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..9a21aab3b 100644 --- a/examples/tutorial/build.gradle.kts +++ b/examples/tutorial/build.gradle.kts @@ -1,14 +1,10 @@ -dependencies { - implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0") - implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.6.0") +val ktorVer = project.properties["ktorVer"] as String - implementation("net.i2p.crypto:eddsa:0.3.0") - implementation("org.bouncycastle:bcprov-jdk15on:1.65") - implementation("com.github.multiformats:java-multihash:1.3.0") +dependencies { + implementation(project(":admin-client")) - implementation(project(":model")) - implementation(project(":block")) - api(project(":admin-client")) + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0") + implementation("io.ktor:ktor-client-logging:$ktorVer") } 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..18bf45336 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,65 +5,79 @@ 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 { - 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(), - ) - val adminKeyPair = keyPairFromHex( - "CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03", - "CCF31D85E3B32A4BEA59987CE0C78E3B8E2DB93881468AB2435FE45D5C9DCD53", - ) - val client = AdminIroha2Client(URL(apiUrl), URL(peerUrl)) - val query = Query(client, admin, adminKeyPair) - query.findAllDomains() - .also { println("ALL DOMAINS: ${it.map { d -> d.id.asString() }}") } - query.findAllAccounts() - .also { println("ALL ACCOUNTS: ${it.map { d -> d.id.asString() }}") } - query.findAllAssets() - .also { println("ALL ASSETS: ${it.map { d -> d.id.asString() }}") } +fun main(): Unit = + runBlocking { + val chainId = UUID.fromString("00000000-0000-0000-0000-000000000000") + val apiUrl = "http://127.0.0.1:8080" + val admin = + AccountId( + "wonderland".asDomainId(), + publicKeyFromHex("CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03").toIrohaPublicKey(), + ) + val adminKeyPair = + keyPairFromHex( + "CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03", + "CCF31D85E3B32A4BEA59987CE0C78E3B8E2DB93881468AB2435FE45D5C9DCD53", + ) + 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() }}") } + query + .findAllAccounts() + .also { println("ALL ACCOUNTS: ${it.map { d -> d.id.asString() }}") } + 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") } + val domain = "looking_glass_${System.currentTimeMillis()}" + sendTransaction.registerDomain(domain).also { println("DOMAIN $domain CREATED") } - val madHatterKeyPair = generateKeyPair() - val madHatter = AccountId(domain.asDomainId(), madHatterKeyPair.public.toIrohaPublicKey()) - sendTransaction.registerAccount(madHatter.asString()) - .also { println("ACCOUNT $madHatter CREATED") } + val madHatterKeyPair = generateKeyPair() + val madHatter = AccountId(domain.asDomainId(), madHatterKeyPair.public.toIrohaPublicKey()) + sendTransaction + .registerAccount(madHatter.asString()) + .also { println("ACCOUNT $madHatter CREATED") } - val assetDefinition = "asset_time_${System.currentTimeMillis()}$ASSET_ID_DELIMITER$domain" - sendTransaction.registerAssetDefinition(assetDefinition, AssetType.numeric()) - .also { println("ASSET DEFINITION $assetDefinition CREATED") } + val assetDefinition = "asset_time_${System.currentTimeMillis()}$ASSET_ID_DELIMITER$domain" + sendTransaction + .registerAssetDefinition(assetDefinition, AssetType.numeric()) + .also { println("ASSET DEFINITION $assetDefinition CREATED") } - val madHatterAsset = AssetId(madHatter, assetDefinition.asAssetDefinitionId()) - sendTransaction.registerAsset(madHatterAsset, AssetValue.Numeric(100.asNumeric())) - .also { println("ASSET $madHatterAsset CREATED") } + val madHatterAsset = AssetId(madHatter, assetDefinition.asAssetDefinitionId()) + sendTransaction + .registerAsset(madHatterAsset, AssetValue.Numeric(100.asNumeric())) + .also { println("ASSET $madHatterAsset CREATED") } - val whiteRabbitKeyPair = generateKeyPair() - val whiteRabbit = AccountId(domain.asDomainId(), whiteRabbitKeyPair.public.toIrohaPublicKey()) - sendTransaction.registerAccount(whiteRabbit.asString()) - .also { println("ACCOUNT $whiteRabbit CREATED") } + val whiteRabbitKeyPair = generateKeyPair() + val whiteRabbit = AccountId(domain.asDomainId(), whiteRabbitKeyPair.public.toIrohaPublicKey()) + sendTransaction + .registerAccount(whiteRabbit.asString()) + .also { println("ACCOUNT $whiteRabbit CREATED") } - val whiteRabbitAsset = AssetId(whiteRabbit, assetDefinition.asAssetDefinitionId()) - sendTransaction.registerAsset(whiteRabbitAsset, AssetValue.Numeric(0.asNumeric())) - .also { println("ASSET $whiteRabbitAsset CREATED") } + val whiteRabbitAsset = AssetId(whiteRabbit, assetDefinition.asAssetDefinitionId()) + sendTransaction + .registerAsset(whiteRabbitAsset, AssetValue.Numeric(0.asNumeric())) + .also { println("ASSET $whiteRabbitAsset CREATED") } - sendTransaction.transferAsset(madHatterAsset, 10, whiteRabbit.asString(), madHatter, madHatterKeyPair) - .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 + .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) - .also { println("$madHatterAsset WAS BURN") } + sendTransaction + .burnAssets(madHatterAsset, BigDecimal(10)) + .also { println("$madHatterAsset WAS BURN") } - query.getAccountAmount(madHatter, madHatterAsset.definition) - .also { println("$madHatterAsset BALANCE: $it AFTER ASSETS BURNING") } -} + query + .getAccountAmount(madHatter, madHatterAsset.definition) + .also { println("$madHatterAsset BALANCE: $it AFTER ASSETS BURNING") } + } 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..570035a4d 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 @@ -14,32 +19,47 @@ open class Query( private val admin: AccountId, private val keyPair: KeyPair, ) { + suspend fun findAllDomains(filter: CompoundPredicateOfDomain? = null) = + client.submit( + QueryBuilder + .findDomains(filter) + .signAs(admin, keyPair), + ) - suspend fun findAllDomains(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllDomains(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 findAllAccounts(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllAccounts(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 findAllAssets(queryFilter: GenericPredicateBox? = null) = QueryBuilder - .findAllAssets(queryFilter) - .account(admin) - .buildSigned(keyPair) - .let { client.sendQuery(it) } - - 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..807208954 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,36 @@ 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, ) { - suspend fun registerDomain( id: String, - metadata: Map = mapOf(), - admin: AccountId = this.admin, - keyPair: KeyPair = this.keyPair, + metadata: Map = mapOf(), ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerDomain(id.asDomainId(), metadata) - buildSigned(keyPair) - }.also { + 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, + metadata: Map = mapOf(), ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - registerAccount(id.asAccountId(), Metadata(metadata)) - buildSigned(keyPair) - }.also { + client.submit(Register.account(id.asAccountId(), Metadata(metadata))).also { withTimeout(timeout) { it.await() } } } @@ -54,17 +38,10 @@ 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() } } } @@ -72,48 +49,27 @@ class SendTransaction( 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 { + 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, + value: BigDecimal, ) { - client.sendTransaction { - account(admin) - chainId(chainUuid) - burnAsset(assetId, value) - buildSigned(keyPair) - }.also { + 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..b9b5bb5ff 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,41 +1,48 @@ 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, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, -) : AdminIroha2Client(urls, httpLogLevel, credentials) { +class AdminIroha2AsyncClient + @JvmOverloads + constructor( + override val apiURL: List, + override val chain: UUID, + override val authority: AccountId, + override val keyPair: KeyPair, + httpLogLevel: LogLevel = LogLevel.NONE, + credentials: String? = null, + ) : AdminIroha2Client(apiURL, chain, authority, keyPair, credentials, httpLogLevel) { + /** + * Send health check request + */ + fun healthAsync() = future { health() } - /** - * Send health check request - */ - fun healthAsync() = future { health() } + /** + * Send status check request + */ + fun statusAsync() = future { status() } - /** - * Send status check request - */ - fun statusAsync() = future { status() } + /** + * Send metrics request + */ + fun metricsAsync() = future { metrics() } - /** - * Send metrics request - */ - fun metricsAsync() = future { metrics() } + /** + * Request current configuration of the peer + */ + fun getConfigsAsync() = future { getConfigs() } - /** - * Request current configuration of the peer - */ - fun getConfigsAsync() = future { getConfigs() } - - /** - * Request description of a configuration property - */ - fun describeConfigAsync(fieldValue: Collection) = future { describeConfig(fieldValue) } -} + /** + * Request description of a configuration property + */ + fun describeConfigAsync(fieldValue: Collection) = future { describeConfig(fieldValue) } + } 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..18f195fe4 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,56 @@ 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,28 +73,12 @@ open class AdminIroha2Client( } private suspend inline fun config(body: B): T { - 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") - } + val response: HttpResponse = + client.get("${getApiURL()}$CONFIGURATION_ENDPOINT") { + contentType(ContentType.Application.Json) + setBody(body) } - url - } - - false -> super.getApiUrl() + return response.body() } 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..2c7e981a0 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 @@ -10,43 +10,43 @@ import kotlin.test.assertEquals @Timeout(120) class ClientTest : IrohaTest() { - @Test @WithIroha - fun schema(): Unit = runBlocking { - val schema = client.schema() - assert(schema.isNotEmpty()) - } + fun schema(): Unit = + runBlocking { + val schema = client.schema() + assert(schema.isNotEmpty()) + } @Test @WithIroha - fun health(): Unit = runBlocking { - val health = client.health() - assert(health == HttpStatusCode.OK.value) - } + fun health(): Unit = + runBlocking { + val health = client.health() + assert(health == HttpStatusCode.OK.value) + } @Test @WithIroha - fun status(): Unit = runBlocking { - val status = client.status() - assertEquals(1, status.blocks) - } + fun status(): Unit = + runBlocking { + val status = client.status() + assertEquals(1, status.blocks) + } @Test @WithIroha - fun metrics(): Unit = runBlocking { - val metrics = client.metrics() - assert(metrics.isNotEmpty()) - } + fun metrics(): Unit = + runBlocking { + val metrics = client.metrics() + assert(metrics.isNotEmpty()) + } @Test @WithIroha - fun getConfigValues(): Unit = runBlocking { - val configs = client.getConfigs() - assert(configs.isNotEmpty()) - } - - companion object { - private const val PEER_AMOUNT = 4 - } + fun getConfigValues(): Unit = + runBlocking { + val configs = client.getConfigs() + assert(configs.isNotEmpty()) + } } 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..4f4dd4c52 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 @@ -19,49 +19,60 @@ import java.nio.file.StandardOpenOption /** * Genesis block is used to initialise a blockchain */ -open class Genesis(open val transaction: RawGenesisTransaction) { +open class Genesis( + open val transaction: RawGenesisTransaction, +) { /** * Write genesis to file */ - fun writeToFile(path: Path): Path = Files.write( - path, - asJson().toByteArray(Charsets.UTF_8), - StandardOpenOption.TRUNCATE_EXISTING, - StandardOpenOption.CREATE, - ) + fun writeToFile(path: Path): Path = + Files.write( + path, + asJson().toByteArray(Charsets.UTF_8), + StandardOpenOption.TRUNCATE_EXISTING, + StandardOpenOption.CREATE, + ) /** * 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() @@ -79,48 +90,54 @@ open class Genesis(open val transaction: RawGenesisTransaction) { return this.sorted() } - private fun MutableSet.sorted() = this.sortedWith( - compareByDescending { instruction -> - when (instruction) { - is InstructionBox.Register -> when (instruction.cast().registerBox) { - is RegisterBox.Domain -> 5 - is RegisterBox.Account -> 4 - is RegisterBox.AssetDefinition -> 3 - is RegisterBox.Role -> 2 - else -> 1 + private fun MutableSet.sorted() = + this.sortedWith( + compareByDescending { instruction -> + when (instruction) { + is InstructionBox.Register -> + when (instruction.cast().registerBox) { + is RegisterBox.Domain -> 5 + is RegisterBox.Account -> 4 + is RegisterBox.AssetDefinition -> 3 + is RegisterBox.Role -> 2 + else -> 1 + } + + else -> -1 } - - else -> -1 - } - }, - ) - - private fun RegisterBox.addMetadata(metadata: Metadata) = when (this) { - is RegisterBox.Account -> RegisterBox.Account( - RegisterOfAccount( - NewAccount(this.registerOfAccount.`object`.id, metadata), - ), + }, ) - is RegisterBox.Domain -> RegisterBox.Domain( - RegisterOfDomain( - NewDomain(this.registerOfDomain.`object`.id, this.registerOfDomain.`object`.logo, metadata), - ), - ) - - is RegisterBox.AssetDefinition -> RegisterBox.AssetDefinition( - RegisterOfAssetDefinition( - NewAssetDefinition( - this.registerOfAssetDefinition.`object`.id, - this.registerOfAssetDefinition.`object`.type, - this.registerOfAssetDefinition.`object`.mintable, - metadata = metadata, - ), - ), - ) - - else -> throw IrohaSdkException("Unexpected type ${this::class}") - } + private fun RegisterBox.addMetadata(metadata: Metadata) = + when (this) { + is RegisterBox.Account -> + RegisterBox.Account( + RegisterOfAccount( + NewAccount(this.registerOfAccount.`object`.id, metadata), + ), + ) + + is RegisterBox.Domain -> + RegisterBox.Domain( + RegisterOfDomain( + NewDomain(this.registerOfDomain.`object`.id, this.registerOfDomain.`object`.logo, metadata), + ), + ) + + is RegisterBox.AssetDefinition -> + RegisterBox.AssetDefinition( + RegisterOfAssetDefinition( + NewAssetDefinition( + this.registerOfAssetDefinition.`object`.id, + this.registerOfAssetDefinition.`object`.type, + this.registerOfAssetDefinition.`object`.mintable, + metadata = metadata, + ), + ), + ) + + else -> throw IrohaSdkException("Unexpected type ${this::class}") + } private fun MutableMap.putMergedMetadata(idBox: RegisterBox) { fun MutableMap.putOrMerge( @@ -141,10 +158,11 @@ open class Genesis(open val transaction: RawGenesisTransaction) { when (idBox) { is RegisterBox.Account -> this.putOrMerge(idBox.registerOfAccount.`object`.id, idBox.registerOfAccount.`object`.metadata) is RegisterBox.Domain -> this.putOrMerge(idBox.registerOfDomain.`object`.id, idBox.registerOfDomain.`object`.metadata) - is RegisterBox.AssetDefinition -> this.putOrMerge( - idBox.registerOfAssetDefinition.`object`.id, - idBox.registerOfAssetDefinition.`object`.metadata, - ) + is RegisterBox.AssetDefinition -> + this.putOrMerge( + idBox.registerOfAssetDefinition.`object`.id, + idBox.registerOfAssetDefinition.`object`.metadata, + ) else -> {} } @@ -161,9 +179,15 @@ open class Genesis(open val transaction: RawGenesisTransaction) { instruction.cast().registerBox }.onSuccess { idBox -> when (idBox) { - is RegisterBox.Account -> idBox.registerOfAccount.`object`.id.let { id -> id to metadata[id]!! } - is RegisterBox.Domain -> idBox.registerOfDomain.`object`.id.let { id -> id to metadata[id]!! } - is RegisterBox.AssetDefinition -> idBox.registerOfAssetDefinition.`object`.id.let { id -> id to metadata[id]!! } + is RegisterBox.Account -> + idBox.registerOfAccount.`object`.id + .let { id -> id to metadata[id]!! } + is RegisterBox.Domain -> + idBox.registerOfDomain.`object`.id + .let { id -> id to metadata[id]!! } + is RegisterBox.AssetDefinition -> + idBox.registerOfAssetDefinition.`object`.id + .let { id -> id to metadata[id]!! } else -> null }?.takeIf { it.second.sortedMapOfName.isNotEmpty() }?.let { isiToReplace.merge(it, mutableListOf(instruction.cast())) { old, new -> diff --git a/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/DeserializerTest.kt b/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/DeserializerTest.kt index b962eadfa..04cfb582c 100644 --- a/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/DeserializerTest.kt +++ b/modules/block/src/test/kotlin/jp/co/soramitsu/iroha2/DeserializerTest.kt @@ -50,7 +50,8 @@ class DeserializerTest { private fun removeWhiteSpacesAndReplacePubKey(json: String): String { val regex = "(\"ed01)+\\w+\"".toRegex() - return json.replace(System.getProperty("line.separator"), "") + return json + .replace(System.getProperty("line.separator"), "") .replace(" ", "") .replace(regex, "publicKey") } 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..c68a03b7e 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,92 @@ 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 genesis = Genesis( - RawGenesisTransaction( - ChainId("00000000-0000-0000-0000-000000000000"), - Genesis.EXECUTOR_FILE_NAME, - 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 = """ + 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(), + 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 +102,13 @@ class SerializerTest { } } ], + "wasm_dir": "", + "wasm_triggers": [], "topology": [] } - """.trimIndent() + """.trimIndent() - val json = JSON_SERDE.writeValueAsString(genesis.transaction).trimIndent() + val json = JSON_SERDE.writeValueAsString(genesis.transaction) assertEquals(expectedJson.lowercase(), json.asPrettyJson().lowercase()) } @@ -64,51 +117,88 @@ class SerializerTest { val triggerId = TriggerId(name = Name("time_trigger")) val aliceAccountId = "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03${ACCOUNT_ID_DELIMITER}wonderland".asAccountId() - val assetId = AssetId( - aliceAccountId, - AssetDefinitionId("wonderland".asDomainId(), "xor".asName()), - ) - val genesis = Genesis( - RawGenesisTransaction( - ChainId("00000000-0000-0000-0000-000000000000"), - Genesis.EXECUTOR_FILE_NAME, - emptyList(), - listOf( - Instructions.mintAsset(assetId, 100), - Instructions.setKeyValue(assetId, "key".asName(), "value"), - Instructions.registerTrigger( - triggerId, - listOf(Instructions.mintAsset(assetId, 1)), - Repeats.Indefinitely(), - aliceAccountId, - Metadata(mapOf()), - EventFilters.timeEventFilter( - BigInteger.valueOf(1715676978L), - BigInteger.valueOf(1L), - ), + val assetId = + AssetId( + aliceAccountId, + AssetDefinitionId("wonderland".asDomainId(), "xor".asName()), + ) + 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( + Mint.asset(assetId, BigDecimal(100)).asInstructionBox(), + SetKeyValue.asset(assetId, "key".asName(), "value").asInstructionBox(), + Register + .trigger( + triggerId, + listOf(Mint.asset(assetId, BigDecimal(1))), + Repeats.Indefinitely(), + aliceAccountId, + EventFilterBox.Time( + EventFilters.timeEventFilter( + BigInteger.valueOf(1715676978L), + BigInteger.valueOf(1L), + ), + ), + Metadata(mapOf(Pair("key".asName(), Json.writeValue("value")))), + ).asInstructionBox(), ), + "", + emptyList(), + emptyList(), ), - emptyList(), - ), - ) - val expectedJson = """ + ) + 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 +210,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 +231,28 @@ 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()) + """.trimIndent() + 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..37d15a22c 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,13 +5,18 @@ 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 */ -class WebSocketProtocolException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) +class WebSocketProtocolException( + message: String? = null, + cause: Throwable? = null, +) : IrohaSdkException(message, cause) /** * Throw if a peer is not available or status code not 2xx @@ -25,15 +30,7 @@ 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/Extensions.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt deleted file mode 100644 index 947874311..000000000 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt +++ /dev/null @@ -1,390 +0,0 @@ -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 net.i2p.crypto.eddsa.EdDSAEngine -import org.bouncycastle.jcajce.provider.digest.Blake2b -import org.bouncycastle.util.encoders.Hex -import java.math.BigDecimal -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 - -fun BlockSubscriptionRequest.Companion.of(from: Long) = BlockSubscriptionRequest(NonZeroOfu64(BigInteger.valueOf(from))) - -fun Signature.asSignatureOf() = SignatureOf(this) - -fun String.asAccountId() = this.split(ACCOUNT_ID_DELIMITER).takeIf { - it.size == 2 -}?.let { parts -> - AccountId(parts[1].asDomainId(), publicKeyFromHex(parts[0]).toIrohaPublicKey()) -} ?: throw IllegalArgumentException("Incorrect account ID: $this") - -fun String.asAssetDefinitionId() = this.split(ASSET_ID_DELIMITER).takeIf { - it.size == 2 -}?.let { parts -> - AssetDefinitionId(parts[1].asDomainId(), parts[0].asName()) -} ?: throw IllegalArgumentException("Incorrect asset definition ID: $this") - -fun String.asAssetId() = this.split(ASSET_ID_DELIMITER).takeIf { - it.size == 3 -}?.let { parts -> - parts[2].asAccountId().let { accountId -> - val domainId = parts[1].takeIf { it.isNotBlank() }?.asDomainId() - - AssetId( - accountId, - AssetDefinitionId( - domainId ?: accountId.domain, - parts[0].asName(), - ), - ) - } -} ?: throw IllegalArgumentException("Incorrect asset ID: $this") - -fun String.asDomainId() = DomainId(Name(this)) - -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" - false -> "" - } - "${prefix}${Hex.toHexString(this)}" -} catch (ex: Exception) { - throw HexCodecException("Cannot encode to hex string", ex) -} - -fun String.fromHex(): ByteArray = try { - Hex.decode(this) -} catch (ex: Exception) { - throw HexCodecException("Cannot decode from hex string `$this`", ex) -} - -/** - * Convert a public key to an Iroha public key - */ -fun PublicKey.toIrohaPublicKey(): IrohaPublicKey { - return 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 { - val sgr = EdDSAEngine(MessageDigest.getInstance(DEFAULT_SPEC.hashAlgorithm)) - sgr.initSign(this) - sgr.update(message.hash()) - sgr.sign() -} catch (ex: Exception) { - throw CryptoException("Cannot sign message", ex) -} - -/** - * Verify the [signature] against the [message] and the given public key - * - * Note: the message must not be prehashed - */ -fun PublicKey.verify(signature: ByteArray, message: ByteArray): Boolean = try { - val sgr = EdDSAEngine(MessageDigest.getInstance(DEFAULT_SPEC.hashAlgorithm)) - sgr.initVerify(this) - sgr.update(message.hash()) - sgr.verify(signature) -} catch (ex: Exception) { - throw CryptoException("Cannot verify message", ex) -} - -fun ByteArray.toIrohaHash(): Hash { - if (this.size != 32) throw IrohaSdkException("Hash byte array size must be 32") - - this[31] = this[31] or 1 - return Hash(this) -} - -fun ByteArray.asHashOf() = HashOf(this.toIrohaHash()) - -fun ByteArray.hash(): ByteArray { - val bytes = Blake2b.Blake2b256().digest(this) - bytes[bytes.size - 1] = bytes[bytes.size - 1] or 1 - return bytes -} - -/** - * Hash the given versioned transaction. Maintains only `VersionedTransaction.V1` - */ -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}`") -} - -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 - -fun DomainId.asJsonString() = "{\"domain\": \"${this.name.string}\"}" - -fun RoleId.asString() = this.name.string - -fun RoleId.asJsonString() = "{\"role\": \"${this.name.string}\"}" - -fun String.fromJsonString() = when { - this.startsWith("\"") && this.endsWith("\"") -> this.drop(1).dropLast(1) - else -> this -} - -fun SocketAddr.asString() = when (this) { - is SocketAddr.Host -> this.socketAddrHost.let { "${it.host}:${it.port}" } - is SocketAddr.Ipv4 -> this.socketAddrV4.let { "${it.ip}:${it.port}" } - is SocketAddr.Ipv6 -> this.socketAddrV6.let { "${it.ip}:${it.port}" } -} - -fun TriggerId.asString() = this.name.string - -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 - is IdBox.AssetId -> this.assetId - is IdBox.AssetDefinitionId -> this.assetDefinitionId - is IdBox.DomainId -> this.domainId - is IdBox.TriggerId -> this.triggerId - is IdBox.PeerId -> this.peerId - is IdBox.CustomParameterId -> this.customParameterId - is IdBox.Permission -> this.permission -} - -fun InstructionBox.extractAccount() = this - .cast() - .registerBox - .cast() - .registerOfAccount.`object` - -fun InstructionBox.Register.extractAccount() = this - .registerBox - .cast() - .registerOfAccount.`object` - -fun InstructionBox.Register.extractDomain() = this - .cast() - .registerBox - .cast() - .registerOfDomain.`object` - -fun InstructionBox.Register.extractAssetDefinition() = this - .cast() - .registerBox - .cast() - .registerOfAssetDefinition.`object` - -inline fun SignedTransaction.extractInstruction(): I = this - .cast() - .extractInstruction() - -inline fun SignedTransaction.V1.extractInstruction() = this - .extractInstructionVec() - .first().cast() - -inline fun SignedTransaction.V1.extractInstructions() = this - .extractInstructionVec() - .cast>() - -inline fun SignedTransaction.V1.extractInstructionVec() = this - .signedTransactionV1.payload.instructions - .cast() - .vec.filterIsInstance() - -fun InstructionBox.SetKeyValue.extractDomainId() = this - .cast() - .setKeyValueBox - .cast() - .setKeyValueOfDomain - .`object` - -fun InstructionBox.Grant.extractValuePermissionToken() = this - .cast() - .grantBox - .cast() - .grantOfPermissionAndAccount - .`object` - -fun EventFilterBox.extractSchedule() = this - .cast() - .timeEventFilter.executionTime - .cast().schedule - -fun BlockMessage.extractBlock() = this.signedBlock.cast().signedBlockV1.payload - -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() - is FindError.AssetDefinition -> this.assetDefinitionId.asString() - is FindError.Domain -> this.domainId.asString() - 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.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() - is BigInteger -> this.asNumeric() - is Double -> this.asNumeric() - is BigDecimal -> this.asNumeric() - else -> throw IrohaSdkException("Unexpected type to extract numeric ${this::class}") -} - -fun String.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) - -fun Int.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) - -fun Long.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) - -fun BigInteger.asNumeric() = Numeric(mantissa = this, scale = 0) - -fun Double.asNumeric() = this.toBigDecimal().asNumeric() - -fun BigDecimal.asNumeric() = Numeric(mantissa = this.unscaledValue(), scale = this.scale().toLong()) - -fun Numeric.asInt() = this.mantissa.toInt() - -fun Numeric.asLong() = this.mantissa.toLong() - -fun Numeric.asBigInteger() = this.mantissa - -fun Numeric.asBigDecimal() = BigDecimal.valueOf(this.mantissa.toLong(), this.scale.toInt()) - -fun Numeric.asNumber() = when (this.scale) { - 0L -> this.mantissa - else -> this.asBigDecimal() -} - -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) -} 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..fc7bce962 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,275 @@ 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 domain from a [QueryResponse] + */ +object DomainOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Domain? = DomainsExtractor.extract(result).firstOrNull() } /** - * Extract a trigger from a query [result] + * Extract a lost of peers from a [QueryResponse] */ -object TriggerBoxExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): Trigger { - return extractIdentifiable( - result.cast().batchedResponseV1.batch, - 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 triggers from a query [result] + * Extract a trigger from a [QueryResponse] */ -object TriggerBoxesExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Trigger::trigger) - } - } +object TriggerExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Trigger = TriggersExtractor.extract(result).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 TriggerOrNullExtractor : ResultExtractor { + override fun extract(result: QueryResponse): Trigger? = TriggersExtractor.extract(result).firstOrNull() } /** - * Extract a list of permission tokens from a query [result] + * Extract a list of triggers from a [QueryResponse] */ -object PermissionTokensExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Permission::permission) - } - } +object TriggersExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = + extract( + result + .cast() + .queryOutput.batch.tuple + .takeIf { it.size == 1 }!! + .first(), + ) } /** - * Extract a permission token schema from a query [result] + * Extract a list of trigger IDs from a [QueryResponse] */ -object ExecutorDataModelExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): ExecutorDataModel { - return extractValue(result.cast().batchedResponseV1.batch, QueryOutputBox.ExecutorDataModel::executorDataModel) - } +object TriggerIdsExtractor : 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 list of permission tokens from a [QueryResponse] + */ +object PermissionTokensExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = + extract( + result + .cast() + .queryOutput.batch.tuple + .takeIf { it.size == 1 }!! + .first(), + ) } /** -* 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) - } + * Extract a list of commited transactions from a [QueryResponse] + */ +object TransactionsExtractor : ResultExtractor> { + override fun extract(result: QueryResponse): List = + extract( + result + .cast() + .queryOutput.batch.tuple + .takeIf { it.size == 1 }!! + .first(), + ) } object BlocksValueExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Block::signedBlock) - } - } + override fun extract(result: QueryResponse): List = + extract( + result + .cast() + .queryOutput.batch.tuple + .takeIf { it.size == 1 }!! + .first(), + ) } 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 `String` from a query [result] - */ -object StringExtractor : ResultExtractor { - override fun extract(result: BatchedResponse): String { - return result.cast().batchedResponseV1.batch - .cast().string - .fromJsonString() - } + 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 roles from a [QueryResponse] */ object RolesExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractIdentifiable(it, IdentifiableBox.Role::role) - } - } -} - -/** - * 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) - } + 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] + * Extract a list of role IDs from a [QueryResponse] */ object RoleIdsExtractor : ResultExtractor> { - override fun extract(result: BatchedResponse): List { - return extractVec(result.cast().batchedResponseV1.batch) { - extractValue(it, QueryOutputBox.Id::idBox).cast().roleId - } - } -} - -/** - * Extract one of the [IdentifiableBox] objects from value - * - * @param downstream Type to extract - */ -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}`", + 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 */ -inline fun extractVec(value: QueryOutputBox, downstream: (QueryOutputBox) -> R): List { +inline fun extract(value: QueryOutputBatchBox): 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}`", - ) - } -} + 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>() -/** - * Extract value - * - * @param downstream Type to extract - */ -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}`", + "Unexpected type `${value::class.qualifiedName}`", ) } -} diff --git a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/SingletonHolder.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/SingletonHolder.kt index af8ee427b..7078ad4a4 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/SingletonHolder.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/SingletonHolder.kt @@ -1,7 +1,8 @@ package jp.co.soramitsu.iroha2 -open class SingletonHolder(private val creator: (A) -> T) { - +open class SingletonHolder( + private val creator: (A) -> T, +) { @Volatile private var instance: T? = null 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..cb64d4fa6 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,48 @@ 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, - httpLogLevel: LogLevel = LogLevel.NONE, - credentials: String? = null, - eventReadTimeoutInMills: Long = 250, - eventReadMaxAttempts: Int = 10, -) : Iroha2Client(urls, httpLogLevel, credentials, eventReadTimeoutInMills, eventReadMaxAttempts) { +class Iroha2AsyncClient + @JvmOverloads + constructor( + 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(apiURL, chain, authority, keyPair, credentials, httpLogLevel, eventReadTimeoutInMills, eventReadMaxAttempts) { + /** + * Send a request to Iroha2 and extract payload. + * {@see Extractors} + */ + fun sendQueryAsync(queryAndExtractor: QueryAndExtractor): CompletableFuture = + future { + submit(queryAndExtractor) + } - /** - * Send a request to Iroha2 and extract payload. - * {@see Extractors} - */ - fun sendQueryAsync( - queryAndExtractor: QueryAndExtractor, - ): CompletableFuture = future { - sendQuery(queryAndExtractor) + /** + * Send a transaction to an Iroha peer and wait until it is committed or rejected. + */ + fun sendTransactionAsync(transaction: SignedTransaction): Future = + runBlocking { + submit(transaction).asCompletableFuture() + } } - - /** - * Send a transaction to an Iroha peer and wait until it is committed or rejected. - */ - fun sendTransactionAsync( - transaction: SignedTransaction, - ): CompletableFuture = runBlocking { - sendTransaction { 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..84f36be8a 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,40 @@ 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( + 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,147 +192,52 @@ 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") { - setBody(SignedTransaction.encode(signedTransaction)) - } + val response: HttpResponse = + client.post("${getApiURL()}${TRANSACTION_ENDPOINT}") { + setBody(SignedTransaction.encode(signedTransaction)) + } response.body() return hash } /** - * 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}`", + ) } - } - - /** - * @see subscribeToBlockStream below - */ - @JvmOverloads - fun subscribeToBlockStream( - from: Long = 1, - count: Long, - autoStart: Boolean = true, - ): Pair, BlockStreamSubscription> = subscribeToBlockStream( - from, - onBlock = { block -> block }, - cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(from + count - 1) }, - autoStart = autoStart, - ) - /** - * Subscribe to block streaming. Returns null if the subscription has already been received - * - * @param from - block number to start from - * @param onBlock - the code that will be invoked after a new block received - * @param onFailure - the code that will be invoked on exception throwing - * @param cancelIf - if the condition returns true then the channel will be closed - * @param onClose - the code that will be invoked right before closing - */ - @JvmOverloads - fun subscribeToBlockStream( - from: Long = 1, - onBlock: (block: BlockMessage) -> Any, - onFailure: suspend (t: Throwable) -> Unit = { throwable -> - logger.error("Block stream was closed with an exception: {}", throwable.message) - }, - cancelIf: suspend (block: BlockMessage) -> Boolean = { false }, - onClose: () -> Unit = { logger.info("Block stream subscription execution was finished") }, - autoStart: Boolean = true, - ): Pair, BlockStreamSubscription> = subscribeToBlockStream( - from, - listOf( - BlockStreamStorage( - onBlock, - cancelIf, - onFailure, + private fun eventSubscriberMessageOf(hash: ByteArray) = + EventSubscriptionRequest( + listOf( + EventFilterBox.Pipeline(PipelineEventFilterBox.Transaction(TransactionEventFilter(hash.asHashOf()))), + EventFilterBox.Pipeline(PipelineEventFilterBox.Block(BlockEventFilter(status = BlockStatus.Applied()))), ), - ), - onClose, - autoStart, - ) - - /** - * Subscribe to block streaming. Returns null if the subscription has already been received - * - * @param from - block number to start from - * @param blockStreamStorages - wrapper for the code blocks that represent logic - * of a block received processing, cancellation condition and error processing - * @param onClose - the code that will be invoked right before closing - * @param autoStart - whether websocket is going to be receiving blocks immediately, - * otherwise calling 'start' method required - */ - @JvmOverloads - fun subscribeToBlockStream( - from: Long = 1, - blockStreamStorages: Iterable, - onClose: () -> Unit = { logger.info("Block stream subscription execution was finished") }, - autoStart: Boolean = true, - ): Pair, BlockStreamSubscription> { - val context = BlockStreamContext( - getApiUrl(), - client, - from, - blockStreamStorages, - onClose, ) - return blockStreamStorages to BlockStreamSubscription.getInstance(context) - .apply { if (autoStart) start() } - } /** - * Subscribe to track the transaction status + * Extract the rejection reason */ - 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") { - if (cursor != null) { - parameter("query", cursor.query) - parameter("cursor", cursor.cursor?.u64) - } else { - setBody(SignedQuery.encode(queryAndExtractor.query)) - } + 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() } - 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 @@ -362,125 +246,184 @@ open class Iroha2Client( private fun subscribeToTransactionStatus( hash: ByteArray, afterSubscription: (() -> Unit)? = null, - ): CompletableDeferred { + ): 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 apiUrl = getApiUrl() + val currApiURL = getApiURL() launch { client.webSocket( - host = apiUrl.host, - port = apiUrl.port, + host = currApiURL.host, + port = currApiURL.port, path = WS_ENDPOINT, ) { logger.debug("WebSocket opened") - send(payload.toFrame()) + 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 income = readMessage(incoming.receive()) - val processed = pipelineEventProcess(income, hash, hexHash) - if (processed != null) { - result.complete(processed) - break + 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 - } - - 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 - } - else -> throw WebSocketProtocolException( - "Expected message with type ${EventBox.Pipeline::class.qualifiedName}, " + - "but was ${event::class.qualifiedName}", - ) - } + return result } /** - * Extract the rejection reason + * @see blocks below */ - 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() - } + @JvmOverloads + fun blocks( + from: Long = 1, + count: Long, + autoStart: Boolean = true, + ): Pair, BlockStreamSubscription> = + blocks( + from, + onBlock = { block -> block }, + cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(from + count - 1) }, + autoStart = autoStart, + ) /** - * Read the message from the frame + * Subscribe to block streaming. Returns null if the subscription has already been received + * + * @param from - block number to start from + * @param onBlock - the code that will be invoked after a new block received + * @param onFailure - the code that will be invoked on exception throwing + * @param cancelIf - if the condition returns true then the channel will be closed + * @param onClose - the code that will be invoked right before closing */ - 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}`", + @JvmOverloads + fun blocks( + from: Long = 1, + onBlock: (block: BlockMessage) -> Any, + onFailure: suspend (t: Throwable) -> Unit = { throwable -> + logger.error("Block stream was closed with an exception: {}", throwable.message) + }, + cancelIf: suspend (block: BlockMessage) -> Boolean = { false }, + onClose: () -> Unit = { logger.info("Block stream subscription execution was finished") }, + autoStart: Boolean = true, + ): Pair, BlockStreamSubscription> = + blocks( + from, + listOf( + BlockStreamStorage( + onBlock, + cancelIf, + onFailure, + ), + ), + onClose, + autoStart, ) + + /** + * Subscribe to block streaming. Returns null if the subscription has already been received + * + * @param from - block number to start from + * @param blockStreamStorages - wrapper for the code blocks that represent logic + * of a block received processing, cancellation condition and error processing + * @param onClose - the code that will be invoked right before closing + * @param autoStart - whether websocket is going to be receiving blocks immediately, + * otherwise calling 'start' method required + */ + @JvmOverloads + 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(), + client, + from, + blockStreamStorages, + onClose, + ) + return blockStreamStorages to + BlockStreamSubscription + .getInstance(context) + .apply { if (autoStart) start() } } - private fun eventSubscriberMessageOf( - hash: ByteArray, - ) = EventSubscriptionRequest( - listOf(Filters.pipelineTransaction(hash)), - ) + 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) + } else { + setBody(SignedQuery.encode(query)) + } + } + return response.body().let { QueryResponse.decode(it) }.cast() + } - object DurationDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Duration { + private object DurationDeserializer : JsonDeserializer() { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Duration { val pairs: Map = p.readValueAs(object : TypeReference>() {}) - val seconds = pairs["secs"] ?: throw JsonMappingException.from( - p, - "Expected `secs` item for duration deserialization", - ) - val nanos = pairs["nanos"] ?: throw JsonMappingException.from( - p, - "Expected `nanos` item for duration deserialization", - ) + val seconds = + pairs["secs"] ?: throw JsonMappingException.from( + p, + "Expected `secs` item for duration deserialization", + ) + val nanos = + pairs["nanos"] ?: throw JsonMappingException.from( + p, + "Expected `nanos` item for duration deserialization", + ) return Duration.ofSeconds(seconds, nanos) } } 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..8ed2bf5ab 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,27 +1,27 @@ 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 } - else -> { - lastRequestedPeerIdx = when (lastRequestedPeerIdx) { - urls.size - 1 -> 0 - else -> lastRequestedPeerIdx!! + 1 + private fun getUrls() = + when (lastRequestedPeerIdx) { + null -> urls.first().also { lastRequestedPeerIdx = 0 } + else -> { + lastRequestedPeerIdx = + when (lastRequestedPeerIdx) { + urls.size - 1 -> 0 + else -> lastRequestedPeerIdx!! + 1 + } + urls[lastRequestedPeerIdx!!] } - urls[lastRequestedPeerIdx!!] } - } } 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..b3675b79f 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 @@ -3,8 +3,8 @@ package jp.co.soramitsu.iroha2.client.balancing 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 +open class WithoutBalancingStrategy( + private val urls: List, +) : BalancingStrategy { + 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..d08f4112c 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 @@ -37,8 +37,8 @@ import kotlin.coroutines.CoroutineContext open class BlockStreamSubscription private constructor( private val context: BlockStreamContext, -) : CoroutineScope, AutoCloseable { - +) : CoroutineScope, + AutoCloseable { override val coroutineContext: CoroutineContext = Dispatchers.IO open val logger: Logger = LoggerFactory.getLogger(javaClass) @@ -72,12 +72,18 @@ open class BlockStreamSubscription private constructor( logger.debug("Block stream subscription has been expanded. Updated number of channels is ${source.size}") } - fun subscribeAndReceive(storage: BlockStreamStorage, collector: FlowCollector) { + fun subscribeAndReceive( + storage: BlockStreamStorage, + collector: FlowCollector, + ) { subscribe(storage) receive(storage.id, collector) } - fun receive(actionId: UUID, collector: FlowCollector) = launch { + fun receive( + actionId: UUID, + collector: FlowCollector, + ) = launch { receive(actionId).collect(collector) } @@ -88,74 +94,77 @@ open class BlockStreamSubscription private constructor( } } - suspend fun stop() = withContext(NonCancellable) { - if (!stopped.getAndSet(true)) { - runJob.cancelAndJoin() - destroy() // singleton instance of subscription - logger.info("Unsubscribed from block streaming") + suspend fun stop() = + withContext(NonCancellable) { + if (!stopped.getAndSet(true)) { + runJob.cancelAndJoin() + destroy() // singleton instance of subscription + logger.info("Unsubscribed from block streaming") + } + logger.warn("Block streaming is already closed") } - logger.warn("Block streaming is already closed") - } override fun close() = runBlocking { stop() } @OptIn(DelicateCoroutinesApi::class) - private fun run() = launch { - val request = BlockSubscriptionRequest( - NonZeroOfu64( - BigInteger.valueOf(context.from), - ), - ) - context.client.webSocket( - host = context.apiUrl.host, - port = context.apiUrl.port, - path = Iroha2Client.WS_ENDPOINT_BLOCK_STREAM, - method = HttpMethod.Get, - ) { - try { - logger.debug("WebSocket opened") - send(BlockSubscriptionRequest.encode(request).toFrame()) - val idsToRemove = mutableListOf() - - for (frame in incoming) { - logger.debug("Received frame: {}", frame) - - val block = BlockMessage.decode(frame.readBytes()) - source.forEach { (id, storage) -> - logger.debug("Executing {} action", id) - val result = storage.onBlock(block) - logger.debug("{} action result: {}", id, result) - - val channel = storage.channel.value - when (channel.isClosedForSend) { - true -> logger.warn("Block stream channel#{} is already closed, not sending the action result", id) - false -> channel.send(result) + private fun run() = + launch { + val request = + BlockSubscriptionRequest( + NonZeroOfu64( + BigInteger.valueOf(context.from), + ), + ) + context.client.webSocket( + host = context.apiUrl.host, + port = context.apiUrl.port, + path = Iroha2Client.WS_ENDPOINT_BLOCK_STREAM, + method = HttpMethod.Get, + ) { + try { + logger.debug("WebSocket opened") + send(Frame.Binary(true, BlockSubscriptionRequest.encode(request))) + val idsToRemove = mutableListOf() + + for (frame in incoming) { + logger.debug("Received frame: {}", frame) + + val block = BlockMessage.decode(frame.readBytes()) + source.forEach { (id, storage) -> + logger.debug("Executing {} action", id) + val result = storage.onBlock(block) + logger.debug("{} action result: {}", id, result) + + val channel = storage.channel.value + when (channel.isClosedForSend) { + true -> logger.warn("Block stream channel#{} is already closed, not sending the action result", id) + false -> channel.send(result) + } + if (storage.cancelIf?.let { it(block) } == true) { + // idempotent + channel.close() + idsToRemove.add(id) + logger.info("Block stream channel#{} is closed and scheduled for removal", id) + } } - if (storage.cancelIf?.let { it(block) } == true) { - // idempotent - channel.close() - idsToRemove.add(id) - logger.info("Block stream channel#{} is closed and scheduled for removal", id) + if (idsToRemove.isNotEmpty()) { + idsToRemove.forEach { + source.remove(it) + logger.info("Block stream channel#{} is removed", it) + } + idsToRemove.clear() } } - if (idsToRemove.isNotEmpty()) { - idsToRemove.forEach { - source.remove(it) - logger.info("Block stream channel#{} is removed", it) - } - idsToRemove.clear() - } + } catch (e: CancellationException) { + logger.info("Closing subscription WS") + this.close() + source.values.forEach { it.channel.value.close() } + return@webSocket + } finally { + context.onClose() } - } catch (e: CancellationException) { - logger.info("Closing subscription WS") - this.close() - source.values.forEach { it.channel.value.close() } - return@webSocket - } finally { - context.onClose() } } - } companion object : SingletonHolder(::BlockStreamSubscription) } 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..92dfbcda0 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,14 @@ package jp.co.soramitsu.iroha2.model +import java.net.URI import java.net.URL -data class IrohaUrls(val apiUrl: URL, val peerUrl: 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/model/Page.kt b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/Page.kt index 43b783bc9..78cf2139e 100644 --- a/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/Page.kt +++ b/modules/client/src/main/kotlin/jp/co/soramitsu/iroha2/model/Page.kt @@ -5,4 +5,7 @@ import java.math.BigInteger /** * Pages contain query results with extracted [data]. */ -data class Page(val data: T, val total: BigInteger) +data class Page( + val data: T, + val total: BigInteger, +) 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..22dadf7b6 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,265 @@ 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] + * Return all peers (peers are identified by their public key) */ - fun findAccountById(accountId: AccountId) = QueryBox.FindAccountById(FindAccountById(accountId)) + fun findPeers(predicate: CompoundPredicateOfPeerId? = null) = + QueryBox.FindPeers( + QueryWithFilterOfFindPeers( + FindPeers(), + predicate ?: CompoundPredicateOfPeerId.And(emptyList()), + SelectorTupleOfPeerId( + listOf( + PeerIdProjectionOfSelectorMarker.Atom(), + ), + ), + ), + ) /** - * Return the value keyed by the provided [Name] for the given [AccountId] + * Return all domains */ - 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), - ) - - /** - * Search the domain with the [DomainId] for assets that have the given [AssetDefinitionId] - */ - 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()) + fun findAssetsDefinitions(predicate: CompoundPredicateOfAssetDefinition? = null) = + QueryBox.FindAssetsDefinitions( + QueryWithFilterOfFindAssetsDefinitions( + FindAssetsDefinitions(), + predicate ?: CompoundPredicateOfAssetDefinition.And(emptyList()), + SelectorTupleOfAssetDefinition(listOf(AssetDefinitionProjectionOfSelectorMarker.Atom())), + ), + ) /** - * Return the asset quantity for the given asset with [AssetId] + * Return all accounts */ - fun findAssetQuantityById(assetId: AssetId) = QueryBox.FindAssetQuantityById( - FindAssetQuantityById(assetId), - ) + fun findAccounts(predicate: CompoundPredicateOfAccount? = null) = + QueryBox.FindAccounts( + QueryWithFilterOfFindAccounts( + FindAccounts(), + predicate ?: CompoundPredicateOfAccount.And(emptyList()), + SelectorTupleOfAccount(listOf(AccountProjectionOfSelectorMarker.Atom())), + ), + ) /** - * Return the asset quantity for the given asset with [AssetDefinitionId] + * Return all accounts that contain an asset of the given definition */ - fun findTotalAssetQuantityByAssetDefinitionId( + fun findAccountsWithAsset( 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, + predicate: CompoundPredicateOfAccount? = null, + ) = QueryBox.FindAccountsWithAsset( + QueryWithFilterOfFindAccountsWithAsset( + FindAccountsWithAsset(definitionId), + predicate ?: CompoundPredicateOfAccount.And(emptyList()), + SelectorTupleOfAccount(listOf(AccountProjectionOfSelectorMarker.Atom())), ), ) /** - * Return the asset definition corresponding to the given [AssetDefinitionId] - */ - fun findAssetDefinitionById(definitionId: AssetDefinitionId) = QueryBox.FindAssetDefinitionById( - FindAssetDefinitionById(definitionId), - ) - - /** - * Return all known registered domains + * Return the all assets */ - fun findAllDomains() = QueryBox.FindAllDomains(FindAllDomains()) - - /** - * Return the domain corresponding to the given [DomainId] - */ - 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(), + fun findPermissionsByAccountId( + accountId: AccountId, + predicate: CompoundPredicateOfPermission? = null, + ) = QueryBox.FindPermissionsByAccountId( + QueryWithFilterOfFindPermissionsByAccountId( + FindPermissionsByAccountId(accountId), + predicate ?: CompoundPredicateOfPermission.And(emptyList()), + SelectorTupleOfPermission( + listOf( + PermissionProjectionOfSelectorMarker.Atom(), + ), + ), + ), ) /** - * Return the transaction by [Hash] + * Return the full set of roles */ - fun findTransactionByHash(hash: Hash) = QueryBox.FindTransactionByHash( - FindTransactionByHash(HashOf(hash)), - ) + 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), - ) - - /** - * Return the value corresponding to the given key [Name] in the metadata of the trigger with the given [TriggerId] - */ - fun findTriggerKeyValueByIdAndKey(id: TriggerId, key: Name) = QueryBox.FindTriggerKeyValueByIdAndKey( - FindTriggerKeyValueByIdAndKey(id, key), + fun findRolesByAccountId( + accountId: AccountId, + predicate: CompoundPredicateOfRoleId? = null, + ) = QueryBox.FindRolesByAccountId( + QueryWithFilterOfFindRolesByAccountId( + FindRolesByAccountId(accountId), + predicate ?: CompoundPredicateOfRoleId.And(emptyList()), + SelectorTupleOfRoleId(listOf(RoleIdProjectionOfSelectorMarker.Atom())), + ), ) /** - * Return the trigger with the given [TriggerId] + * Return all currently triggers */ - fun findTriggerById(id: TriggerId) = QueryBox.FindTriggerById(FindTriggerById(id)) + fun findTriggers(predicate: CompoundPredicateOfTrigger? = null) = + QueryBox.FindTriggers( + QueryWithFilterOfFindTriggers( + FindTriggers(), + predicate ?: CompoundPredicateOfTrigger.And(emptyList()), + SelectorTupleOfTrigger(listOf(TriggerProjectionOfSelectorMarker.Atom())), + ), + ) /** - * Return all currently active triggers, that have not expired at the time of the query + * Return all active trigger IDs */ - fun findAllActiveTriggerIds() = QueryBox.FindAllActiveTriggerIds(FindAllActiveTriggerIds()) + fun findActiveTriggerIds(predicate: CompoundPredicateOfTriggerId? = null) = + QueryBox.FindActiveTriggerIds( + QueryWithFilterOfFindActiveTriggerIds( + FindActiveTriggerIds(), + predicate ?: CompoundPredicateOfTriggerId.And(emptyList()), + SelectorTupleOfTriggerId(listOf(TriggerIdProjectionOfSelectorMarker.Atom())), + ), + ) /** - * Return a trigger with the given [AccountId] + * Return the full set of transactions */ - fun findTriggersByAuthorityId(id: AccountId) = QueryBox.FindTriggersByAuthorityId( - FindTriggersByAuthorityId(id), - ) - - /** - * Return all currently triggers with the given [DomainId] - */ - 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..cebb2c055 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,448 +1,345 @@ 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, + val query: QueryBox, + val extractor: ResultExtractor, ) { - private var accountId: AccountId? = null 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()) + fun sorting(key: String) = + this.apply { + this.sorting = Sorting(key.asName()) + } + + fun sorting(key: Name) = + this.apply { + this.sorting = Sorting(key) + } + + fun pagination( + limit: BigInteger? = null, + offset: BigInteger? = null, + ) = this.apply { + this.pagination = Pagination(limit?.let { NonZeroOfu64(limit) }, offset ?: BigInteger.ZERO) } - fun sorting(key: Name) = this.apply { - 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 fetchSize(value: Long) = this.apply { - this.fetchSize = FetchSize(NonZeroOfu32(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), - ) - val encodedPayload = ClientQueryPayload.encode(payload) - val signature = QuerySignature(Signature(keyPair.private.sign(encodedPayload)).asSignatureOf()) + fun fetchSize(value: BigInteger) = + this.apply { + this.fetchSize = FetchSize(NonZeroOfu64(value)) + } + + 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 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, - ) - - @JvmStatic - fun findAccountKeyValueByIdAndKey(accountId: AccountId, key: Name) = QueryBuilder( - Queries.findAccountKeyValueByIdAndKey(accountId, key), - StringExtractor, - ) - - @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, - ) - - @JvmStatic - @JvmOverloads - fun findAllAssetsDefinitions( - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAllAssetsDefinitions(), - AssetDefinitionsExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAssetsByName( - name: Name, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByName(name), - AssetsExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findAssetsByAccountId( - accountId: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByAccountId(accountId), - AssetsExtractor, - queryFilter, - ) + fun findPeers(predicate: CompoundPredicateOfPeerId? = null) = + QueryBuilder( + Queries.findPeers(predicate), + PeersExtractor, + ) + /** + * Return all domains + */ @JvmStatic - fun findAccountById(accountId: AccountId) = QueryBuilder(Queries.findAccountById(accountId), AccountExtractor) + fun findDomains(predicate: CompoundPredicateOfDomain? = null) = + QueryBuilder( + Queries.findDomains( + predicate, + ), + DomainsExtractor, + ) - @JvmStatic - fun findAssetById(assetId: AssetId) = QueryBuilder(Queries.findAssetById(assetId), AssetExtractor) + /** + * Return domain with the given id + */ + @JvmStatic + 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 findAssetsByDomainId( - domainId: DomainId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByDomainId(domainId), - AssetsExtractor, - queryFilter, - ) + fun findAssetsDefinitions(predicate: CompoundPredicateOfAssetDefinition? = null) = + QueryBuilder( + Queries.findAssetsDefinitions(predicate), + AssetDefinitionsExtractor, + ) @JvmStatic - fun findAssetsByAssetDefinitionId(assetDefinition: AssetDefinitionId) = QueryBuilder( - Queries.findAssetsByAssetDefinitionId(assetDefinition), - AssetsExtractor, - ) + 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 findAllAssetsDefinitions( - assetDefinition: AssetDefinitionId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findAssetsByAssetDefinitionId(assetDefinition), - AssetDefinitionsExtractor, - queryFilter, - ) + fun findAccounts(predicate: CompoundPredicateOfAccount? = null) = + QueryBuilder( + Queries.findAccounts(predicate), + AccountsExtractor, + ) @JvmStatic - @JvmOverloads - fun findAssetsByDomainIdAndAssetDefinitionId( - domainId: DomainId, - assetDefinition: AssetDefinitionId, - queryFilter: GenericPredicateBox? = null, + fun findAccountsWithAsset( + definitionId: AssetDefinitionId, + predicate: CompoundPredicateOfAccount? = null, ) = QueryBuilder( - Queries.findAssetsByDomainIdAndAssetDefinitionId(domainId, assetDefinition), - 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, + Queries.findAccountsWithAsset( + definitionId, + predicate, + ), + AccountsExtractor, ) @JvmStatic - fun findAssetDefinitionKeyValueByIdAndKey( - id: AssetDefinitionId, - key: String, - ) = findAssetDefinitionKeyValueByIdAndKey(id, key.asName()) + fun findAccountById(accountId: AccountId): QueryBuilder { + val byAccountIdFilter = + CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(accountId), + ), + ), + ) - @JvmStatic - fun findDomainKeyValueByIdAndKey(id: DomainId, key: String) = findDomainKeyValueByIdAndKey(id, key.asName()) + return QueryBuilder(Queries.findAccounts(byAccountIdFilter), AccountOrNullExtractor) + } @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) + fun findAssets(predicate: CompoundPredicateOfAsset? = null) = + QueryBuilder( + Queries.findAssets(predicate), + AssetsExtractor, + ) @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, + predicate: CompoundPredicateOfPermission? = null, ) = QueryBuilder( - Queries.findPermissionsByAccountId(accountId), + Queries.findPermissionsByAccountId( + accountId, + predicate, + ), PermissionTokensExtractor, - queryFilter, ) @JvmStatic - fun findExecutorDataModel( - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findExecutorDataModel(), - ExecutorDataModelExtractor, - queryFilter, - ) + fun findRoles(predicate: CompoundPredicateOfRole? = null) = + QueryBuilder( + Queries.findRoles(predicate ?: CompoundPredicateOfRole.And(emptyList())), + RolesExtractor, + ) @JvmStatic - @JvmOverloads - fun findRolesByAccountId(accountId: AccountId, queryFilter: GenericPredicateBox? = null) = + fun findRoleById(predicate: CompoundPredicateOfRole? = null) = QueryBuilder( - Queries.findRolesByAccountId(accountId), + Queries.findRoles(predicate ?: CompoundPredicateOfRole.And(emptyList())), RoleIdsExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findAllRoleIds(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllRoleIds(), + fun findRolesByAccountId( + accountId: AccountId, + predicate: CompoundPredicateOfRoleId? = null, + ) = QueryBuilder( + Queries.findRolesByAccountId( + accountId, + predicate, + ), RoleIdsExtractor, - queryFilter, ) @JvmStatic - @JvmOverloads - fun findAllRoles(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllRoles(), - RolesExtractor, - queryFilter, - ) - - @JvmStatic - @JvmOverloads - fun findRoleByRoleId(roleId: RoleId, queryFilter: GenericPredicateBox? = null) = + fun findTriggers(predicate: CompoundPredicateOfTrigger? = null) = QueryBuilder( - Queries.findRoleByRoleId(roleId), - RoleExtractor, - queryFilter, + Queries.findTriggers( + predicate, + ), + TriggersExtractor, ) @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, - ) - - @JvmStatic - fun findAssetDefinitionById(definitionId: AssetDefinitionId) = QueryBuilder( - Queries.findAssetDefinitionById(definitionId), - AssetDefinitionExtractor, - ) - - @JvmStatic - fun findTriggerById(id: TriggerId) = QueryBuilder( - Queries.findTriggerById(id), - TriggerBoxExtractor, - ) - - @JvmStatic - fun findTriggerKeyValueByIdAndKey(id: TriggerId, key: Name) = QueryBuilder( - Queries.findTriggerKeyValueByIdAndKey(id, key), - StringExtractor, - ) - - @JvmStatic - @JvmOverloads - fun findAllActiveTriggerIds(queryFilter: GenericPredicateBox? = null) = QueryBuilder( - Queries.findAllActiveTriggerIds(), - TriggerIdsExtractor, - queryFilter, - ) + 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 findTriggersByAuthorityId( - id: AccountId, - queryFilter: GenericPredicateBox? = null, - ) = QueryBuilder( - Queries.findTriggersByAuthorityId(id), - TriggerBoxExtractor, - queryFilter, - ) + fun findActiveTriggerIds(predicate: CompoundPredicateOfTriggerId? = null) = + QueryBuilder( + Queries.findActiveTriggerIds( + predicate, + ), + TriggerIdsExtractor, + ) @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 +348,7 @@ 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..cc24a3758 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 @@ -40,97 +45,125 @@ import kotlin.test.assertTrue @Sdk("Java/Kotlin") @Feature("Block Streaming") class BlockStreamTest : IrohaTest() { - @Test @WithIroha([NewAccountWithMetadata::class]) @Story("Successful subscription to block stream") @SdkTestId("subscription_to_block_stream") @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 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.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - registerAssetDefinition(newAssetName.asName(), DEFAULT_DOMAIN_ID, AssetType.Store()) + fun `subscription to block stream`(): Unit = + runBlocking { + val idToSubscription = client.blocks(count = 3) + val actionId = idToSubscription.first.first().id + val subscription = idToSubscription.second + val newAssetName = "rox" + + client.submit(Transfer.domain(ALICE_ACCOUNT_ID, DEFAULT_DOMAIN_ID, BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } + } + 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) } + + // 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[1] + .cast() + .extractDomain() + .id.name.string + + assertEquals(DEFAULT_DOMAIN_ID.asString(), registerDomain) + 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() + assertNotNull(newAssetDefinition) + assertEquals(newAssetName, newAssetDefinition.id.name.string) + assertEquals(DEFAULT_DOMAIN, newAssetDefinition.id.domain.asString()) + + subscription.stop() } - val blocks = mutableListOf() - subscription.receive(actionId).collect { block -> blocks.add(block) } - - val expectedSize = NewAccountWithMetadata().transaction.instructions.count() + 2 // + wasm + peer register - var isi = blocks[0].validate(1, GENESIS_DOMAIN, GENESIS_ADDRESS, expectedSize) - val registerDomain = isi[0].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) - - isi = blocks[2].validate(3, DEFAULT_DOMAIN, BOB_PUBLIC_KEY.payload.toHex(true), 1) - val newAssetDefinition = isi[0].cast().extractAssetDefinition() - assertNotNull(newAssetDefinition) - assertEquals(newAssetName, newAssetDefinition.id.name.string) - assertEquals(DEFAULT_DOMAIN, newAssetDefinition.id.domain.asString()) - - subscription.stop() - } - @Test @WithIroha([NewAccountWithMetadata::class]) @Story("Successful subscription to endless block stream") @SdkTestId("subscription_to_endless_block_stream") @ResourceLock("blockStream") - 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( - onBlock = { block -> block.extractBlock().height() }, - cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(repeatTimes.toLong()) }, - ) - val initialActionId = idToSubscription.first.first().id - val subscription = idToSubscription.second - var heightSum = BigInteger.ZERO - - subscription.receive(initialActionId) { heightSum += it.u64 } - - repeat(repeatTimes + shift) { - client.tx { setKeyValue(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), randomAlphabetic(16)) } + 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.blocks( + onBlock = { block -> block.extractBlock().height() }, + cancelIf = { block -> block.extractBlock().height().u64 == BigInteger.valueOf(repeatTimes.toLong()) }, + ) + val initialActionId = idToSubscription.first.first().id + val subscription = idToSubscription.second + var heightSum = BigInteger.ZERO + + subscription.receive(initialActionId) { heightSum += it.u64 } + + repeat(repeatTimes + shift) { + 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() + .extractInstruction() + }, + ), + collector = { isi.add(it) }, + ) + + lateinit var lastValue: String + repeat(repeatTimes * 2) { + lastValue = randomAlphabetic(16) + 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.readValue()) + + subscription.stop() } - assertEquals((1..repeatTimes.toLong()).sum(), heightSum.toLong()) - - val isi = mutableListOf() - subscription.subscribeAndReceive( - BlockStreamStorage( - onBlock = { it.extractBlock().transactions.first().value.extractInstruction() }, - ), - collector = { isi.add(it) }, - ) - lateinit var lastValue: String - repeat(repeatTimes * 2) { - lastValue = randomAlphabetic(16) - client.tx { setKeyValue(ALICE_ACCOUNT_ID, randomAlphabetic(16).asName(), lastValue) } + private fun BlockPayload.payloads(): List = + this.transactions.map { tx -> + tx + .cast() + .signedTransactionV1 + .payload } - Thread.sleep(5000) - val actual = isi.last().cast().setKeyValueBox - .cast().setKeyValueOfAccount.value - assertEquals(lastValue, actual) - - subscription.stop() - } - - private fun BlockPayload.payloads(): List = this.transactions.map { tx -> - tx.value - .cast() - .signedTransactionV1 - .payload - } private fun BlockMessage.validate( expectedHeight: Long, @@ -139,19 +172,28 @@ class BlockStreamTest : IrohaTest() { expectedIsiSize: Int, ): List { val committedBlock = this.extractBlock() - assertEquals(expectedHeight, committedBlock.header.height.u64.toLong()) + assertEquals( + expectedHeight, + committedBlock.header.height.u64 + .toLong(), + ) val payloads = committedBlock.payloads() assertTrue { payloads.any { it.authority.domain.name.string == expectedDomain } } assertTrue { payloads.any { - it.authority.signatory.payload.toHex(true).lowercase() == expectedAccount.lowercase() + it.authority.signatory.payload + .toHex(true) + .lowercase() == expectedAccount.lowercase() } } - val instructions = payloads.reversed().map { - it.instructions.cast().vec - }.flatten() // wasm isi in the end + val instructions = + payloads + .reversed() + .map { + it.instructions.cast().vec + }.flatten() // wasm isi in the end assertEquals(expectedIsiSize, instructions.size) return instructions 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..e2801817c 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,39 @@ 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 { - val container = IrohaContainer { - this.alias = "iroha$DEFAULT_P2P_PORT" - this.genesis = DefaultGenesis() - }.also { it.start() } + 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 -> - withTimeout(Duration.ofSeconds(10)) { d.await() } - } + 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..2f83cc7de 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() { @@ -23,40 +26,42 @@ class GenesisTest : IrohaTest() { @Test @WithIroha(source = "src/test/resources/genesis.json", configs = ["LOG_LEVEL${IROHA_CONFIG_DELIMITER}TRACE"]) - fun `register asset instruction committed`(): Unit = runBlocking { - client.checkAliceAndBobExists() - } + fun `register asset instruction committed`(): Unit = + runBlocking { + client.checkAliceAndBobExists() + } @Test - fun `manual IrohaContainer initialization`(): Unit = runBlocking { - val path = javaClass.getResource("../../genesis.json")!!.path - val container = IrohaContainer { - this.alias = "iroha$DEFAULT_P2P_PORT" - this.genesisPath = path - }.also { it.start() } - - val client = Iroha2Client(container.getApiUrl(), container.getP2pUrl()) - client.checkAliceAndBobExists() - } + fun `manual IrohaContainer initialization`(): Unit = + runBlocking { + val path = javaClass.getResource("../../genesis.json")!!.path + val container = + IrohaContainer { + this.alias = "iroha$DEFAULT_P2P_PORT" + this.genesisPath = path + }.also { it.start() } + + val client = Iroha2Client(listOf(container.getApiUrl()), container.config.chain, ALICE_ACCOUNT_ID, ALICE_KEYPAIR) + client.checkAliceAndBobExists() + } @Test @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()) } - - QueryBuilder.findAssetDefinitionById(definitionId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { assetDefinition -> assertEquals(assetDefinition.id, definitionId) } - } + fun `custom executor path`(): Unit = + runBlocking { + val definitionId = AssetDefinitionId(DEFAULT_DOMAIN_ID, "XSTUSD".asName()) + client.submit(Register.assetDefinition(definitionId, AssetType.numeric())).also { d -> + withTimeout(Duration.ofSeconds(10)) { d.await() } + } + + 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..bfc70a76d 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,39 +80,34 @@ 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 -> - withTimeout(txTimeout) { d.await() } - } + fun `register domain with manual initialized Iroha`(): Unit = + runBlocking { + val domainId = "new_domain_name".asDomainId() + + 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) } - .also { result -> assertEquals(result.id, domainId) } - } + client + .submit(QueryBuilder.findDomainById(domainId))!! + .also { result -> assertEquals(result.id, domainId) } + } @Test @Disabled // EXAMPLE @@ -98,50 +117,41 @@ class InstructionsTest : IrohaTest() { privateKey = "9ac47abf59b356e0bd7dcbbbb4dec080e302156a48ca907e47cb6aea1d32719e", dockerComposeFile = "../../docker-compose/docker-compose.yaml", ) - 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 -> - withTimeout(txTimeout) { d.await() } - } + fun `register domain with manual initialized Iroha via docker-compose`(): Unit = + runBlocking { + val domainId = "new_domain_name".asDomainId() - QueryBuilder.findDomainById(domainId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { result -> assertEquals(result.id, domainId) } - } + client.submit(Register.domain(domainId)).also { d -> + withTimeout(txTimeout) { d.await() } + } + + client + .submit(QueryBuilder.findDomainById(domainId))!! + .also { result -> assertEquals(result.id, domainId) } + } /** * Using for docs generation */ // #region java_register_domain @Test - @WithIroha([DefaultGenesis::class]) + @WithIroha([AliceHasPermissionToRegisterDomain::class]) @Feature("Domains") @Story("Account registers a domain") @Permission("no_permission_required") @SdkTestId("register_domain") - fun `register domain`(): Unit = runBlocking { - val domainId = "new_domain_name".asDomainId() - - client.sendTransaction { - account(super.account) - registerDomain(domainId) - buildSigned(super.keyPair) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + fun `register domain`(): Unit = + runBlocking { + val domainId = "new_domain_name".asDomainId() - QueryBuilder.findDomainById(domainId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { result -> assertEquals(result.id, domainId) } - } + client.submit(Register.domain(domainId)).also { d -> + withTimeout(txTimeout) { d.await() } + } + + client + .submit(QueryBuilder.findDomainById(domainId))!! + .also { result -> assertEquals(result.id, domainId) } + } // #endregion java_register_domain /** @@ -154,22 +164,18 @@ class InstructionsTest : IrohaTest() { @Story("Account registers an account") @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 -> - withTimeout(txTimeout) { d.await() } - } + fun `register account`(): Unit = + runBlocking { + 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 @Test @@ -180,34 +186,25 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @SdkTestId("register_account") @SdkTestId("unregister_account") - fun `register and unregister account`(): Unit = runBlocking { - val joeKeyPair = generateKeyPair() - val joeId = AccountId(DEFAULT_DOMAIN_ID, joeKeyPair.public.toIrohaPublicKey()) - client.tx { registerAccount(joeId) } - - QueryBuilder.findAccountById(joeId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .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) } + fun `register and unregister account`(): Unit = + runBlocking { + val joeKeyPair = generateKeyPair() + val joeId = AccountId(DEFAULT_DOMAIN_ID, joeKeyPair.public.toIrohaPublicKey()) + client.submit(Register.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } } + + client + .submit(QueryBuilder.findAccountById(joeId))!! + .also { account -> assertEquals(account.id, joeId) } + + client.submitAs(joeId, joeKeyPair, Unregister.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } + } + client + .submit(QueryBuilder.findAccountById(joeId)) + .also { account -> assertNull(account) } } - } @Test @WithIroha([DefaultGenesis::class]) @@ -217,39 +214,45 @@ class InstructionsTest : IrohaTest() { @Permission("no_permission_required") @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 assetId = AssetId(ALICE_ACCOUNT_ID, definitionId) - client.tx { registerAsset(assetId, AssetValue.Numeric(0.asNumeric())) } - - QueryBuilder.findAssetById(assetId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .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) } - } - } + fun `register and unregister asset`(): Unit = + runBlocking { + val assetDefinitionId = AssetDefinitionId(DEFAULT_DOMAIN_ID, "XSTUSD".asName()) + client + .submit(Register.assetDefinition(assetDefinitionId, AssetType.numeric())) + .also { d -> + withTimeout(txTimeout) { d.await() } + } - client.tx { unregisterAssetDefinition(definitionId) } - assertThrows { - runBlocking { - QueryBuilder.findAssetDefinitionById(definitionId) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - } + val assetId = AssetId(ALICE_ACCOUNT_ID, assetDefinitionId) + client + .submit(Register.asset(assetId, AssetValue.Numeric(0.asNumeric()))) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + + client + .submit(QueryBuilder.findAssetById(assetId))!! + .also { asset -> assertEquals(asset.id, assetId) } + + client + .submit(Unregister.asset(assetId)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + client + .submit(QueryBuilder.findAssetById(assetId)) + .also { asset -> assertNull(asset) } + + client + .submit(Unregister.assetDefinition(assetDefinitionId)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + client + .submit( + QueryBuilder.findAssetDefinitionById(assetDefinitionId), + ).also { definition -> assertNull(definition) } } - } @Test @WithIroha([AliceHasPermissionToUnregisterDomain::class]) @@ -257,18 +260,18 @@ class InstructionsTest : IrohaTest() { @Story("Account unregisters a domain") @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) } - } + fun `unregister domain`(): Unit = + runBlocking { + 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 @WithIroha([DefaultGenesis::class]) @@ -276,44 +279,43 @@ class InstructionsTest : IrohaTest() { @Story("Account registers an account") @Permission("no_permission_required") @SdkTestId("register_account_with_metadata") - fun `register account with metadata`(): Unit = runBlocking { - val addressKey = "address".asName() - val phoneKey = "phone".asName() - val emailKey = "email".asName() - val cityKey = "city".asName() - val addressValue = "address" - val phoneValue = "phone" - val emailValue = "email" - val cityValue = "city" - val metadata = Metadata( - mapOf( - Pair(addressKey, addressValue), - Pair(phoneKey, phoneValue), - Pair(emailKey, emailValue), - Pair(cityKey, cityValue), - ), - ) - val newAccountId = AccountId(DEFAULT_DOMAIN_ID, generatePublicKey()) - client.sendTransaction { - account(super.account) - registerAccount(newAccountId, metadata) - buildSigned(super.keyPair) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + fun `register account with metadata`(): Unit = + runBlocking { + val addressKey = "address".asName() + val phoneKey = "phone".asName() + val emailKey = "email".asName() + val cityKey = "city".asName() + val addressValue = "address" + val phoneValue = "phone" + val emailValue = "email" + val cityValue = "city" + val metadata = + Metadata( + mapOf( + 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.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 - 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]) - } + val accountMetadata = + client + .submit( + QueryBuilder.findAccountById(newAccountId), + )!! + .also { account -> assertEquals(account.id, newAccountId) } + .metadata + assertEquals(4, accountMetadata.sortedMapOfName.size) + assertEquals(addressValue, accountMetadata.sortedMapOfName[addressKey]!!.readValue()) + assertEquals(phoneValue, accountMetadata.sortedMapOfName[phoneKey]!!.readValue()) + assertEquals(emailValue, accountMetadata.sortedMapOfName[emailKey]!!.readValue()) + assertEquals(cityValue, accountMetadata.sortedMapOfName[cityKey]!!.readValue()) + } /** * Using for docs generation @@ -325,23 +327,21 @@ class InstructionsTest : IrohaTest() { @Story("Account registers an asset definition") @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 -> - withTimeout(txTimeout) { d.await() } + fun `register asset`(): Unit = + runBlocking { + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).also { d -> + withTimeout(txTimeout) { d.await() } + } + val assetDefinitions = + client.submit( + QueryBuilder.findAssetsDefinitions(), + ) + + 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", + ) } - val assetDefinitions = QueryBuilder.findAllAssetsDefinitions() - .account(super.account) - .buildSigned(super.keyPair) - .let { q -> client.sendQuery(q) } - - 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") - } // #endregion java_register_asset @Test @@ -350,43 +350,57 @@ class InstructionsTest : IrohaTest() { @Story("Account registers an asset definition") @Permission("no_permission_required") @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) - } + fun `store asset`(): Unit = + runBlocking { + val pair1 = "key1".asName() to "bar" + 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 asset = + client.submit( + QueryBuilder.findAssetById(DEFAULT_ASSET_ID), + ) - val findAssetByIdQry = QueryBuilder.findAssetById(DEFAULT_ASSET_ID) - .account(super.account) - .buildSigned(super.keyPair) - val asset = client.sendQuery(findAssetByIdQry) + 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]!!.readValue()) + assertEquals(pair2.second, value.metadata.sortedMapOfName[pair2.first]!!.readValue()) + assertEquals(pair3.second, value.metadata.sortedMapOfName[pair3.first]!!.readValue()) + } - 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]) + 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 domainPredicate = + CompoundPredicateOfAsset.Atom( + AssetProjectionOfPredicateMarker.Id( + AssetIdProjectionOfPredicateMarker.Definition( + AssetDefinitionIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals(DEFAULT_DOMAIN_ID), + ), + ), + ), + ), + ) - // 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) - assertEquals(1, assetsByDomainName.size) - assertEquals(asset.id, assetsByDomainName.first().id) - } + val assetsByDomainName = client.submit(QueryBuilder.findAssets(domainPredicate)) + assertEquals(1, assetsByDomainName.size) + assertEquals(asset.id, assetsByDomainName.first().id) + } @Test @WithIroha( @@ -397,78 +411,87 @@ class InstructionsTest : IrohaTest() { @Story("Account metadata limit adjustment") @Permission("no_permission_required") @SdkTestId("account_metadata_limit_increased") - fun `account metadata limit increased`(): Unit = runBlocking { - client.tx { + fun `account metadata limit increased`(): Unit = + runBlocking { + val key = "key".asName() + val value = randomAlphabetic(5000) + // 5000 characters string would be rejected by Iroha with default WSV_ACCOUNT_METADATA_LIMITS config - setKeyValue(ALICE_ACCOUNT_ID, "key".asName(), randomAlphabetic(5000)) + 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]) - 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, - ) - } + @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 + .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() } + } } - } @Test @WithIroha([DefaultGenesis::class]) @Feature("Accounts") @Story("Account sets key value pair") - @Permission("CanSetKeyValueInUserAsset") - @SdkTestId("set_key_value_pair_for_another_account_asset_definition") - fun `grant access to asset key-value and then revoke`(): Unit = runBlocking { - val aliceAssetId = DEFAULT_ASSET_ID - - client.tx { - registerAssetDefinition(aliceAssetId.definition, AssetType.Store()) - // grant by Alice to Bob permissions to set key value in Asset.Store - grantPermissionToken( - Permissions.CanSetKeyValueInUserAsset, - aliceAssetId.asJsonString(true), - BOB_ACCOUNT_ID, - ) - } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - setKeyValue(aliceAssetId, "foo".asName(), "bar") - } + @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 + .submit( + Register.assetDefinition(aliceAssetId.definition, AssetType.Store()), + // grant by Alice to Bob permissions to set key value in Asset.Store + Grant.accountPermission( + permission, + BOB_ACCOUNT_ID, + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + 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() } + } + client + .submit( + QueryBuilder.findPermissionsByAccountId(BOB_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR), + ).also { permissions -> assertTrue { permissions.isEmpty() } } } - QueryBuilder.findPermissionsByAccountId(BOB_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { client.sendQuery(it) } - .also { permissions -> assertTrue { permissions.isEmpty() } } - } /** * Using for docs generation @@ -480,24 +503,40 @@ class InstructionsTest : IrohaTest() { @Story("Account mints an asset") @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 -> - withTimeout(txTimeout) { d.await() } - } + fun `mint asset`(): Unit = + runBlocking { + 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 @Test @@ -506,20 +545,52 @@ class InstructionsTest : IrohaTest() { @Story("Account burns an asset") @Permission("no_permission_required") @SdkTestId("burn_asset_for_account_in_same_domain") - fun `burn asset`(): Unit = runBlocking { - // 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()) + 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 + .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()) - } + // check balance after burn + result = client.submit(query) + assertEquals( + 50, + result + .get(DEFAULT_ASSET_ID)!! + .value + .cast() + .numeric + .asInt(), + ) + } @Test @WithIroha([DefaultGenesis::class]) @@ -527,24 +598,47 @@ class InstructionsTest : IrohaTest() { @Story("Account burns an asset") @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(), - BOB_ACCOUNT_ID, + fun `burn other user asset`(): Unit = + runBlocking { + 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.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(), ) } - 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()) - } @Test @WithIroha([DefaultGenesis::class]) @@ -552,71 +646,82 @@ class InstructionsTest : IrohaTest() { @Story("Account changes account metadata") @Permission("CanSetKeyValueInAccount") @SdkTestId("change_account_metadata_by_granted_account") - fun `change user account metadata`(): Unit = runBlocking { - 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), - ALICE_ACCOUNT_ID, - ) - buildSigned(BOB_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } + fun `change user account metadata`(): Unit = + runBlocking { + val saltKey = "salt" + + // grant permission to Alice to change Bob's account metadata + client + .submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + Grant.accountPermission( + CanModifyAccountMetadata(BOB_ACCOUNT_ID), + ALICE_ACCOUNT_ID, + ), + ).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) } + // add/update salt value in Bob's account metadata + val salt = randomAlphabetic(10) + 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()]) - } + // check new metadata in Bob's account + 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") @SdkTestId("transfer_asset") - fun `transfer asset`(): Unit = runBlocking { - val aliceAssetId = DEFAULT_ASSET_ID - val bobAssetId = AliceAndBobEachHave100Xor.BOB_ASSET_ID + fun `transfer asset`(): Unit = + runBlocking { + val aliceAssetId = DEFAULT_ASSET_ID + val bobAssetId = AliceAndBobEachHave100Xor.BOB_ASSET_ID - assertEquals(100, getAccountAmount(aliceAssetId)) - assertEquals(100, getAccountAmount(bobAssetId)) + assertEquals(100, getAccountAmount(aliceAssetId)) + assertEquals(100, getAccountAmount(bobAssetId)) - client.tx { transferAsset(aliceAssetId, 40, BOB_ACCOUNT_ID) } - assertEquals(60, getAccountAmount(aliceAssetId)) - assertEquals(140, getAccountAmount(bobAssetId)) + 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) } - assertEquals(100, getAccountAmount(aliceAssetId)) - assertEquals(100, getAccountAmount(bobAssetId)) + 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) } + val joeDomain = "joe_domain".asDomainId() + client.submit(Register.domain(joeDomain)).also { d -> + withTimeout(txTimeout) { d.await() } + } - val joeKeyPair = generateKeyPair() - val joeId = AccountId(joeDomain, joeKeyPair.public.toIrohaPublicKey()) - registerAccount(joeId) + val joeKeyPair = generateKeyPair() + val joeId = AccountId(joeDomain, joeKeyPair.public.toIrohaPublicKey()) + client.submit(Register.account(joeId)).also { d -> + withTimeout(txTimeout) { d.await() } + } - client.tx { - grantPermissionToken(Permissions.CanTransferUserAssetsToken, aliceAssetId.asJsonString(true), joeId) - } - client.tx(account = joeId, joeKeyPair) { - transferAsset(aliceAssetId, 40, BOB_ACCOUNT_ID) + client.submit(Grant.accountPermission(CanTransferAsset(aliceAssetId), joeId)).also { d -> + withTimeout(txTimeout) { d.await() } + } + 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)) } - assertEquals(60, getAccountAmount(aliceAssetId)) - assertEquals(140, getAccountAmount(bobAssetId)) - } @Test @WithIroha([StoreAssetWithMetadata::class]) @@ -624,18 +729,29 @@ class InstructionsTest : IrohaTest() { @Story("Account removes asset metadata") @Permission("no_permission_required") @SdkTestId("remove_asset_metadata") - fun `remove asset`(): Unit = runBlocking { - val assetId = StoreAssetWithMetadata.ASSET_ID - 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) } + fun `remove asset`(): Unit = + runBlocking { + val assetId = StoreAssetWithMetadata.ASSET_ID + val assetKey = StoreAssetWithMetadata.ASSET_KEY + + val assetBefore = getAsset(assetId) + 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()) - } + val assetAfter = getAsset(assetId) + assert( + assetAfter.value + .cast() + .metadata.sortedMapOfName + .isEmpty(), + ) + } @Test @WithIroha([DefaultGenesis::class]) @@ -647,56 +763,78 @@ class InstructionsTest : IrohaTest() { @Story("Account burns an asset") @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()) } - - // counter to track all changes in balance - var counter = BigDecimal.ZERO - // count of changes (both mint and burn) - val probes = 20 - val random = SecureRandom() - // return positive random number what is never greater than counter - val getFpNumber = { - BigDecimal(random.nextDouble() + random.nextInt()) - .abs() - .stripTrailingZeros() - .remainder(counter, MathContext.DECIMAL64) - .setScale(random.nextInt(DEFAULT_SCALE), RoundingMode.DOWN) - } - val mintAsset: suspend (BigDecimal) -> Unit = { - client.tx { mintAsset(DEFAULT_ASSET_ID, it) } - counter += it - } - val burnAsset: suspend (BigDecimal) -> Unit = { - client.tx { burnAsset(DEFAULT_ASSET_ID, it) } - counter -= it - } - 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 -> - assertTrue("expected value `$expectedBalance`, but was `$actualBalance`") { - expectedBalance.compareTo(actualBalance) == 0 - } + fun `check assets with type Fixed are properly minted and burned`(): Unit = + runBlocking { + 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 + // count of changes (both mint and burn) + val probes = 20 + val random = SecureRandom() + // return positive random number what is never greater than counter + val getFpNumber = { + BigDecimal(random.nextDouble() + random.nextInt()) + .abs() + .stripTrailingZeros() + .remainder(counter, MathContext.DECIMAL64) + .setScale(random.nextInt(DEFAULT_SCALE), RoundingMode.DOWN) + } + val mintAsset: suspend (BigDecimal) -> Unit = { + client.submit(Mint.asset(DEFAULT_ASSET_ID, it)).also { d -> + withTimeout(txTimeout) { d.await() } } - } - assertBalance(counter) - mintAsset(BigDecimal.TEN) - assertBalance(counter) - for (i in 0..probes) { - if (i % 2 == 0) { - mintAsset(getFpNumber()) - } else { - burnAsset(getFpNumber()) + counter += it + } + val burnAsset: suspend (BigDecimal) -> Unit = { + 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 -> + 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 + } + } } assertBalance(counter) + mintAsset(BigDecimal.TEN) + assertBalance(counter) + for (i in 0..probes) { + if (i % 2 == 0) { + mintAsset(getFpNumber()) + } else { + burnAsset(getFpNumber()) + } + assertBalance(counter) + } } - } @Test @WithIroha([DefaultGenesis::class]) @@ -704,40 +842,43 @@ class InstructionsTest : IrohaTest() { @Story("Account registers an asset definition") @Permission("no_permission_required") @SdkTestId("register_asset_definition_with_metadata") - 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)) + fun `register asset with metadata`(): Unit = + runBlocking { + val assetKey = "asset_metadata_key".asName() + val assetValue = "some string value" + val metadata = Metadata(mapOf(assetKey to Json.writeValue(assetValue))) + + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store(), metadata = metadata)).also { d -> + withTimeout(txTimeout) { d.await() } + } - client.tx { - registerAssetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.Store(), metadata) + client + .submit(QueryBuilder.findAssetDefinitionById(DEFAULT_ASSET_DEFINITION_ID))!! + .also { assertEquals(assetValue, it.metadata.sortedMapOfName[assetKey]!!.readValue()) } } - QueryBuilder.findAssetDefinitionKeyValueByIdAndKey(DEFAULT_ASSET_DEFINITION_ID, assetKey) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { value -> - Assertions.assertEquals(value, assetValue) - } - } - @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) } - assertThrows { - runBlocking { client.tx { registerDomain(domainId) } } + fun `double domain registration should fail`(): Unit = + runBlocking { + val domainId = UUID.randomUUID().toString().asDomainId() + client.submit(Register.domain(domainId)).also { d -> + withTimeout(txTimeout) { d.await() } + } + assertThrows { + 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") @@ -750,60 +891,74 @@ class InstructionsTest : IrohaTest() { @Permission("CanSetKeyValueInUserAsset") @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()) - } + fun `register and grant role to account and then revoke it`(): Unit = + runBlocking { + 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 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") - } + val assetId = AssetId(BOB_ACCOUNT_ID, assetDefinitionName) + val roleId = RoleId("BOB_ASSET_ACCESS".asName()) + 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) } - .also { asset -> - assertTrue( - asset.value.cast() - .metadata.sortedMapOfName - .containsValue("value"), - ) - } + client + .submit(QueryBuilder.findAssetById(assetId)) + .also { asset -> + assertEquals( + asset!! + .value + .cast() + .metadata.sortedMapOfName["key".asName()]!! + .readValue(), + "value", + ) + } - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - revokeRole(roleId, ALICE_ACCOUNT_ID) - } - QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { roles -> - assertTrue( - roles.isEmpty(), - ) + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, Revoke.accountRole(roleId, ALICE_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } } - QueryBuilder.findAllRoles() - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } - .firstOrNull { it.id == roleId } - .also { Assertions.assertNotNull(it) } - - client.tx(BOB_ACCOUNT_ID, BOB_KEYPAIR) { - unregisterRole(roleId) + client + .submit(QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID).signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) + .also { roles -> + assertTrue( + roles.isEmpty(), + ) + } + client + .submit(QueryBuilder.findRoles().signAs(BOB_ACCOUNT_ID, BOB_KEYPAIR)) + .firstOrNull { it.id == roleId } + .also { assertNotNull(it) } + + 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 { assertNull(it) } } - QueryBuilder.findAllRoles() - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } - .firstOrNull { it.id == roleId } - .also { Assertions.assertNull(it) } - } @Test @WithIroha( @@ -822,106 +977,113 @@ class InstructionsTest : IrohaTest() { ) @Feature("Configurations") @Permission("no_permission_required") - fun `multiple genesis`(): Unit = runBlocking { - val assetId = StoreAssetWithMetadata.ASSET_ID - val assetKey = StoreAssetWithMetadata.ASSET_KEY - - val assetBefore = getAsset(assetId) - assertEquals( - StoreAssetWithMetadata.ASSET_VALUE, - assetBefore.value.cast().metadata.sortedMapOfName[assetKey]?.fromJsonString(), - ) - QueryBuilder.findAccountById(ALICE_ACCOUNT_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { alice -> - assertEquals( - RubbishToTestMultipleGenesis.ALICE_KEY_VALUE, - alice.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.ALICE_KEY_VALUE.asName()]?.fromJsonString(), - ) - } - QueryBuilder.findAccountById(BOB_ACCOUNT_ID) - .account(BOB_ACCOUNT_ID) - .buildSigned(BOB_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { bob -> - assertEquals( - RubbishToTestMultipleGenesis.BOB_KEY_VALUE, - bob.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.BOB_KEY_VALUE.asName()]?.fromJsonString(), - ) - } - QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> client.sendQuery(query) } - .also { domain -> - assertEquals( - RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE, - domain.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE.asName()]?.fromJsonString(), - ) - } - } + fun `multiple genesis`(): Unit = + runBlocking { + val assetId = StoreAssetWithMetadata.ASSET_ID + val assetKey = StoreAssetWithMetadata.ASSET_KEY + + val assetBefore = getAsset(assetId) + assertEquals( + StoreAssetWithMetadata.ASSET_VALUE, + assetBefore.value + .cast() + .metadata.sortedMapOfName[assetKey]!! + .readValue(), + ) + 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()]!!.readValue(), + ) + } + 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()]!!.readValue(), + ) + } + client + .submit(QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID)) + .also { domain -> + assertEquals( + RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE, + domain!!.metadata.sortedMapOfName[RubbishToTestMultipleGenesis.DOMAIN_KEY_VALUE.asName()]!!.readValue(), + ) + } + } @Test @WithIroha([WithDomainTransferredToBob::class]) @Feature("Domains") @Story("Account transfers domain ownership") @SdkTestId("transfer_domain_ownership_in_genesis") - 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) + fun `transfer domain ownership in genesis`(): Unit = + runBlocking { + val key = randomAlphabetic(5).asName() + val value = randomAlphabetic(5) + 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) } - val extractedValue = QueryBuilder.findDomainById(WithDomainTransferredToBob.DOMAIN_ID) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .metadata.sortedMapOfName[key] - 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) } + fun `transfer domain ownership`(): Unit = + runBlocking { + val domainId = "Kingdom".asDomainId() + 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)) + assertFailsWith(TransactionRejectedException::class) { + client + .submitAs( + BOB_ACCOUNT_ID, + BOB_KEYPAIR, + SetKeyValue.domain(domainId, randomAlphabetic(5).asName(), randomAlphabetic(5)), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } } + val query = + QueryBuilder + .findDomainById(domainId) + .signAs(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) + var kingdomDomainOwnedBy = client.submit(query)!!.ownedBy + assertEquals(ALICE_ACCOUNT_ID, kingdomDomainOwnedBy) + + client.submit(Transfer.domain(ALICE_ACCOUNT_ID, domainId, BOB_ACCOUNT_ID)).also { d -> + withTimeout(txTimeout) { d.await() } + } + kingdomDomainOwnedBy = client.submit(query)!!.ownedBy + assertEquals(BOB_ACCOUNT_ID, kingdomDomainOwnedBy) + + val key = randomAlphabetic(5).asName() + val value = randomAlphabetic(5) + client.submitAs(BOB_ACCOUNT_ID, BOB_KEYPAIR, SetKeyValue.domain(domainId, key, value)).also { d -> + withTimeout(txTimeout) { d.await() } + } + + val extractedValue: String = + client + .submit(QueryBuilder.findDomainById(domainId))!! + .metadata.sortedMapOfName[key]!! + .readValue() + assertEquals(value, extractedValue) } - var kingdomDomainOwnedBy = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) }.ownedBy - assertEquals(ALICE_ACCOUNT_ID, kingdomDomainOwnedBy) - - client.tx(ALICE_ACCOUNT_ID, ALICE_KEYPAIR) { - transferDomainOwnership(ALICE_ACCOUNT_ID, domainId, BOB_ACCOUNT_ID) - } - kingdomDomainOwnedBy = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(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) } - - val extractedValue = QueryBuilder.findDomainById(domainId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .metadata.sortedMapOfName[key] - assertEquals(value, extractedValue) - } @Test @Permission("no_permission_required") @@ -929,42 +1091,30 @@ class InstructionsTest : IrohaTest() { @Story("Initiator starts network with fat genesis") @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) } - .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 + fun `fat genesis apply`(): Unit = + runBlocking { + 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 getAsset(assetId: AssetId? = null) = QueryBuilder - .findAssetById(assetId ?: DEFAULT_ASSET_ID) - .account(super.account) - .buildSigned(super.keyPair) - .let { query -> - client.sendQuery(query) - } + 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) = + 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..9e6b65e55 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,183 +41,136 @@ import kotlin.test.assertTrue @Owner("akostyuchenko") @Sdk("Java/Kotlin") @Feature("Peers") -@Disabled // https://github.com/hyperledger/iroha/issues/4999 class PeerTest : IrohaTest() { - companion object { private const val PEER_AMOUNT = 4 } @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())) - } - containerJob.await() - registerJob.await() + fun `register peer`(): Unit = + runBlocking { + val keyPair = generateKeyPair() + val payload = keyPair.public.bytes() - assertTrue(isPeerAvailable(address, payload)) - } + client.submit(Register.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } + } + + 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") - fun `unregister peer`(): 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 { - registerPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) - repeat(PEER_AMOUNT) { assertTrue(isPeerAvailable(address, payload)) } - - unregisterPeer(PeerId(SocketAddr.Host(SocketAddrHost(address, p2pPort)), keyPair.public.toIrohaPublicKey())) - repeat(PEER_AMOUNT) { assertFalse(isPeerAvailable(address, payload)) } + fun `unregister peer`(): 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 { + 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() } + } + + assertFalse(isPeerRegistered(payload)) + } } - } @Test - @WithIroha([DefaultGenesis::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 } + @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 keyPair = generateKeyPair() + val payload = keyPair.public.bytes() + + startNewContainer(keyPair, alias, PEER_AMOUNT).use { container -> + client.submit(Register.peer(PeerId(keyPair.public.toIrohaPublicKey()))).also { d -> + withTimeout(txTimeout) { d.await() } } - delay(2000) + 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) } } } - } @Test @WithIroha([DefaultGenesis::class], amount = PEER_AMOUNT) - fun `round-robin load balancing test`(): Unit = runBlocking { - repeat(PEER_AMOUNT + 1) { - assertEquals(findDomain(DEFAULT_DOMAIN_ID).id, DEFAULT_DOMAIN_ID) + fun `round-robin load balancing test`(): Unit = + runBlocking { + repeat(PEER_AMOUNT + 1) { + assertEquals(findDomain(DEFAULT_DOMAIN_ID).id, DEFAULT_DOMAIN_ID) + } } - } private suspend fun startNewContainer( keyPair: KeyPair, alias: String, amount: Int, - ): IrohaContainer = coroutineScope { - IrohaContainer { - this.waitStrategy = false - this.keyPair = keyPair - this.alias = alias - 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() } - }.also { - withContext(Dispatchers.IO) { - it.start() + ): IrohaContainer = + coroutineScope { + IrohaContainer { + this.waitStrategy = false + this.keyPair = keyPair + this.alias = alias + 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.extractPeer() } + }.also { + withContext(Dispatchers.IO) { + it.start() + } } } - } - private suspend fun isPeerAvailable( - address: String, + private suspend fun isPeerRegistered( 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) + ): 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( - SocketAddr.Host( - SocketAddrHost( - this.config.alias, - this.config.ports[IrohaConfig.P2P_PORT_IDX], + private fun IrohaContainer.extractPeer() = + Peer( + SocketAddr.Host( + SocketAddrHost( + this.config.alias, + this.config.ports[IrohaConfig.P2P_PORT_IDX], + ), + ), + PeerId( + this.config.keyPair.public + .toIrohaPublicKey(), ), - ), - 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..82109b402 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,42 +75,39 @@ 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") @Permission("no_permission_required") class QueriesTest : IrohaTest() { - @Test @WithIroha([NewAccountWithMetadata::class], configs = ["LOG_LEVEL${IROHA_CONFIG_DELIMITER}TRACE"]) @Feature("Accounts") @Query("FindAllAccounts") @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 }) + fun `find all accounts`(): Unit = + runBlocking { + 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 @WithIroha([NewAccountWithMetadata::class]) @@ -87,22 +115,38 @@ class QueriesTest : IrohaTest() { @Query("FindAllAccountsWithFilter") @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"), - ) - QueryBuilder.findAllAccounts(filter) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { accounts -> - assert(accounts.size == 2) + fun `find all accounts with filter`(): Unit = + runBlocking { + 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(), + ), + ), + ), + ), + ), + ) + + 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 @WithIroha([NewAccountWithMetadata::class]) @@ -110,19 +154,18 @@ class QueriesTest : IrohaTest() { @Query("FindAccountKeyValueByIdAndKey") @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) - } - } + fun `find account key value by ID and key`(): Unit = + runBlocking { + val metadata = + client + .submit( + QueryBuilder.findAccountById( + NewAccountWithMetadata.ACCOUNT_ID, + ), + )!! + .metadata.sortedMapOfName + assertEquals(NewAccountWithMetadata.VALUE, metadata[ NewAccountWithMetadata.KEY ]!!.readValue()) + } @Test @WithIroha([DefaultGenesis::class]) @@ -130,33 +173,41 @@ class QueriesTest : IrohaTest() { @Query("FindAccountsByDomainId") @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 }) - } - } + fun `find accounts by domain ID`(): Unit = + runBlocking { + val byDomainIdFilter = + CompoundPredicateOfAccount.Atom( + AccountProjectionOfPredicateMarker.Id( + AccountIdProjectionOfPredicateMarker.Domain( + DomainIdProjectionOfPredicateMarker.Atom( + DomainIdPredicateAtom.Equals( + DEFAULT_DOMAIN_ID, + ), + ), + ), + ), + ) - @Test + val accounts = client.submit(QueryBuilder.findAccounts(byDomainIdFilter)) + assert(accounts.all { it.id.domain == DEFAULT_DOMAIN_ID }) + } + +// @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) } - - 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()) } - } + fun `find total asset quantity by AssetDefinitionId`(): Unit = + runBlocking { + val quantity = BigDecimal(10) + client.submit(Mint.asset(AssetId(BOB_ACCOUNT_ID, XOR_DEFINITION_ID), quantity)).also { + withTimeout(txTimeout) { it.await() } + } + + val totalQuantity = client.submit(QueryBuilder.findAssetDefinitionById(XOR_DEFINITION_ID))!!.totalQuantity + assertEquals(quantity + XorAndValAssets.XOR_QUANTITY, totalQuantity.asBigDecimal()) + } @Test @WithIroha([XorAndValAssets::class]) @@ -164,17 +215,13 @@ class QueriesTest : IrohaTest() { @Query("FindAllAssets") @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 -> + fun `find all assets`(): Unit = + runBlocking { + 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 @WithIroha([XorAndValAssets::class]) @@ -182,16 +229,27 @@ class QueriesTest : IrohaTest() { @Query("FindAssetsByName") @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 -> + fun `find assets by name`(): Unit = + runBlocking { + 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 @WithIroha([XorAndValAssets::class]) @@ -199,18 +257,24 @@ class QueriesTest : IrohaTest() { @Query("FindAssetsByAccountId") @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 -> + fun `find assets by account id`(): Unit = + runBlocking { + 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 @WithIroha([XorAndValAssets::class]) @@ -218,20 +282,39 @@ class QueriesTest : IrohaTest() { @Query("FindAssetsByDomainIdAndAssetDefinitionId") @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, - ) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> - client.sendQuery(query) - }.also { assets -> + fun `find assets by domain name and asset definition id`(): Unit = + runBlocking { + 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), + ), + ), + ), + ), + ), + ) + + 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 @WithIroha([XorAndValAssets::class]) @@ -239,17 +322,19 @@ class QueriesTest : IrohaTest() { @Query("FindAssetQuantityById") @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) - } - } + fun `find asset quantity by id`(): Unit = + runBlocking { + 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 @WithIroha([StoreAssetWithMetadata::class]) @@ -257,19 +342,19 @@ class QueriesTest : IrohaTest() { @Query("FindAssetKeyValueByIdAndKey") @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) - } - } + fun `find asset key value by ID and key`(): Unit = + runBlocking { + val metadata = + client + .submit( + QueryBuilder.findAssetById( + StoreAssetWithMetadata.ASSET_ID, + ), + )!! + .metadata() + + assertEquals(StoreAssetWithMetadata.ASSET_VALUE, metadata[StoreAssetWithMetadata.ASSET_KEY]!!.readValue()) + } @Test @WithIroha([StoreAssetWithMetadata::class]) @@ -277,19 +362,18 @@ class QueriesTest : IrohaTest() { @Query("FindAssetDefinitionKeyValueByIdAndKey") @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) - } - } + fun `find asset definition key value by ID and key`(): Unit = + runBlocking { + val metadata = + client + .submit( + QueryBuilder.findAssetDefinitionById( + StoreAssetWithMetadata.DEFINITION_ID, + ), + )!! + .metadata.sortedMapOfName + assertEquals(StoreAssetWithMetadata.ASSET_VALUE, metadata[StoreAssetWithMetadata.ASSET_KEY]!!.readValue()) + } @Test @WithIroha([StoreAssetWithMetadata::class]) @@ -298,16 +382,12 @@ class QueriesTest : IrohaTest() { @Story("Account queries asset by metadata filters") @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 { + fun `find asset by metadata filters`(): Unit = + runBlocking { + client.submit(QueryBuilder.findAssets()).also { assert(it.isNotEmpty()) } - } + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @@ -315,15 +395,12 @@ class QueriesTest : IrohaTest() { @Query("FindAssetDefinitionById") @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) - } - } + fun `find asset definition by ID`(): Unit = + runBlocking { + client + .submit(QueryBuilder.findAssetDefinitionById(DEFAULT_ASSET_DEFINITION_ID))!! + .also { assertEquals(it.id, DEFAULT_ASSET_DEFINITION_ID) } + } @Test @WithIroha([NewDomain::class]) @@ -331,17 +408,15 @@ class QueriesTest : IrohaTest() { @Query("FindAllDomains") @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 -> - assert(domains.any { it.id == DEFAULT_DOMAIN_ID }) - assert(domains.any { it.id == NewDomain.DOMAIN_ID }) - } - } + fun `find all domains`(): Unit = + runBlocking { + client + .submit(QueryBuilder.findDomains()) + .also { domains -> + assert(domains.any { it.id == DEFAULT_DOMAIN_ID }) + assert(domains.any { it.id == NewDomain.DOMAIN_ID }) + } + } @Test @WithIroha([NewDomain::class]) @@ -349,18 +424,23 @@ class QueriesTest : IrohaTest() { @Query("FindAllDomainsWithFilter") @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 }) - } - } + fun `find all domains with filter`(): Unit = + runBlocking { + 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 @WithIroha([DefaultGenesis::class]) @@ -368,16 +448,12 @@ class QueriesTest : IrohaTest() { @Query("FindDomainById") @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) + fun `find domain by ID`(): Unit = + runBlocking { + client.submit(QueryBuilder.findDomainById(DEFAULT_DOMAIN_ID))!!.also { + assertEquals(DEFAULT_DOMAIN_ID, it.id) } - } + } @Test @WithIroha([DefaultGenesis::class]) @@ -385,16 +461,12 @@ class QueriesTest : IrohaTest() { @Query("FindAllPeers") @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()) - } - } + fun `find all peers`(): Unit = + runBlocking { + client + .submit(QueryBuilder.findPeers()) + .also { assert(it.isNotEmpty()) } + } @Test @WithIroha([DefaultGenesis::class]) @@ -402,28 +474,29 @@ class QueriesTest : IrohaTest() { @Query("FindTransactionsByAccountId") @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) - } - - 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) - } - } + fun `find transactions by account id`(): Unit = + runBlocking { + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).also { + withTimeout(txTimeout) { it.await() } + } + + val result = + client.submit( + QueryBuilder.findTransactions( + CompoundPredicateOfCommittedTransaction.Atom( + CommittedTransactionProjectionOfPredicateMarker.Value( + SignedTransactionProjectionOfPredicateMarker.Authority( + AccountIdProjectionOfPredicateMarker.Atom( + AccountIdPredicateAtom.Equals(ALICE_ACCOUNT_ID), + ), + ), + ), + ), + ), + ) + + assertEquals(1, result.size) + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @@ -431,19 +504,20 @@ class QueriesTest : IrohaTest() { @Query("FindPermissionTokensByAccountId") @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) - } - } + fun `find permission tokens by account id`(): Unit = + runBlocking { + 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 @WithIroha([DefaultGenesis::class]) @@ -451,36 +525,45 @@ class QueriesTest : IrohaTest() { @Query("FindTransactionByHash") @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() } - } - - 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() - - val txByHash = QueryBuilder.findTransactionByHash(hash) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - assertEquals( - DEFAULT_ASSET_DEFINITION_ID.domain, - txByHash.transaction.value - .extractInstruction() - .registerBox.cast().registerOfDomain.`object`.id, - ) - txByHash.transaction.value - .let { SignedTransaction.encode(it).hash() } - .also { assertContentEquals(hash, it) } - } + fun `find transaction by hash`(): Unit = + runBlocking { + client.submit(Register.assetDefinition(DEFAULT_ASSET_DEFINITION_ID, AssetType.numeric())).let { + withTimeout(txTimeout) { it.await() } + } + + 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()), + ), + ), + ), + ), + ), + ) + + assertEquals(1, transactions.size) + assertEquals( + DEFAULT_ASSET_DEFINITION_ID.domain, + transactions[0] + .value + .extractInstruction() + .registerBox + .cast() + .registerOfDomain.`object`.id, + ) + transactions[0] + .value + .let { SignedTransaction.encode(it).hash() } + .also { assertContentEquals(hash, it) } + } @Test @WithIroha([NewDomainWithMetadata::class]) @@ -488,15 +571,17 @@ class QueriesTest : IrohaTest() { @Query("FindDomainKeyValueByIdAndKey") @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) } - } + fun `find domain key value by ID and key`(): Unit = + runBlocking { + val metadata = + client + .submit( + QueryBuilder.findDomainById(NewDomainWithMetadata.DOMAIN_ID), + )!! + .metadata.sortedMapOfName + + assertEquals(NewDomainWithMetadata.VALUE, metadata[NewDomainWithMetadata.KEY]!!.readValue()) + } @Test @WithIroha([WithExecutableTrigger::class]) @@ -504,29 +589,13 @@ class QueriesTest : IrohaTest() { @Query("FindTriggerById") @Story("Trigger queries trigger by ID") @SdkTestId("find_trigger_by_id") - 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 } } - } + fun `find trigger by ID`(): Unit = + runBlocking { + val triggerId = WithExecutableTrigger.TRIGGER_ID - @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 @WithIroha([WithExecutableTrigger::class]) @@ -534,17 +603,24 @@ class QueriesTest : IrohaTest() { @Query("FindAllActiveTriggerIds") @Story("Trigger queries all active trigger IDs") @SdkTestId("find_all_active_trigger_ids") - 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 } } - } - } + fun `find all active trigger IDs`(): Unit = + runBlocking { + val triggerId = WithExecutableTrigger.TRIGGER_ID + + val triggers = + client.submit( + QueryBuilder.findActiveTriggerIds( + CompoundPredicateOfTriggerId.Atom( + TriggerIdProjectionOfPredicateMarker.Atom( + TriggerIdPredicateAtom.Equals(triggerId), + ), + ), + ), + ) + + assertEquals(1, triggers.size) + assertEquals(triggerId, triggers[0]) + } @Test @WithIroha([DefaultGenesis::class]) @@ -552,27 +628,23 @@ class QueriesTest : IrohaTest() { @Query("FindAllAccountsWithPaginationAndSorting") @Story("Account queries all accounts with pagination and sorting by metadata key") @SdkTestId("pagination_plus_sorting_by_metadata_key") - fun `pagination plus sorting by metadata key`(): Unit = runBlocking { - 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")) - - 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]) + fun `pagination plus sorting by metadata key`(): Unit = + runBlocking { + val key1 = RandomStringUtils.randomAlphabetic(5).asName() + val key2 = RandomStringUtils.randomAlphabetic(5).asName() + + 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 -> + 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()) } + } } - } @Test @WithIroha([NewDomainWithMetadata::class]) @@ -580,65 +652,81 @@ class QueriesTest : IrohaTest() { @Query("FindAllAccountsWithPagination") @Story("Account queries all accounts with pagination after inserting some new accounts") @SdkTestId("pagination_works_correct_after_inserting_some_new_accounts") - fun `pagination works correct after inserting some new accounts`(): Unit = runBlocking { - 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) } - .let { accounts -> - assertEquals(limit, accounts.size.toLong()) - assertEquals(metadata2, accounts[2].metadata.sortedMapOfName[key]) - } - 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) } - .let { accounts -> - assertEquals(2, accounts.size) - assertEquals(metadata4, accounts[1].metadata.sortedMapOfName[key]) - } + fun `pagination works correct after inserting some new accounts`(): Unit = + runBlocking { + val key = "ts".asName() + val limit = 3L + + 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][key]!!.readValue()) + } + 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][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) } - .let { accounts -> - assertEquals(3, accounts.size) - assertEquals(metadata6, accounts[0].metadata.sortedMapOfName[key]) - assertEquals(metadata8, accounts[2].metadata.sortedMapOfName[key]) - } - print(metadata5) - print(metadata7) - } + 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][key]!!.readValue()) + assertEquals(metadata8, accounts[2][key]!!.readValue()) + } + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @@ -646,25 +734,23 @@ class QueriesTest : IrohaTest() { @Query("FindAllAccountsWithPagination") @Story("Account queries all accounts with pagination") @SdkTestId("find_all_account_with_pagination") - 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) } - 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) } - assertEquals(limit - start, accounts.size.toLong()) - } + fun `find all account with pagination`(): Unit = + runBlocking { + val limit = 5L + val start = 3L + + var accounts = client.submit(QueryBuilder.findAccounts().pagination(BigInteger.valueOf(5))) + assertEquals(3, accounts.size) + + repeat(2) { createAccount() } + accounts = + client.submit( + QueryBuilder + .findAccounts() + .pagination(BigInteger.valueOf(limit), BigInteger.valueOf(start)), + ) + assertEquals(limit - start, accounts.size.toLong()) + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @@ -672,24 +758,17 @@ class QueriesTest : IrohaTest() { @Query("FindAllTransactions") @Story("Account queries all transactions") @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() } + fun `find all transactions`(): Unit = + runBlocking { + repeat(5) { + 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 @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @@ -697,61 +776,68 @@ class QueriesTest : IrohaTest() { @Query("FindAllBlocks") @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() } - } - QueryBuilder.findAllBlocks() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { blocks -> - assertTrue(blocks.size == 2) + fun `find all blocks`(): Unit = + runBlocking { + client.submit(Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1))).also { + withTimeout(txTimeout) { it.await() } } - } - - @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() } - } - QueryBuilder.findAllBlockHeaders() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { client.sendQuery(it) } - .also { headers -> - assertTrue(headers.size == 2) + client.submit(QueryBuilder.findBlocks()).also { + assertEquals(2, it.size) } - } + } + +// @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 @WithIroha([AliceHasRoleWithAccessToBobsMetadata::class]) @@ -759,34 +845,12 @@ class QueriesTest : IrohaTest() { @Query("FindRolesByAccountId") @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, - ) + fun `find roles by account ID`(): Unit = + runBlocking { + client.submit(QueryBuilder.findRolesByAccountId(ALICE_ACCOUNT_ID)).also { + assertContains(it, AliceHasRoleWithAccessToBobsMetadata.ROLE_ID) } - } + } @Test @WithIroha([AliceHasRoleWithAccessToBobsMetadata::class]) @@ -794,14 +858,22 @@ class QueriesTest : IrohaTest() { @Query("FindRoleByRoleId") @Story("Account queries role by role ID") @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) } - } + fun `find role by ID`(): Unit = + runBlocking { + val roleId = AliceHasRoleWithAccessToBobsMetadata.ROLE_ID + + 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 @WithIroha([AliceWithTestAssets::class]) @@ -809,47 +881,45 @@ class QueriesTest : IrohaTest() { @Query("FindAssetDefinitionsWithOrFilter") @Story("Account queries asset definitions with or filter") @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}"), - ) - 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) - } - } + fun `find asset definitions with or filter`(): Unit = + runBlocking { + val definitionId = AliceWithTestAssets.TEST_ASSET_DEFINITION_ID + + val assets = + client.submit( + QueryBuilder.findAssetsDefinitions( + CompoundPredicateOfAssetDefinition.Atom( + AssetDefinitionProjectionOfPredicateMarker.Id( + AssetDefinitionIdProjectionOfPredicateMarker.Atom(AssetDefinitionIdPredicateAtom.Equals(definitionId)), + ), + ), + ), + ) + + assertEquals(1, assets.size) + assertEquals(definitionId, assets[0].id) + } @WithIroha([WithManyDomains::class]) @Feature("Domains") @Query("FindAllDomains") @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) } - assertEquals(WithManyDomains.DOMAINS_COUNT + 2, domains.size) - } + fun `find multiple domains with cursor test`(): Unit = + runBlocking { + 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(), + 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..becf6b425 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,315 +57,325 @@ import java.time.Instant import java.util.Date import kotlin.test.assertEquals import kotlin.test.assertNotNull +import kotlin.test.assertNull @Feature("Triggers") @Owner("akostyuchenko") @Sdk("Java/Kotlin") class TriggersTest : IrohaTest() { - @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Data created trigger mints asset upon asset definition creation") @SdkTestId("data_created_trigger") - fun `data created trigger`(): Unit = runBlocking { - val triggerId = TriggerId(name = "data_trigger".asName()) - val newAssetName = "token1" - - // check account assets before trigger - val query = QueryBuilder.findAllAssetsDefinitions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - val assetDefinitions = client.sendQuery(query) - assertEquals(1, assetDefinitions.size) - val asset = assetDefinitions.first { it.id.name.string == "xor" } - assertNotNull(asset) - - // Check default asset quantity before trigger - val prevQuantity = checkDefaultAssetQuantity() - assertEquals(100L, prevQuantity) - - val filter = EventFilterBox.Data( - EntityFilters.byAssetDefinition(1), - ) - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerEventTrigger( - triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 1)), - Repeats.Indefinitely(), - ALICE_ACCOUNT_ID, - Metadata(mapOf()), - filter, - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + fun `data created trigger`(): Unit = + runBlocking { + val triggerId = TriggerId(name = "data_trigger".asName()) + val newAssetName = "token1" + + // check account assets before trigger + val query = QueryBuilder.findAssetsDefinitions() + val assetDefinitions = client.submit(query) + assertEquals(1, assetDefinitions.size) + val asset = assetDefinitions.first { it.id.name.string == "xor" } + assertNotNull(asset) + + // Check default asset quantity before trigger + val prevQuantity = checkDefaultAssetQuantity() + assertEquals(100L, prevQuantity) + + val filter = + EventFilterBox.Data( + EntityFilters.byAssetDefinition(1), + ) + client + .submit( + Register.trigger( + triggerId, + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), + Repeats.Indefinitely(), + ALICE_ACCOUNT_ID, + filter, + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + + // register new asset + // after that trigger should mint DEFAULT_ASSET_ID + createNewAsset(newAssetName, assetDefinitions.size) + + // check new quantity after trigger is run + val newQuantity = checkDefaultAssetQuantity() + assertEquals(prevQuantity + 1L, newQuantity) } - // register new asset - // after that trigger should mint DEFAULT_ASSET_ID - createNewAsset(newAssetName, assetDefinitions.size) - - // check new quantity after trigger is run - val newQuantity = checkDefaultAssetQuantity() - assertEquals(prevQuantity + 1L, newQuantity) - } - @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Pre commit trigger mints asset to account for every transaction") @SdkTestId("pre_commit_trigger_should_mint_asset_to_account_for_every_transaction") - fun `pre commit trigger should mint asset to account for every transaction`(): Unit = runBlocking { - val triggerId = TriggerId(name = "pre_commit_trigger".asName()) - val newAssetName = "token1" - - // check account assets before trigger - val query = QueryBuilder.findAllAssetsDefinitions() - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - val assetDefinitions = client.sendQuery(query) - assertEquals(1, assetDefinitions.size) - - // check DEFAULT_ASSET_ID quantity before trigger - val prevQuantity = checkDefaultAssetQuantity() - assertEquals(100L, prevQuantity) - - // register pre commit trigger - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerPreCommitTrigger( - triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 10)), - Repeats.Indefinitely(), - ALICE_ACCOUNT_ID, - ) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } - } - - // check DEFAULT_ASSET_ID quantity after trigger is run - var newQuantity = checkDefaultAssetQuantity() - assertEquals(110L, newQuantity) - - // register new asset - // after that trigger should mint 10 more quantity to DEFAULT_ASSET_ID - createNewAsset(newAssetName, assetDefinitions.size) - - // check DEFAULT_ASSET_ID quantity after trigger is run - newQuantity = checkDefaultAssetQuantity() - 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() } + fun `pre commit trigger should mint asset to account for every transaction`(): Unit = + runBlocking { + val triggerId = TriggerId(name = "pre_commit_trigger".asName()) + val newAssetName = "token1" + + // check account assets before trigger + val query = QueryBuilder.findAssetsDefinitions() + val assetDefinitions = client.submit(query) + assertEquals(1, assetDefinitions.size) + + // check DEFAULT_ASSET_ID quantity before trigger + val prevQuantity = checkDefaultAssetQuantity() + assertEquals(100L, prevQuantity) + + // register pre commit trigger + client + .submit( + Register.trigger( + triggerId, + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(10))), + Repeats.Indefinitely(), + ALICE_ACCOUNT_ID, + EventFilterBox.Time(TimeEventFilter(ExecutionTime.PreCommit())), + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + + // check DEFAULT_ASSET_ID quantity after trigger is run + var newQuantity = checkDefaultAssetQuantity() + assertEquals(110L, newQuantity) + + // register new asset + // after that trigger should mint 10 more quantity to DEFAULT_ASSET_ID + createNewAsset(newAssetName, assetDefinitions.size) + + // check DEFAULT_ASSET_ID quantity after trigger is run + newQuantity = checkDefaultAssetQuantity() + assertEquals(120L, newQuantity) + + // transfer asset instruction just to test trigger + 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() + assertEquals(30L, newQuantity) } - // check DEFAULT_ASSET_ID quantity after trigger is run - newQuantity = checkDefaultAssetQuantity() - assertEquals(30L, newQuantity) - } - @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Executable trigger mints asset") @SdkTestId("executable_trigger") - fun `executable trigger`(): Unit = runBlocking { - val triggerId = TriggerId(name = "executable_trigger".asName()) - - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerExecutableTrigger( - triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 1)), - Repeats.Exactly(1L), - ALICE_ACCOUNT_ID, - ) - executeTrigger(triggerId) - buildSigned(ALICE_KEYPAIR) - }.also { d -> - withTimeout(txTimeout) { d.await() } + fun `executable trigger`(): Unit = + runBlocking { + val triggerId = TriggerId("executable_trigger".asName()) + + client + .submit( + Register.trigger( + triggerId, + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), + Repeats.Exactly(1L), + ALICE_ACCOUNT_ID, + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(triggerId)), + ), + Execute.trigger(triggerId, null), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + + assertEquals(101L, readQuantity()) } - assertEquals(101L, readQuantity()) - } - @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class], configs = ["LOG_LEVEL${IROHA_CONFIG_DELIMITER}TRACE"]) @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")) - - sendAndAwaitTimeTrigger( - triggerId, - Repeats.Indefinitely(), - Instructions.burnAsset(DEFAULT_ASSET_ID, 1), - ) - sendAndWait10Txs() - - delay(3000) - val q = readQuantity() - assert(q <= 90L) - } + fun `endless time trigger`(): Unit = + runBlocking { + val triggerId = TriggerId("endless_time_trigger".asName()) + + sendAndAwaitTimeTrigger( + triggerId, + Repeats.Indefinitely(), + Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1)), + ) + sendAndWait10Txs() + + delay(3000) + val q = readQuantity() + assert(q <= 90L) + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @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")) - - sendAndAwaitTimeTrigger( - triggerId, - Repeats.Exactly(5L), - Instructions.burnAsset(DEFAULT_ASSET_ID, 1), - ) - sendAndWait10Txs() - - delay(3000) - assertEquals(95, readQuantity()) - } + fun `time trigger execution repeats few times`(): Unit = + runBlocking { + val triggerId = TriggerId("time_trigger".asName()) + + sendAndAwaitTimeTrigger( + triggerId, + Repeats.Exactly(5L), + Burn.asset(DEFAULT_ASSET_ID, BigDecimal(1)), + ) + sendAndWait10Txs() + + delay(3000) + assertEquals(95, readQuantity()) + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Wasm trigger mints NFT for every user") @SdkTestId("wasm_trigger_to_mint_nft_for_every_user") - fun `wasm trigger to mint nft for every user and update trigger metadata`(): Unit = runBlocking { - val triggerId = TriggerId(name = "wasm_trigger".asName()) - - val currentTime = Date().time + 10000 - val filter = EventFilterBox.Time( - EventFilters.timeEventFilter(BigInteger.valueOf(currentTime), BigInteger.valueOf(1000L)), - ) - val wasm = this.javaClass.classLoader - .getResource("create_nft_for_alice_smartcontract.wasm") - .readBytes() - - client.tx { - registerWasmTrigger( - triggerId, - wasm, - Repeats.Indefinitely(), - ALICE_ACCOUNT_ID, - Metadata(mapOf()), - filter, + 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 + 5000 + val filter = + EventFilterBox.Time( + EventFilters.timeEventFilter(BigInteger.valueOf(currentTime), BigInteger.valueOf(1000L)), + ) + val wasm = + this.javaClass.classLoader + .getResource("create_nft_for_alice_smartcontract.wasm") + .readBytes() + + client.submit( + Register.trigger( + triggerId, + wasm, + Repeats.Indefinitely(), + ALICE_ACCOUNT_ID, + filter, + ), ) + keepNetworkBusyAndCheckAssetDefinitionIds() + + val testKey = "key02357123".asName() + val testValue = "value986441123" + client + .submit(SetKeyValue.trigger(triggerId, testKey, testValue)) + .also { d -> + withTimeout(txTimeout) { d.await() } + } + + delay(15000) + + client + .submit(QueryBuilder.findTriggerById(triggerId))!! + .also { + assertEquals( + testValue, + it.action.metadata.sortedMapOfName[testKey]!! + .readValue(), + ) + } } - keepNetworkBusyAndCheckAssetDefinitionIds() - - val testKey = "key02357123" - val testValue = "value986441123" - client.tx { setKeyValue(triggerId, testKey.asName(), testValue) } - - 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)) } - } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Wasm trigger mints NFT for every user when trigger metadata is updated") @SdkTestId("wasm_trigger_to_mint_nft_for_every_user_on_update_trigger_metadata_event") - fun `wasm trigger to mint nft for every user on update trigger metadata event`(): Unit = runBlocking { - val wasmTriggerId = TriggerId(name = "wasm_trigger".asName()) - val setKeyValueTriggerId = TriggerId(name = "update_trigger".asName()) - - val filter = Filters.data( - EntityFilters.byTrigger(1, wasmTriggerId), - ) - val wasm = this.javaClass.classLoader - .getResource("create_nft_for_alice_smartcontract.wasm") - .readBytes() - - client.tx { - registerWasmTrigger( - wasmTriggerId, - wasm, - Repeats.Indefinitely(), - ALICE_ACCOUNT_ID, - Metadata(mapOf()), - filter, - ) - } - val testKey = "key" - val testValue = "value" - client.tx { - registerExecutableTrigger( - setKeyValueTriggerId, - listOf(Instructions.setKeyValue(wasmTriggerId, testKey.asName(), testValue)), - Repeats.Exactly(1L), - ALICE_ACCOUNT_ID, + fun `wasm trigger to mint nft for every user on update trigger metadata event`(): Unit = + runBlocking { + val wasmTriggerId = TriggerId(name = "wasm_trigger".asName()) + val setKeyValueTriggerId = TriggerId(name = "update_trigger".asName()) + + val filter = + Filters.data( + EntityFilters.byTrigger(1, wasmTriggerId), + ) + val wasm = + this.javaClass.classLoader + .getResource("create_nft_for_alice_smartcontract.wasm") + .readBytes() + + client + .submit( + Register.trigger( + wasmTriggerId, + wasm, + Repeats.Indefinitely(), + ALICE_ACCOUNT_ID, + filter, + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + val testKey = "key".asName() + val testValue = "value" + client.submit( + Register.trigger( + setKeyValueTriggerId, + listOf(SetKeyValue.trigger(wasmTriggerId, testKey, testValue)), + Repeats.Exactly(1L), + ALICE_ACCOUNT_ID, + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(setKeyValueTriggerId)), + ), + Execute.trigger(setKeyValueTriggerId, null), ) - executeTrigger(setKeyValueTriggerId) - } - keepNetworkBusyAndCheckAssetDefinitionIds() - - QueryBuilder.findTriggerById(wasmTriggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } - .also { assertEquals(testValue, it.action.metadata.getStringValue(testKey)) } - } + keepNetworkBusyAndCheckAssetDefinitionIds() + + client + .submit(QueryBuilder.findTriggerById(wasmTriggerId))!! + .also { + assertEquals( + testValue, + it.action.metadata.sortedMapOfName[testKey]!! + .readValue(), + ) + } + } @Test @WithIroha([AliceHas100XorAndPermissionToMintAndBurn::class]) @Story("Unregister an executable trigger") @SdkTestId("unregister_executable_trigger") - fun `unregister executable trigger`(): Unit = runBlocking { - val triggerName = "executable_trigger" - val triggerId = TriggerId(name = triggerName.asName()) - - client.sendTransaction { - accountId = ALICE_ACCOUNT_ID - registerExecutableTrigger( - triggerId, - listOf(Instructions.mintAsset(DEFAULT_ASSET_ID, 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() } - } - - assertThrows { - runBlocking { - QueryBuilder.findTriggerById(triggerId) - .account(ALICE_ACCOUNT_ID) - .buildSigned(ALICE_KEYPAIR) - .let { query -> client.sendQuery(query) } + fun `unregister executable trigger`(): Unit = + runBlocking { + val triggerName = "executable_trigger" + val triggerId = TriggerId(name = triggerName.asName()) + + client + .submit( + Register.trigger( + triggerId, + listOf(Mint.asset(DEFAULT_ASSET_ID, BigDecimal(1))), + Repeats.Exactly(1L), + ALICE_ACCOUNT_ID, + EventFilterBox.ExecuteTrigger(ExecuteTriggerEventFilter(triggerId)), + ), + ).also { d -> + withTimeout(txTimeout) { d.await() } + } + + 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,94 +383,105 @@ 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() - } - - private suspend fun sendAndAwaitTimeTrigger( + ): Long = + client + .submit(QueryBuilder.findAssetById(assetId))!! + .value + .cast() + .numeric + .asLong() + + private suspend fun sendAndAwaitTimeTrigger( triggerId: TriggerId, repeats: Repeats, - instruction: InstructionBox, + instruction: I, accountId: AccountId = ALICE_ACCOUNT_ID, ) { - client.sendTransaction { - this.accountId = accountId - registerTimeTrigger( - triggerId, - listOf(instruction), - repeats, - accountId, - EventFilters.timeEventFilter( - BigInteger.valueOf(Instant.now().toEpochMilli()), - BigInteger.valueOf(500L), + client + .submit( + Register.trigger( + triggerId, + listOf(instruction), + repeats, + accountId, + 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) { + 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, - "nft_number_1_for_${ALICE_PUBLIC_KEY.payload.toHex(true)}".asName(), - ) + val expectedDefinition = + AssetDefinitionId( + DEFAULT_DOMAIN_ID, + "nft_number_1_for_${ALICE_PUBLIC_KEY.payload.toHex(true)}".asName(), + ) assert(assets.size > 1) assert(assets.all { it.id.account == ALICE_ACCOUNT_ID }) 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/annotations/Permission.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Permission.kt index 3b68e223e..d31bc313f 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Permission.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Permission.kt @@ -9,4 +9,6 @@ import java.lang.annotation.Inherited @Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS) @LabelAnnotation(name = "permission") @Repeatable -annotation class Permission(val value: String) +annotation class Permission( + val value: String, +) diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Query.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Query.kt index 4dcdbfa17..92091c236 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Query.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Query.kt @@ -9,4 +9,6 @@ import java.lang.annotation.Inherited @Target(AnnotationTarget.FUNCTION) @LabelAnnotation(name = "query") @Repeatable -annotation class Query(val value: String) +annotation class Query( + val value: String, +) diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Sdk.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Sdk.kt index f62090de9..18984f2c5 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Sdk.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/Sdk.kt @@ -8,4 +8,6 @@ import java.lang.annotation.Inherited @Retention(AnnotationRetention.RUNTIME) @Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS) @LabelAnnotation(name = "sdk") -annotation class Sdk(val value: String) +annotation class Sdk( + val value: String, +) diff --git a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/SdkTestId.kt b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/SdkTestId.kt index 553af31d1..bf815ab4e 100644 --- a/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/SdkTestId.kt +++ b/modules/client/src/test/kotlin/jp/co/soramitsu/iroha2/annotations/SdkTestId.kt @@ -9,4 +9,6 @@ import java.lang.annotation.Inherited @Target(AnnotationTarget.FUNCTION) @LabelAnnotation(name = "sdk_test_id") @Repeatable -annotation class SdkTestId(val value: String) +annotation class SdkTestId( + val value: String, +) 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..670186a8e 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 @@ -35,81 +54,102 @@ import kotlin.random.Random.Default.nextDouble /** * Create a default genesis where there is just one domain with only Alice and Bob in it */ -open class DefaultGenesis(transaction: RawGenesisTransaction? = null) : Genesis(transaction ?: rawGenesisTx()) +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 +157,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 +175,61 @@ 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, ), - Parameter.Executor( - SmartContractParameter.Fuel(NonZeroOfu64(BigInteger.valueOf(5500000000))), + Grant.accountPermission( + CanBurnAssetWithDefinition(DEFAULT_ASSET_DEFINITION_ID), + ALICE_ACCOUNT_ID, ), + 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 +239,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 +259,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 +283,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 +302,46 @@ 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), - - Instructions.registerAssetDefinition(VAL_DEFINITION_ID, AssetType.numeric()), - Instructions.mintAsset(AssetId(ALICE_ACCOUNT_ID, VAL_DEFINITION_ID), VAL_QUANTITY), - ), -) { +open class XorAndValAssets : + Genesis( + rawGenesisTx( + Register.assetDefinition(XOR_DEFINITION_ID, AssetType.numeric()), + Mint.asset(AssetId(ALICE_ACCOUNT_ID, XOR_DEFINITION_ID), XOR_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 +354,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 +383,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 +410,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 +471,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..5dfa8d06a 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 @@ -19,21 +19,22 @@ import kotlin.test.assertEquals import kotlin.test.assertTrue class CryptoTest { - @Test fun `generating key pairs is thread safe`() { val iterations = 1000 - val futureResults = generateSequence { - CoroutineScope(Dispatchers.Default) - .async { generateKeyPair() } - }.take(iterations).toSet() + val futureResults = + generateSequence { + CoroutineScope(Dispatchers.Default) + .async { generateKeyPair() } + }.take(iterations).toSet() - class ByteArrayWrapper(private val byteArray: ByteArray) { + class ByteArrayWrapper( + private val byteArray: ByteArray, + ) { 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() @@ -42,9 +43,11 @@ class CryptoTest { runBlocking { assertEquals( iterations, - futureResults.map { it.await().private.bytes() } + futureResults + .map { it.await().private.bytes() } .map { ByteArrayWrapper(it) } - .toSet().size, + .toSet() + .size, ) } } @@ -53,7 +56,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 +75,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..76d26c282 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 @@ -12,7 +12,6 @@ import kotlin.test.assertFailsWith import kotlin.test.assertTrue class FixnumTest { - @Test fun `check there and back works for floating point numbers with fractional parts only`() { val random = SecureRandom() @@ -52,7 +51,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..21f8f4285 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,16 @@ fun main(args: Array) { /** * Parse the [arguments][args] */ -fun parseArgs(args: Array): Map { - return args.map { it.split("=") } +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..21d538276 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) { @@ -90,43 +86,50 @@ fun resolveKotlinType(type: Type): TypeName { /** * Check if the given [type] is one of the [built-in Kotlin types][builtinKotlinTypes] */ -fun lookUpInBuiltInTypes(type: Type): TypeName = builtinKotlinTypes[type::class] - ?: throw RuntimeException("unexpected type: $type") +fun lookUpInBuiltInTypes(type: Type): TypeName = + builtinKotlinTypes[type::class] + ?: throw RuntimeException("unexpected type: $type") /** * 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) - .removeSuffix("::") - .removePrefix("iroha") - .replace("::", ".") - .replace("_", "") -} +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] */ -fun defineClassName(typeName: String) = typeName.substringBefore('<') - .substringAfterLast("::") +fun defineClassName(typeName: String) = + typeName + .substringBefore('<') + .substringAfterLast("::") -val builtinKotlinTypes = mapOf, TypeName>( - StringType::class to String::class.asTypeName(), - BooleanType::class to Boolean::class.asTypeName(), - U8Type::class to Short::class.asTypeName(), - U16Type::class to Int::class.asTypeName(), - U32Type::class to Long::class.asTypeName(), - U64Type::class to BigInteger::class.asTypeName(), - U128Type::class to BigInteger::class.asTypeName(), - U256Type::class to BigInteger::class.asTypeName(), - I8Type::class to Byte::class.asTypeName(), - I16Type::class to Short::class.asTypeName(), - I32Type::class to Int::class.asTypeName(), - I64Type::class to Long::class.asTypeName(), - 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(), -) +val builtinKotlinTypes = + mapOf, TypeName>( + StringType::class to String::class.asTypeName(), + BooleanType::class to Boolean::class.asTypeName(), + U8Type::class to Short::class.asTypeName(), + U16Type::class to Int::class.asTypeName(), + U32Type::class to Long::class.asTypeName(), + U64Type::class to BigInteger::class.asTypeName(), + U128Type::class to BigInteger::class.asTypeName(), + U256Type::class to BigInteger::class.asTypeName(), + I8Type::class to Byte::class.asTypeName(), + I16Type::class to Short::class.asTypeName(), + I32Type::class to Int::class.asTypeName(), + I64Type::class to Long::class.asTypeName(), + I128Type::class to BigInteger::class.asTypeName(), + I256Type::class to BigInteger::class.asTypeName(), + VecType::class to List::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..47e7ff01c 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 @@ -6,7 +6,9 @@ import jp.co.soramitsu.iroha2.type.Type /** * Basic blueprint for all kinds of types */ -abstract class Blueprint(val source: T) { +abstract class Blueprint( + val source: T, +) { abstract val className: String abstract val packageName: String abstract val properties: List @@ -17,4 +19,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..44bc01a52 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 @@ -5,12 +5,13 @@ import jp.co.soramitsu.iroha2.type.EnumType /** * Blueprint for [EnumType] */ -class EnumBlueprint(type: EnumType) : TypeBasedBlueprint(type) { +class EnumBlueprint( + type: EnumType, +) : TypeBasedBlueprint(type) { val variants = resolveVariants() - private fun resolveVariants(): List { - return source.variants.map { + 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..646880d50 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 @@ -12,13 +12,13 @@ class EnumVariantBlueprint( val parentBlueprint: EnumBlueprint, source: EnumType.Variant, ) : Blueprint(source) { - override val className = defineClassName(source.name) override val packageName = "${parentBlueprint.packageName}.${parentBlueprint.className}" override val properties = resolveProperties(source) - override fun resolveProperties(variant: EnumType.Variant): List { - return variant.type?.requireValue() + override fun resolveProperties(variant: EnumType.Variant): List = + variant.type + ?.requireValue() ?.let { type -> Property( defineClassName(type.name).replaceFirstChar(Char::lowercase), @@ -26,5 +26,4 @@ class EnumVariantBlueprint( 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..19fd955a2 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 @@ -7,16 +7,17 @@ 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) -> +class StructBlueprint( + type: StructType, +) : TypeBasedBlueprint(type) { + override fun resolveProperties(type: StructType): List = + type.mapping.map { (name, ty) -> Property( convertToCamelCase(name), resolveKotlinType(ty.requireValue()), ty.requireValue(), ) } - } /** * Create property name by converting from snake case to camel case 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..8efaf6af9 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 @@ -9,27 +9,38 @@ import jp.co.soramitsu.iroha2.type.Type /** * Blueprint for [TupleStructType] */ -class TupleStructBlueprint(type: TupleStructType) : TypeBasedBlueprint(type) { +class TupleStructBlueprint( + type: TupleStructType, +) : TypeBasedBlueprint(type) { override fun resolveProperties(type: TupleStructType): List { - val unique = type.types.map { it.name }.distinct().size == type.types.size + val unique = + type.types + .map { it.name } + .distinct() + .size == type.types.size var propertyCount = 1 - return type.types.map { - it.requireValue() - }.map { - Property(createPropName(it, unique, propertyCount++), resolveKotlinType(it), it) - } + return type.types + .map { + it.requireValue() + }.map { + Property(createPropName(it, unique, propertyCount++), resolveKotlinType(it), it) + } } - private fun createPropName(type: Type, unique: Boolean = true, propertyCount: Int? = null): String { - return when (type) { + 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() }}" + 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/blueprint/TypeBasedBlueprint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TypeBasedBlueprint.kt index 0da06f763..1bb478395 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TypeBasedBlueprint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/blueprint/TypeBasedBlueprint.kt @@ -8,7 +8,9 @@ import jp.co.soramitsu.iroha2.type.CompositeType * Blueprint for a specific type */ @ExperimentalUnsignedTypes -abstract class TypeBasedBlueprint(source: T) : Blueprint(source) { +abstract class TypeBasedBlueprint( + source: T, +) : Blueprint(source) { override val className: String = defineClassName(source.name) override val packageName: String = definePackageName(className, source) override val properties = resolveProperties(source) 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..e499c92bf 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,14 +13,17 @@ 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 /** * Basic generator for all kinds of [blueprints][Blueprint] */ abstract class AbstractGenerator> { - companion object { val ANY_TYPE = ClassName("kotlin", "Any") } @@ -38,7 +42,10 @@ abstract class AbstractGenerator> { return clazz.build() } - open fun implGenerics(blueprint: T, clazz: TypeSpec.Builder) { + open fun implGenerics( + blueprint: T, + clazz: TypeSpec.Builder, + ) { if (blueprint.source is CompositeType) { val generics = blueprint.source.generics for (i in generics.indices) { @@ -47,29 +54,39 @@ abstract class AbstractGenerator> { } } - open fun implClassBody(blueprint: T, clazz: TypeSpec.Builder) { + open fun implClassBody( + blueprint: T, + clazz: TypeSpec.Builder, + ) { implFunctions(blueprint, clazz) implInnerClasses(blueprint, clazz) clazz.addType(implCompanions(blueprint, clazz).build()) } - open fun implCompanions(blueprint: T, clazz: TypeSpec.Builder): TypeSpec.Builder { - val thisType = ClassName( - blueprint.packageName, - blueprint.className, - ).let { className -> - when (blueprint.source is CompositeType && blueprint.source.generics.isNotEmpty()) { - true -> className.parameterizedBy( - blueprint.source.generics.map { WildcardTypeName.producerOf(ANY_TYPE) }, - ) - false -> className + open fun implCompanions( + blueprint: T, + clazz: TypeSpec.Builder, + ): TypeSpec.Builder { + val thisType = + ClassName( + blueprint.packageName, + blueprint.className, + ).let { className -> + when (blueprint.source is CompositeType && blueprint.source.generics.isNotEmpty()) { + true -> + className.parameterizedBy( + blueprint.source.generics.map { WildcardTypeName.producerOf(ANY_TYPE) }, + ) + false -> className + } } - } - val companionBuilder = TypeSpec.companionObjectBuilder() - .addSuperinterface(SCALE_READER.parameterizedBy(thisType)) - .addSuperinterface(SCALE_WRITER.parameterizedBy(thisType)) - .addFunction(readFun(thisType, blueprint)) - .addFunction(writeFun(thisType, blueprint)) + val companionBuilder = + TypeSpec + .companionObjectBuilder() + .addSuperinterface(SCALE_READER.parameterizedBy(thisType)) + .addSuperinterface(SCALE_WRITER.parameterizedBy(thisType)) + .addFunction(readFun(thisType, blueprint)) + .addFunction(writeFun(thisType, blueprint)) return when { blueprint.properties.isEmpty() && KModifier.SEALED !in clazz.modifiers -> { @@ -80,9 +97,11 @@ abstract class AbstractGenerator> { } open fun scaleReaderCode(blueprint: T): CodeBlock { - var result = CodeBlock.builder() - .add("return try {\n") - .indent() + var result = + CodeBlock + .builder() + .add("return try {\n") + .indent() result.add("${blueprint.className}(\n").indent() val codeBlocks = blueprint.properties.map { resolveScaleReadImpl(it.original) }.toList() for (cb in codeBlocks) { @@ -92,58 +111,122 @@ abstract class AbstractGenerator> { .unindent() .add(")\n") .unindent() - .add("} catch (ex: Exception) {\n").indent() - .add("throw %M(ex)\n", SCALE_CODEC_EX_WRAPPER).unindent() + .add("} catch (ex: Exception) {\n") + .indent() + .add("throw %M(ex)\n", SCALE_CODEC_EX_WRAPPER) + .unindent() .add("}") .build() } open fun scaleWriterCode(blueprint: T): CodeBlock { - var result = CodeBlock.builder() - .add("return try {\n") - .indent() - val codeBlocks = blueprint.properties.map { - resolveScaleWriteImpl( - it.original, - CodeBlock.of("instance.%N", it.name), - ) - } + var result = + CodeBlock + .builder() + .add("return try {\n") + .indent() + val codeBlocks = + blueprint.properties.map { + resolveScaleWriteImpl( + it.original, + CodeBlock.of("instance.%N", it.name), + ) + } for (cb in codeBlocks) { result = result.add(cb).add("\n") } return result .unindent() - .add("} catch (ex: Exception) {\n").indent() - .add("throw %M(ex)\n", SCALE_CODEC_EX_WRAPPER).unindent() + .add("} catch (ex: Exception) {\n") + .indent() + .add("throw %M(ex)\n", SCALE_CODEC_EX_WRAPPER) + .unindent() .add("}") .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 + open fun implInnerClasses( + blueprint: T, + clazz: TypeSpec.Builder, + ) = Unit - open fun implClassModifiers(blueprint: T, clazz: TypeSpec.Builder) { + open fun implClassModifiers( + blueprint: T, + clazz: TypeSpec.Builder, + ) { if (blueprint.properties.isNotEmpty()) { clazz.addModifiers(KModifier.DATA) } } - 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) { + open fun implConstructor( + blueprint: T, + clazz: TypeSpec.Builder, + ) { if (blueprint.properties.isEmpty()) { return } val constructorBuilder = FunSpec.constructorBuilder() for ((name, type) in blueprint.properties) { constructorBuilder.addParameter( - ParameterSpec.builder(name, type) + ParameterSpec + .builder(name, type) .let { it.takeIf { type.isNullable }?.defaultValue("null") ?: it } .build(), ) clazz.addProperty( - PropertySpec.builder(name, type) + PropertySpec + .builder(name, type) .initializer(name) .build(), ) @@ -151,35 +234,55 @@ abstract class AbstractGenerator> { clazz.primaryConstructor(constructorBuilder.build()) } - open fun implKDoc(blueprint: T, clazz: TypeSpec.Builder) { + open fun implKDoc( + blueprint: T, + clazz: TypeSpec.Builder, + ) { 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 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)) + private fun asInstructionBoxFun() = + FunSpec + .builder("asInstructionBox") + .addCode(CodeBlock.of("return %M()", MemberName("jp.co.soramitsu.iroha2", "asInstructionBoxExt"))) .addModifiers(KModifier.OVERRIDE) - .returns(type) + .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) - val code = """return when (o2) { - null -> false - else -> o2::class == o1::class - } - """.trimIndent() + val code = + """ + return when (o2) { + null -> false + else -> o2::class == o1::class + } + """.trimIndent() - return FunSpec.builder("equals") + return FunSpec + .builder("equals") .addParameter(ParameterSpec.builder("o1", variantType).build()) .addParameter(ParameterSpec.builder("o2", ANY_TYPE.copy(nullable = true)).build()) .addCode(code) @@ -188,18 +291,21 @@ abstract class AbstractGenerator> { } private fun variantHashcodeFun(blueprint: T): FunSpec { - val code = "return \"${blueprint.packageName}.${blueprint.className}\".hashCode()" - .replace("jp.co.soramitsu.iroha2.generated.", "") - return FunSpec.builder("hashCode") + val code = + "return \"${blueprint.packageName}.${blueprint.className}\".hashCode()" + .replace("jp.co.soramitsu.iroha2.generated.", "") + return FunSpec + .builder("hashCode") .addCode(code) .addModifiers(KModifier.OVERRIDE) .returns(Int::class) .build() } - protected fun TypeName.extractName() = when (this) { - is ParameterizedTypeName -> this.rawType.canonicalName - is ClassName -> this.canonicalName - else -> throw RuntimeException("Unexpected type: $this") - } + protected fun TypeName.extractName() = + when (this) { + is ParameterizedTypeName -> this.rawType.canonicalName + is ClassName -> this.canonicalName + else -> throw RuntimeException("Unexpected type: $this") + } } 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..e5036d997 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 @@ -12,23 +12,35 @@ import jp.co.soramitsu.iroha2.codegen.blueprint.EnumBlueprint * Generator for [EnumBlueprint] */ object EnumGenerator : AbstractGenerator() { - - override fun implKDoc(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) { + override fun implKDoc( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) { super.implKDoc(blueprint, clazz) clazz.addKdoc("\n\nGenerated from '${blueprint.source.name}' enum") } - override fun implClassModifiers(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) { + override fun implClassModifiers( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) { clazz.addModifiers(KModifier.SEALED) } // class generated from Rust Enums no need to have constructor due they are not intended // to be instantiated - override fun implConstructor(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) = Unit - - override fun implFunctions(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) { + override fun implConstructor( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) = Unit + + override fun implFunctions( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) { clazz.addFunction( - FunSpec.builder("discriminant") + FunSpec + .builder("discriminant") .addModifiers(KModifier.ABSTRACT) .returns(Int::class, CodeBlock.of("Discriminator of variant in enum")) .build(), @@ -38,7 +50,10 @@ object EnumGenerator : AbstractGenerator() { } } - override fun implInnerClasses(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) { + override fun implInnerClasses( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) { for (variant in blueprint.variants) { clazz.addType(EnumVariantGenerator.generate(variant)) } @@ -46,9 +61,10 @@ object EnumGenerator : AbstractGenerator() { override fun scaleReaderCode(blueprint: EnumBlueprint): CodeBlock { val codeBlock = CodeBlock.builder().add("return when(val discriminant = reader.readUByte()) {\n") - val whenFlow = blueprint.variants.joinToString("\n") { - CodeBlock.of("\t${it.discriminant} -> ${it.className}.read(reader)").toString() - } + val whenFlow = + blueprint.variants.joinToString("\n") { + CodeBlock.of("\t${it.discriminant} -> ${it.className}.read(reader)").toString() + } codeBlock.add(whenFlow) codeBlock.add("\n\telse -> throw RuntimeException(\"Unresolved discriminant of the enum variant: \$discriminant\")") return codeBlock.add("}").build() @@ -57,47 +73,53 @@ object EnumGenerator : AbstractGenerator() { override fun scaleWriterCode(blueprint: EnumBlueprint): CodeBlock { val codeBlock = CodeBlock.builder().add("writer.directWrite(instance.discriminant())\n") codeBlock.add("when(val discriminant = instance.discriminant()) {\n") - val whenFlow = blueprint.variants.joinToString("\n") { - CodeBlock.of("\t${it.discriminant} -> ${it.className}.write(writer, instance as ${it.className})") - .toString() - } + val whenFlow = + blueprint.variants.joinToString("\n") { + CodeBlock + .of("\t${it.discriminant} -> ${it.className}.write(writer, instance as ${it.className})") + .toString() + } codeBlock.add(whenFlow) codeBlock.add("\n\telse -> throw RuntimeException(\"Unresolved discriminant of the enum variant: \$discriminant\")") return codeBlock.add("}").build() } - override fun implSuperClasses(blueprint: EnumBlueprint, clazz: TypeSpec.Builder) { + override fun implSuperClasses( + blueprint: EnumBlueprint, + clazz: TypeSpec.Builder, + ) { super.implSuperClasses(blueprint, clazz) clazz.addSuperinterface(ModelEnum::class) } - private fun hashCodeFun(blueprint: EnumBlueprint): FunSpec { - return FunSpec.builder("hashCode") + 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 { - return FunSpec.builder("equals") + 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") - blueprint.variants.filter { - it.properties.isEmpty() - }.joinToString("\n") { - CodeBlock.of("\tis ${it.className} -> ${it.className}.equals(this, other)").toString() - }.also { whenFlow -> - codeBlock.add(whenFlow) - } + blueprint.variants + .filter { + it.properties.isEmpty() + }.joinToString("\n") { + CodeBlock.of("\tis ${it.className} -> ${it.className}.equals(this, other)").toString() + }.also { whenFlow -> + codeBlock.add(whenFlow) + } codeBlock.add("\n\telse -> super.equals(other)") return codeBlock.add("}").build() } @@ -105,13 +127,14 @@ object EnumGenerator : AbstractGenerator() { private fun hashcodeCode(blueprint: EnumBlueprint): CodeBlock { val codeBlock = CodeBlock.builder().add("return when(this) {\n") - blueprint.variants.filter { - it.properties.isEmpty() - }.joinToString("\n") { - CodeBlock.of("\tis ${it.className} -> ${it.className}.hashCode()").toString() - }.also { whenFlow -> - codeBlock.add(whenFlow) - } + blueprint.variants + .filter { + it.properties.isEmpty() + }.joinToString("\n") { + CodeBlock.of("\tis ${it.className} -> ${it.className}.hashCode()").toString() + }.also { whenFlow -> + codeBlock.add(whenFlow) + } codeBlock.add("\n\telse -> super.hashCode()") return codeBlock.add("}").build() } 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..cbe97d985 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 @@ -14,14 +14,20 @@ import jp.co.soramitsu.iroha2.codegen.resolveKotlinType * Generator for [EnumVariantBlueprint] */ object EnumVariantGenerator : AbstractGenerator() { - - override fun implKDoc(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder) { + override fun implKDoc( + blueprint: EnumVariantBlueprint, + clazz: TypeSpec.Builder, + ) { clazz.addKdoc("'${blueprint.className}' variant") } - override fun implFunctions(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder) { + override fun implFunctions( + blueprint: EnumVariantBlueprint, + clazz: TypeSpec.Builder, + ) { clazz.addFunction( - FunSpec.builder("discriminant") + FunSpec + .builder("discriminant") .addModifiers(KModifier.OVERRIDE) .returns(Int::class) .addCode("return DISCRIMINANT") @@ -29,19 +35,24 @@ object EnumVariantGenerator : AbstractGenerator() { ) } - override fun implConstructor(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder) { + override fun implConstructor( + blueprint: EnumVariantBlueprint, + clazz: TypeSpec.Builder, + ) { if (blueprint.properties.isNotEmpty()) { val constructorBuilder = FunSpec.constructorBuilder() for (property in blueprint.properties) { constructorBuilder.addParameter( - ParameterSpec.builder(property.name, property.typeName) + ParameterSpec + .builder(property.name, property.typeName) .build(), ) clazz.addProperty( - PropertySpec.builder( - property.name, - property.typeName, - ).initializer(property.name) + PropertySpec + .builder( + property.name, + property.typeName, + ).initializer(property.name) .build(), ) } @@ -52,27 +63,32 @@ object EnumVariantGenerator : AbstractGenerator() { override fun implCompanions( blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder, - ): TypeSpec.Builder { - return super.implCompanions(blueprint, clazz) + ): TypeSpec.Builder = + super + .implCompanions(blueprint, clazz) .addProperty( - PropertySpec.builder("DISCRIMINANT", Int::class, KModifier.CONST) + PropertySpec + .builder("DISCRIMINANT", Int::class, KModifier.CONST) .initializer("%L", blueprint.discriminant) .build(), ) - } - override fun implSuperClasses(blueprint: EnumVariantBlueprint, clazz: TypeSpec.Builder) { + override fun implSuperClasses( + blueprint: EnumVariantBlueprint, + clazz: TypeSpec.Builder, + ) { super.implSuperClasses(blueprint, clazz) val className = ClassName(blueprint.parentBlueprint.packageName, blueprint.parentBlueprint.className) val generics = blueprint.parentBlueprint.source.generics if (generics.isNotEmpty()) { - className.parameterizedBy( - generics.map { - resolveKotlinType(it.requireValue()) - }, - ).also { clazz.superclass(it) } + className + .parameterizedBy( + generics.map { + resolveKotlinType(it.requireValue()) + }, + ).also { clazz.superclass(it) } } else { clazz.superclass(className) } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/GeneratorEntryPoint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/GeneratorEntryPoint.kt index 665a25ead..6e2982652 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/GeneratorEntryPoint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/codegen/generator/GeneratorEntryPoint.kt @@ -17,35 +17,44 @@ import java.nio.file.Path */ object GeneratorEntryPoint { @OptIn(ExperimentalUnsignedTypes::class) - fun generate(types: Map, outputPath: Path) { - types.values.mapNotNull { type -> - when (type) { - is StructType -> StructBlueprint(type) - is EnumType -> EnumBlueprint(type) - is TupleStructType -> TupleStructBlueprint(type) - else -> null - } - }.forEach { type -> - val typeSpec = when (type) { - is StructBlueprint -> StructGenerator.generate(type) - is EnumBlueprint -> EnumGenerator.generate(type) - is TupleStructBlueprint -> TupleStructGenerator.generate(type) - else -> throw RuntimeException("Unexpected blueprint type: ${type::class}") - } - val builder = FileSpec.builder(type.packageName, type.className) - .addType(typeSpec) - .addFileComment("\nAuto-generated file. DO NOT EDIT!\n") + fun generate( + types: Map, + outputPath: Path, + ) { + types.values + .mapNotNull { type -> + when (type) { + is StructType -> StructBlueprint(type) + is EnumType -> EnumBlueprint(type) + is TupleStructType -> TupleStructBlueprint(type) + else -> null + } + }.forEach { type -> + val typeSpec = + when (type) { + is StructBlueprint -> StructGenerator.generate(type) + is EnumBlueprint -> EnumGenerator.generate(type) + is TupleStructBlueprint -> TupleStructGenerator.generate(type) + else -> throw RuntimeException("Unexpected blueprint type: ${type::class}") + } + val builder = + FileSpec + .builder(type.packageName, type.className) + .addType(typeSpec) + .addFileComment("\nAuto-generated file. DO NOT EDIT!\n") - val isSortedMap = type.properties - .map { it.original as? MapType } - .any { it?.sortedByKey == true } - val isSortedVec = type.properties - .map { it.original as? IterableType } - .any { it?.sorted == true } - if (isSortedMap || isSortedVec) { - builder.addImport("jp.co.soramitsu.iroha2", "comparator") + val isSortedMap = + type.properties + .map { it.original as? MapType } + .any { it?.sortedByKey == true } + val isSortedVec = + type.properties + .map { it.original as? IterableType } + .any { it?.sorted == true } + if (isSortedMap || isSortedVec) { + builder.addImport("jp.co.soramitsu.iroha2", "comparator") + } + builder.build().writeTo(outputPath) } - builder.build().writeTo(outputPath) - } } } 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..c6cecaf93 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,19 +46,16 @@ 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) { +fun resolveScaleReadImpl(type: Type): CodeBlock = + 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 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()") @@ -75,20 +70,20 @@ fun resolveScaleReadImpl(type: Type): CodeBlock { 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") } -} /** * Resolve Scale Writer for a given [type] */ -fun resolveScaleWriteImpl(type: Type, propName: CodeBlock): CodeBlock { - return when (type) { +fun resolveScaleWriteImpl( + type: Type, + propName: CodeBlock, +): CodeBlock = + 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) @@ -104,43 +99,40 @@ fun resolveScaleWriteImpl(type: Type, propName: CodeBlock): CodeBlock { 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") } -} /** * @return the class name for a given [type][typeName] */ -fun withoutGenerics(typeName: TypeName): ClassName { - return when (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()) { +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()), - ) + else -> + CodeBlock.of( + "reader.readArray(%L) {%L}", + this.size, + resolveScaleReadImpl(this.innerType.requireValue()), + ) } -} -private fun VecType.scaleReadImpl(): CodeBlock { - return when (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()), - ) + else -> + CodeBlock.of( + "reader.readVec(reader.readCompactInt()) {%L}", + resolveScaleReadImpl(this.innerType.requireValue()), + ) } -} private fun CompositeType.scaleReadImpl(): CodeBlock { val typeName = resolveKotlinType(this) @@ -152,31 +144,21 @@ private fun CompositeType.scaleReadImpl(): CodeBlock { } } -private fun OptionType.scaleReadImpl(): CodeBlock { - return when (this.innerType.requireValue()) { +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 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") + 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()) { +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()") @@ -184,15 +166,15 @@ private fun CompactType.scaleReadImpl(): CodeBlock { 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 { val key = (resolveKotlinType(this.key.requireValue()) as ClassName) val keyName = key.simpleName - val sorted = when { - this.sortedByKey -> CodeBlock.of(".toSortedMap(\n%1L.comparator()\n)", CodeBlock.of(keyName)) - else -> CodeBlock.of("") - } + val sorted = + when { + this.sortedByKey -> CodeBlock.of(".toSortedMap(\n%1L.comparator()\n)", CodeBlock.of(keyName)) + else -> CodeBlock.of("") + } return CodeBlock.of( "writer.writeCompact(%1L.size)\n" + "%1L%4L.forEach { (key, value) ->\n\t%2L\n\t%3L\n}", @@ -203,29 +185,23 @@ 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 { - 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)), - propName, - ) +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 ArrayType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { +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")) @@ -236,20 +212,20 @@ private fun ArrayType.scaleWriteImpl(propName: CodeBlock): CodeBlock { ) } } -} -private fun VecType.scaleWriteImpl(propName: CodeBlock): CodeBlock { - return when (this.innerType.requireValue()) { +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 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("") } - false -> CodeBlock.of("") - } val value = resolveScaleWriteImpl(this.innerType.requireValue(), CodeBlock.of("value")) CodeBlock.of( @@ -260,14 +236,5 @@ private fun VecType.scaleWriteImpl(propName: CodeBlock): CodeBlock { ) } } -} - -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")), - ) -} 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..78e3b1884 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 @@ -11,13 +11,18 @@ import jp.co.soramitsu.iroha2.codegen.blueprint.StructBlueprint * Generator for [StructBlueprint] */ object StructGenerator : AbstractGenerator() { - - override fun implKDoc(blueprint: StructBlueprint, clazz: TypeSpec.Builder) { + override fun implKDoc( + blueprint: StructBlueprint, + clazz: TypeSpec.Builder, + ) { super.implKDoc(blueprint, clazz) clazz.addKdoc("\n\nGenerated from '${blueprint.source.name}' regular structure") } - override fun implFunctions(blueprint: StructBlueprint, clazz: TypeSpec.Builder) { + override fun implFunctions( + blueprint: StructBlueprint, + clazz: TypeSpec.Builder, + ) { super.implFunctions(blueprint, clazz) if (blueprint.properties.any { it.typeName.extractName() == ByteArray::class.qualifiedName }) { @@ -25,8 +30,9 @@ object StructGenerator : AbstractGenerator() { } } - private fun hashCodeFun(blueprint: StructBlueprint): FunSpec { - return FunSpec.builder("hashCode") + private fun hashCodeFun(blueprint: StructBlueprint): FunSpec = + FunSpec + .builder("hashCode") .addModifiers(KModifier.OVERRIDE) .returns(Int::class) .apply { @@ -49,10 +55,10 @@ object StructGenerator : AbstractGenerator() { } } }.build() - } - private fun equalsFun(blueprint: StructBlueprint): FunSpec { - return FunSpec.builder("equals") + 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) @@ -67,5 +73,4 @@ object StructGenerator : AbstractGenerator() { } addStatement("return true") }.build() - } } diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/ExtractGeneric.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/ExtractGeneric.kt index eb08e97f5..a661fe86d 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/ExtractGeneric.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/parse/ExtractGeneric.kt @@ -7,7 +7,10 @@ private const val TYPE_GROUP_INDEX = 2 // first one will be the entire typeDef, /** * Extract generics from [name] using [parser] */ -fun extractGeneric(name: String, parser: SchemaParser): List { +fun extractGeneric( + name: String, + parser: SchemaParser, +): List { val groups = GENERIC_REGEX.find(name)?.groupValues ?: return listOf() val rawType = groups.getOrNull(TYPE_GROUP_INDEX) ?: return listOf() return rawType.split(", ").map { parser.createAndGetNest(it) } 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..39a7dd33c 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 @@ -6,7 +6,6 @@ import jp.co.soramitsu.iroha2.type.Type * Parser for Iroha2 schema */ class SchemaParser { - private val registry = HashMap() private val resolver = TypeResolver(this) @@ -16,12 +15,14 @@ class SchemaParser { * @return resolved types */ fun parse(schema: Map): Map { - val preprocessed = schema - .map { entry -> createAndGetNest(entry.key, entry.value) } - .associateBy { it.name } - val notResolvedTypes = preprocessed - .flatMap { it.value.notResolvedTypes() } - .toSet() + val preprocessed = + schema + .map { entry -> createAndGetNest(entry.key, entry.value) } + .associateBy { it.name } + val notResolvedTypes = + preprocessed + .flatMap { it.value.notResolvedTypes() } + .toSet() if (notResolvedTypes.isNotEmpty()) { throw RuntimeException("Some types are not resolved: $notResolvedTypes") } @@ -31,13 +32,16 @@ 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..102b977c5 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 @@ -7,7 +7,6 @@ import jp.co.soramitsu.iroha2.DEFINITION_SCHEMA_GENERIC_REGEX import kotlin.streams.toList class SchemaReader { - private val repeated = mutableMapOf() private val toReplace = mutableMapOf() @@ -22,6 +21,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()) } @@ -49,9 +49,11 @@ class SchemaReader { val mutable = immutable.map { this.contains(it) }.all { !it } if (mutable && repeated[values[1]] != null) { val source = "${values[1]}<${values[2]}>" - return source to source.replace("<", "Of") - .replace(", ", "And") - .replace(">", "") + return source to + source + .replace("<", "Of") + .replace(", ", "And") + .replace(">", "") } else if (this.contains("Option>( - BooleanResolver, - SortedMapResolver, - BitMapResolver, - OptionResolver, - VectorResolver, - SortedVectorResolver, - ArrayResolver, - EnumResolver, - TupleStructResolver, - StructResolver, - OneStringStructResolver, - StringResolver, - CompactResolver, - UIntResolver, - IntResolver, - SetResolver, - FixedPointResolver, - QueryResolver, - ) +class TypeResolver( + private val schemaParser: SchemaParser, +) { + private val resolvers = + listOf>( + BooleanResolver, + SortedMapResolver, + BitMapResolver, + OptionResolver, + VectorResolver, + SortedVectorResolver, + ArrayResolver, + EnumResolver, + TupleStructResolver, + StructResolver, + OneStringStructResolver, + StringResolver, + CompactResolver, + UIntResolver, + IntResolver, + ) /** * Resolve the type based on a given [name]. @@ -64,11 +61,15 @@ class TypeResolver(private val schemaParser: SchemaParser) { * @param name The name to resolve * @param typeValue The type to try and resolve the [name] to */ - fun resolve(name: String, typeValue: Any?): Type? { - val candidates = resolvers - .asSequence() - .mapNotNull { it.resolve(name, typeValue, schemaParser) } - .toSet() + fun resolve( + name: String, + typeValue: Any?, + ): Type? { + val candidates = + resolvers + .asSequence() + .mapNotNull { it.resolve(name, typeValue, schemaParser) } + .toSet() return candidates.firstOrNull() } } @@ -81,29 +82,39 @@ 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) { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): BooleanType? = + when (name) { "bool" -> BooleanType else -> null } - } } /** * Resolver for [MapType] */ 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 @@ -119,16 +130,21 @@ object BitMapResolver : Resolver { * Resolver for [MapType] */ 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) - .removeSurrounding("<", ">") - .split(',') - .map { it.trim() } + val wildcards = + name + .removePrefix(NAME) + .removeSurrounding("<", ">") + .split(',') + .map { it.trim() } if (wildcards.size != 2) return null return MapType( @@ -143,9 +159,15 @@ 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 { +abstract class WrapperResolver( + open val wrapperName: String, +) : Resolver { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): T? = + when { name.startsWith("$wrapperName<") -> { val innerTypeName = name.removeSurrounding("$wrapperName<", ">") val innerType = schemaParser.createAndGetNest(innerTypeName) @@ -158,12 +180,15 @@ abstract class WrapperResolver(open val wrapperName: String) : Resolve } 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 } /** @@ -172,16 +197,16 @@ abstract class WrapperResolver(open val wrapperName: String) : Resolve 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 { + 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,14 +218,17 @@ object SortedVectorResolver : SortedWrapperResolver("SortedVec") { sorted: Boolean, ) = VecType(name, innerType, sorted) - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): VecType? { - return when ( + 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,35 +243,30 @@ object VectorResolver : SortedWrapperResolver("Vec") { sorted: Boolean, ) = VecType(name, innerType, sorted) - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): VecType? { - return when ( + 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(), false) false -> null } - } -} - -/** - * Resolver for [SetType] - */ -object SetResolver : WrapperResolver("BTreeSet") { - override fun createWrapper( - name: String, - innerType: TypeNest, - sorted: Boolean, - ) = SetType(name, innerType, sorted) } /** * Resolver for [ArrayType] */ 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,23 +299,27 @@ 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) { + 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), - ) - } + 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,8 +330,8 @@ object TupleStructResolver : Resolver { name: String, typeValue: Any?, schemaParser: SchemaParser, - ): TupleStructType? { - return if (typeValue is Map<*, *> && typeValue["Tuple"] != 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) @@ -312,15 +339,18 @@ object TupleStructResolver : Resolver { } else { null } - } } /** * Resolver for [StructType] */ object StructResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StructType? { - return if ((typeValue is Map<*, *> && typeValue["Struct"] != 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) { @@ -333,72 +363,73 @@ object StructResolver : Resolver { } else { null } - } } /** * Resolver for [StructType] */ object OneStringStructResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StructType? { - return if (typeValue is String) { + 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 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 -> - val parts = name.split("<") - val firstPart = parts.first() - val lastPart = parts.last().split(",") - .first().replaceFirstChar { it.uppercase() } - .replace(">", "") - - when (firstPart.lowercase() == lastPart.lowercase()) { - true -> firstPart - false -> "${firstPart}Of$lastPart" - } - } -} -/** - * 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 + private fun String.toFieldName() = + this.replaceFirstChar { it.lowercase() }.let { name -> + val parts = name.split("<") + val firstPart = parts.first() + val lastPart = + parts + .last() + .split(",") + .first() + .replaceFirstChar { it.uppercase() } + .replace(">", "") + + when (firstPart.lowercase() == lastPart.lowercase()) { + true -> firstPart + false -> "${firstPart}Of$lastPart" + } } - } } /** * Resolver for [StringType] */ object StringResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): StringType? { - return when { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): StringType? = + when { name.endsWith("String") -> StringType else -> null } - } } /** * Resolver for [UIntType] */ object UIntResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): UIntType? { - return when (name) { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): UIntType? = + when (name) { "AtomicU32Wrapper" -> U32Type "NonZeroU8" -> U8Type "u8" -> U8Type @@ -409,15 +440,18 @@ object UIntResolver : Resolver { "u256" -> U256Type else -> null } - } } /** * Resolver for [IntType] */ object IntResolver : Resolver { - override fun resolve(name: String, typeValue: Any?, schemaParser: SchemaParser): IntType? { - return when (name) { + override fun resolve( + name: String, + typeValue: Any?, + schemaParser: SchemaParser, + ): IntType? = + when (name) { "i8" -> I8Type "i16" -> I16Type "i32" -> I32Type @@ -426,30 +460,15 @@ object IntResolver : Resolver { "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 - } - } } /** * `TypeNest` contains [the name of the type][name] and [the type it resolves to][value] */ -data class TypeNest(val name: String, var value: Type?) { - +data class TypeNest( + val name: String, + var value: Type?, +) { private var resolutionInProgress: Boolean = false fun requireValue() = value ?: NullType @@ -471,7 +490,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..c2fb9866d 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 @@ -7,12 +7,14 @@ import jp.co.soramitsu.iroha2.parse.TypeNest * * The [type names][name] are resolved with a [TypeResolver]. */ -sealed class Type(open val name: String) { +sealed class Type( + open val name: String, +) { open fun notResolvedTypes(): Set = setOf() } /** - * 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..0613ec09d 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 @@ -5,7 +5,10 @@ import jp.co.soramitsu.iroha2.parse.TypeNest /** * Basic class for different composite types */ -abstract class CompositeType(override val name: String, open val generics: List) : Type(name) +abstract class CompositeType( + override val name: String, + open val generics: List, +) : Type(name) /** * `EnumType` composite type @@ -15,11 +18,14 @@ data class EnumType( override val generics: List, val variants: List, ) : CompositeType(name, generics) { - /** * 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 @@ -28,9 +34,11 @@ data class EnumType( return setOf() } resolutionInProgress = true - val result = generics.union(variants.mapNotNull { it.type }) - .flatMap { it.value?.notResolvedTypes() ?: setOf(it.name) } - .toSet() + val result = + generics + .union(variants.mapNotNull { it.type }) + .flatMap { it.value?.notResolvedTypes() ?: setOf(it.name) } + .toSet() resolutionInProgress = false return result } @@ -44,11 +52,12 @@ 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 +68,10 @@ 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/Int.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Int.kt index 132ac4e5f..92122e121 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Int.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Int.kt @@ -3,7 +3,9 @@ package jp.co.soramitsu.iroha2.type /** * Integer types */ -abstract class IntType(name: String) : Type(name) +abstract class IntType( + name: String, +) : Type(name) /** * 8-bit integers diff --git a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Uint.kt b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Uint.kt index cdd45180f..ed1fb65cb 100644 --- a/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Uint.kt +++ b/modules/codegen/src/main/kotlin/jp/co/soramitsu/iroha2/type/Uint.kt @@ -3,7 +3,9 @@ package jp.co.soramitsu.iroha2.type /** * Unigned integer types */ -abstract class UIntType(name: String) : Type(name) +abstract class UIntType( + name: String, +) : Type(name) /** * 8-bit unsigned integers 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..303200604 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 @@ -5,12 +5,16 @@ import jp.co.soramitsu.iroha2.parse.TypeNest /** * Basic class for wrapper types. The `WrapperType` data type wraps [another type][innerType]. */ -abstract class WrapperType(override val name: String, open val innerType: TypeNest) : Type(name) { - override fun notResolvedTypes() = if (innerType.value == null) { - setOf(innerType.name) - } else { - setOf() - } +abstract class WrapperType( + override val name: String, + open val innerType: TypeNest, +) : Type(name) { + override fun notResolvedTypes() = + if (innerType.value == null) { + setOf(innerType.name) + } else { + setOf() + } } /** @@ -39,15 +43,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. */ @@ -65,12 +60,3 @@ 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) 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..9323de29c 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 @@ -27,29 +27,32 @@ fun Name.Companion.comparator() = compareBy { it.string } * Compare account IDs */ @JvmName("AccountIdComparator") -fun AccountId.Companion.comparator() = compareBy { it.domain.name.string }.thenComparator { o1, o2 -> - PublicKey.comparator().compare(o1.signatory, o2.signatory) -} +fun AccountId.Companion.comparator() = + compareBy { it.domain.name.string }.thenComparator { o1, o2 -> + PublicKey.comparator().compare(o1.signatory, o2.signatory) + } /** * Compare asset definition IDs */ @JvmName("AssetDefinitionIdComparator") -fun AssetDefinitionId.Companion.comparator() = compareBy { it.name.string } - .thenBy { it.domain.name.string } +fun AssetDefinitionId.Companion.comparator() = + compareBy { it.name.string } + .thenBy { it.domain.name.string } /** * Compare asset IDs */ @JvmName("AssetIdComparator") -fun AssetId.Companion.comparator() = Comparator { o1, o2 -> - AssetDefinitionId.comparator().compare( - o1.definition, - o2.definition, - ) -}.thenComparator { o1, o2 -> - AccountId.comparator().compare(o1.account, o2.account) -} +fun AssetId.Companion.comparator() = + Comparator { o1, o2 -> + AssetDefinitionId.comparator().compare( + o1.definition, + o2.definition, + ) + }.thenComparator { o1, o2 -> + AccountId.comparator().compare(o1.account, o2.account) + } /** * Compare role IDs @@ -61,52 +64,59 @@ fun RoleId.Companion.comparator() = compareBy { it.name.string } * Compare public keys */ @JvmName("PublicKeyComparator") -fun PublicKey.Companion.comparator() = Comparator { o1, o2 -> - ByteArray::class.comparator().compare(o1.payload, o2.payload) -} +fun PublicKey.Companion.comparator() = + Comparator { o1, o2 -> + ByteArray::class.comparator().compare(o1.payload, o2.payload) + } /** * Compare signatures */ @JvmName("SignatureOfComparator") -fun SignatureOf.Companion.comparator() = Comparator> { o1, o2 -> - ByteArray::class.comparator().compare( - o1.signature.payload, - o2.signature.payload, - ) -} +fun SignatureOf.Companion.comparator() = + Comparator> { o1, o2 -> + ByteArray::class.comparator().compare( + o1.signature.payload, + o2.signature.payload, + ) + } /** * Compare permissions */ @JvmName("PermissionComparator") -fun Permission.Companion.comparator() = compareBy { - it.name -}.thenComparator { o1, o2 -> - o1.payload?.compareTo(o2.payload ?: "") ?: 0 -} +fun Permission.Companion.comparator() = + compareBy { + it.name + }.thenComparator { o1, o2 -> + o1.payload.string.compareTo(o2.payload.string) + } /** * Compare custom parameter ID */ @JvmName("CustomParameterIdComparator") -fun CustomParameterId.Companion.comparator() = compareBy { - it.name.string -} - -private fun KClass.comparator() = Comparator { o1, o2 -> - if (o1.size != o2.size) { - throw ComparisonException("Unexpected payload length") +fun CustomParameterId.Companion.comparator() = + compareBy { + it.name.string } - o1.forEachIndexed { index, b1 -> - val result = b1.compareTo(o2[index]) - if (result != 0) return@Comparator result +private fun KClass.comparator() = + Comparator { o1, o2 -> + if (o1.size != o2.size) { + throw ComparisonException("Unexpected payload length") + } + + o1.forEachIndexed { index, b1 -> + val result = b1.compareTo(o2[index]) + if (result != 0) return@Comparator result + } + return@Comparator 0 } - return@Comparator 0 -} /** * Throw if an exception occurs during comparison */ -class ComparisonException(message: String) : RuntimeException(message) +class ComparisonException( + message: String, +) : RuntimeException(message) 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 62% 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..c4dcf6a9a 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 @@ -17,7 +17,10 @@ import java.security.SecureRandom @JvmField val DEFAULT_SPEC: EdDSANamedCurveSpec = EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.ED_25519) -enum class DigestFunction(val hashFunName: String, val index: Int) { +enum class DigestFunction( + val hashFunName: String, + val index: Int, +) { Ed25519("ed25519", 0xed), } @@ -27,8 +30,8 @@ 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 { +fun generateKeyPair(spec: EdDSAParameterSpec = DEFAULT_SPEC): KeyPair = + try { val seed = ByteArray(spec.curve.field.getb() / 8) SecureRandom().nextBytes(seed) @@ -41,12 +44,9 @@ fun generateKeyPair(spec: EdDSAParameterSpec = DEFAULT_SPEC): KeyPair { } 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 +54,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 +66,14 @@ 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 +81,17 @@ 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 +104,25 @@ 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) { +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..07e7ce453 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 @@ -3,14 +3,41 @@ package jp.co.soramitsu.iroha2 /** * Top-level error that can be thrown by the client */ -open class IrohaSdkException(message: String? = null, cause: Throwable? = null) : Exception(message, cause) +open class IrohaSdkException( + message: String? = null, + cause: Throwable? = null, +) : Exception(message, cause) /** * Throw if there is an exception during scale encoding/decoding */ -class ScaleCodecException(message: String? = null, cause: Throwable? = null) : IrohaSdkException(message, cause) +class ScaleCodecException( + message: String? = null, + cause: Throwable? = null, +) : IrohaSdkException(message, cause) /** * 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) +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/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt new file mode 100644 index 000000000..c3a8a56e7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Extensions.kt @@ -0,0 +1,440 @@ +@file:Suppress("ktlint:standard:no-wildcard-imports") + +package jp.co.soramitsu.iroha2 + +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 +import java.math.BigDecimal +import java.math.BigInteger +import java.security.MessageDigest +import java.security.PrivateKey +import java.security.PublicKey +import kotlin.experimental.or +import jp.co.soramitsu.iroha2.generated.PublicKey as IrohaPublicKey + +fun BlockSubscriptionRequest.Companion.of(from: Long) = BlockSubscriptionRequest(NonZeroOfu64(BigInteger.valueOf(from))) + +fun Signature.asSignatureOf() = SignatureOf(this) + +fun String.asAccountId() = + this + .split(ACCOUNT_ID_DELIMITER) + .takeIf { + it.size == 2 + }?.let { parts -> + AccountId(parts[1].asDomainId(), publicKeyFromHex(parts[0]).toIrohaPublicKey()) + } ?: throw IllegalArgumentException("Incorrect account ID: $this") + +fun String.asAssetDefinitionId() = + this + .split(ASSET_ID_DELIMITER) + .takeIf { + it.size == 2 + }?.let { parts -> + AssetDefinitionId(parts[1].asDomainId(), parts[0].asName()) + } ?: throw IllegalArgumentException("Incorrect asset definition ID: $this") + +fun String.asAssetId() = + this + .split(ASSET_ID_DELIMITER) + .takeIf { + it.size == 3 + }?.let { parts -> + parts[2].asAccountId().let { accountId -> + val domainId = parts[1].takeIf { it.isNotBlank() }?.asDomainId() + + AssetId( + accountId, + AssetDefinitionId( + domainId ?: accountId.domain, + parts[0].asName(), + ), + ) + } + } ?: throw IllegalArgumentException("Incorrect asset ID: $this") + +fun String.asDomainId() = DomainId(Name(this)) + +fun String.asRoleId() = RoleId(Name(this)) + +fun String.asName() = Name(this) + +fun ByteArray.toHex(withPrefix: Boolean = false): String = + try { + val prefix = + when (withPrefix) { + true -> "ed0120" + false -> "" + } + "${prefix}${Hex.toHexString(this)}" + } catch (ex: Exception) { + throw HexCodecException("Cannot encode to hex string", ex) + } + +fun String.fromHex(): ByteArray = + try { + Hex.decode(this) + } catch (ex: Exception) { + throw HexCodecException("Cannot decode from hex string `$this`", ex) + } + +/** + * Convert a public key to an Iroha public key + */ +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.signAs(message: ByteArray): ByteArray = + try { + val sgr = EdDSAEngine(MessageDigest.getInstance(DEFAULT_SPEC.hashAlgorithm)) + sgr.initSign(this) + sgr.update(message.hash()) + sgr.sign() + } catch (ex: Exception) { + throw CryptoException("Cannot sign message", ex) + } + +/** + * Verify the [signature] against the [message] and the given public key + * + * Note: the message must not be prehashed + */ +fun PublicKey.verify( + signature: ByteArray, + message: ByteArray, +): Boolean = + try { + val sgr = EdDSAEngine(MessageDigest.getInstance(DEFAULT_SPEC.hashAlgorithm)) + sgr.initVerify(this) + sgr.update(message.hash()) + sgr.verify(signature) + } catch (ex: Exception) { + throw CryptoException("Cannot verify message", ex) + } + +fun ByteArray.toIrohaHash(): Hash { + if (this.size != 32) throw IrohaSdkException("Hash byte array size must be 32") + + this[31] = this[31] or 1 + return Hash(this) +} + +fun ByteArray.asHashOf() = HashOf(this.toIrohaHash()) + +fun ByteArray.hash(): ByteArray { + val bytes = Blake2b.Blake2b256().digest(this) + bytes[bytes.size - 1] = bytes[bytes.size - 1] or 1 + return bytes +} + +/** + * Hash the given versioned transaction. Maintains only `VersionedTransaction.V1` + */ +fun SignedTransaction.hash() = SignedTransaction.encode(this).hash() + +/** + * Cast to another type + */ +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 AssetDefinitionId.asString() = 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 + +inline fun Json.readValue(): T = JSON_SERDE.readValue(this.string) + +fun Json.Companion.writeValue(value: V): Json { + val value = JSON_SERDE.writeValueAsString(value) + + if (value == "{ }") { + return Json("null") + } + + return Json(value) +} + +fun DomainId.asString() = this.name.string + +fun RoleId.asString() = this.name.string + +fun SocketAddr.asString() = + when (this) { + is SocketAddr.Host -> this.socketAddrHost.let { "${it.host}:${it.port}" } + is SocketAddr.Ipv4 -> this.socketAddrV4.let { "${it.ip}:${it.port}" } + is SocketAddr.Ipv6 -> this.socketAddrV6.let { "${it.ip}:${it.port}" } + } + +fun TriggerId.asString() = this.name.string + +fun Metadata.merge(extra: Metadata) = + Metadata( + this.sortedMapOfName.toMutableMap().also { it.putAll(extra.sortedMapOfName) }, + ) + +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 + is IdBox.AssetId -> this.assetId + is IdBox.AssetDefinitionId -> this.assetDefinitionId + is IdBox.DomainId -> this.domainId + is IdBox.TriggerId -> this.triggerId + is IdBox.PeerId -> this.peerId + is IdBox.CustomParameterId -> this.customParameterId + is IdBox.Permission -> this.permission + } + +fun InstructionBox.extractAccount() = + this + .cast() + .registerBox + .cast() + .registerOfAccount.`object` + +fun InstructionBox.Register.extractAccount() = + this + .registerBox + .cast() + .registerOfAccount.`object` + +fun InstructionBox.Register.extractDomain() = + this + .cast() + .registerBox + .cast() + .registerOfDomain.`object` + +fun InstructionBox.Register.extractAssetDefinition() = + this + .cast() + .registerBox + .cast() + .registerOfAssetDefinition.`object` + +inline fun SignedTransaction.extractInstruction(): I = + this + .cast() + .extractInstruction() + +inline fun SignedTransaction.V1.extractInstruction() = + this + .extractInstructionVec() + .first() + .cast() + +inline fun SignedTransaction.V1.extractInstructions() = + this + .extractInstructionVec() + .cast>() + +inline fun SignedTransaction.V1.extractInstructionVec() = + this + .signedTransactionV1.payload.instructions + .cast() + .vec + .filterIsInstance() + +fun InstructionBox.SetKeyValue.extractDomainId() = + this + .cast() + .setKeyValueBox + .cast() + .setKeyValueOfDomain + .`object` + +fun InstructionBox.Grant.extractValuePermissionToken() = + this + .cast() + .grantBox + .cast() + .grantOfPermissionAndAccount + .`object` + +fun EventFilterBox.extractSchedule() = + this + .cast() + .timeEventFilter.executionTime + .cast() + .schedule + +fun BlockMessage.extractBlock() = + this.signedBlock + .cast() + .signedBlockV1.payload + +fun BlockPayload.height() = this.header.height + +fun Asset.metadata() = + this.value + .cast() + .metadata.sortedMapOfName + +fun String.toSocketAddr() = + this.split(":").let { parts -> + if (parts.size != 2) throw IrohaSdkException("Incorrect address") + + SocketAddr.Host(SocketAddrHost(parts.first(), parts.last().toInt())) + } + +fun FindError.extract() = + when (this) { + is FindError.Account -> this.accountId.asString() + is FindError.Asset -> this.assetId.asString() + is FindError.AssetDefinition -> this.assetDefinitionId.asString() + is FindError.Domain -> this.domainId.asString() + 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.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 Number.asNumeric() = + when (this) { + is Int -> this.asNumeric() + is Long -> this.asNumeric() + is BigInteger -> this.asNumeric() + is Double -> this.asNumeric() + is BigDecimal -> this.asNumeric() + else -> throw IrohaSdkException("Unexpected type to extract numeric ${this::class}") + } + +fun String.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) + +fun Int.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) + +fun Long.asNumeric() = Numeric(mantissa = this.toBigInteger(), scale = 0) + +fun BigInteger.asNumeric() = Numeric(mantissa = this, scale = 0) + +fun Double.asNumeric() = this.toBigDecimal().asNumeric() + +fun BigDecimal.asNumeric() = Numeric(mantissa = this.unscaledValue(), scale = this.scale().toLong()) + +fun Numeric.asInt() = this.mantissa.toInt() + +fun Numeric.asLong() = this.mantissa.toLong() + +fun Numeric.asBigInteger() = this.mantissa + +fun Numeric.asBigDecimal() = BigDecimal.valueOf(this.mantissa.toLong(), this.scale.toInt()) + +fun Numeric.asNumber() = + when (this.scale) { + 0L -> this.mantissa + else -> this.asBigDecimal() + } + +fun Numeric.asString() = this.asNumber().toString() + +fun AssetType.Companion.numeric(scale: Long? = null) = AssetType.Numeric(NumericSpec(scale)) + +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))) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Fixnum.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Fixnum.kt index 8dc54d63f..4e8bc30d5 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Fixnum.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/Fixnum.kt @@ -43,33 +43,35 @@ val POWERS_OF_10: Array by lazy { * * @see https://github.com/loyd/fixnum/blob/77860b04eb53a2e001b3b97fe3601833e18b01b9/src/lib.rs#L581 */ -fun BigInteger.fromFixedPoint(scale: Int = DEFAULT_SCALE): BigDecimal = try { - BigDecimal(this) - .divide(BigDecimal(POWERS_OF_10[scale])) - .stripTrailingZeros() -} catch (ex: Exception) { - throw FixedPointConversionException("Could not convert from fixed point", ex) -} +fun BigInteger.fromFixedPoint(scale: Int = DEFAULT_SCALE): BigDecimal = + try { + BigDecimal(this) + .divide(BigDecimal(POWERS_OF_10[scale])) + .stripTrailingZeros() + } catch (ex: Exception) { + throw FixedPointConversionException("Could not convert from fixed point", ex) + } /** * Convert [BigDecimal] to a fixed-point number * * @see https://github.com/loyd/fixnum/blob/77860b04eb53a2e001b3b97fe3601833e18b01b9/src/lib.rs#L688 */ -fun BigDecimal.toFixedPoint(scale: Int = DEFAULT_SCALE): BigInteger = try { - val thisZeroStripped = this.stripTrailingZeros() - if (thisZeroStripped.scale() > scale) { - throw FixedPointConversionException( - "Scale of the original floating point number is ${thisZeroStripped.scale()}" + - " and it is greater than fixed point number scale: $scale. Need to decrease scale of the original floating point", - ) +fun BigDecimal.toFixedPoint(scale: Int = DEFAULT_SCALE): BigInteger = + try { + val thisZeroStripped = this.stripTrailingZeros() + if (thisZeroStripped.scale() > scale) { + throw FixedPointConversionException( + "Scale of the original floating point number is ${thisZeroStripped.scale()}" + + " and it is greater than fixed point number scale: $scale. Need to decrease scale of the original floating point", + ) + } + thisZeroStripped + .multiply(BigDecimal.valueOf(POWERS_OF_10[scale])) + .toBigIntegerExact() + } catch (ex: Exception) { + when (ex) { + is FixedPointConversionException -> throw ex + else -> throw FixedPointConversionException("Could not convert to fixed point number", ex) + } } - thisZeroStripped - .multiply(BigDecimal.valueOf(POWERS_OF_10[scale])) - .toBigIntegerExact() -} catch (ex: Exception) { - when (ex) { - is FixedPointConversionException -> throw ex - else -> throw FixedPointConversionException("Could not convert to fixed point number", ex) - } -} 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..ac66a86a5 --- /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 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..48d559496 --- /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 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 67% 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..9f9061aff 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,21 +204,30 @@ 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) - } - - private fun deserializeInstruction(jsonNode: JsonNode, mapper: ObjectMapper): InstructionBox { + 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() val param = node.key - val subtype = InstructionBox::class.nestedClasses.find { clazz -> - !clazz.isCompanion && clazz.simpleName == param - } ?: throw DeserializationException("Class with constructor($param) not found") + val subtype = + InstructionBox::class.nestedClasses.find { clazz -> + !clazz.isCompanion && clazz.simpleName == param + } ?: throw DeserializationException("Class with constructor($param) not found") - val argTypeName = subtype.primaryConstructor?.parameters - ?.firstOrNull()?.type?.toString() - ?: throw DeserializationException("Subtype parameter not found by $param") + val argTypeName = + subtype.primaryConstructor + ?.parameters + ?.firstOrNull() + ?.type + ?.toString() + ?: throw DeserializationException("Subtype parameter not found by $param") val toConvert: JsonNode = node.value @@ -245,34 +237,43 @@ object InstructionDeserializer : JsonDeserializer() { } object GrantBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): GrantBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): GrantBox { val node = p.readValueAsTree() - val paramClass = node.fields().next().key.toArg() + val paramClass = + node + .fields() + .next() + .key + .toArg() return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (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) { + 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") } - } } object AssetValueDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetValue { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): AssetValue { val node = p.readValueAsTree().fields().next() return when (node.key) { "Store" -> AssetValue.Store(Metadata(mapOf())) @@ -285,13 +286,17 @@ 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() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): RegisterBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): RegisterBox { val node = p.readValueAsTree().fields().next() val paramClass = node.key.toArg() @@ -300,153 +305,181 @@ object RegisterBoxDeserializer : JsonDeserializer() { return getRegisterBox(value) } - private fun String.toArg(): Class<*> { - return when (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" -> Role::class.java + "Role" -> NewRole::class.java else -> throw DeserializationException("Unknown string type: $this") } - } - private fun getRegisterBox(arg: Any): RegisterBox { - return when (arg) { + 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)) + 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 Role -> RegisterBox.Role(RegisterOfRole(arg)) + is NewRole -> RegisterBox.Role(RegisterOfRole(arg)) else -> throw DeserializationException("Register box `$arg` not found") } - } } /** * Deserializer for [BurnBox] */ object BurnBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): BurnBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): BurnBox { val node = p.readValueAsTree() - val paramClass = node.fields().next().key.toArg() + val paramClass = + node + .fields() + .next() + .key + .toArg() return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (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) { + 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") } - } } object MintBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): MintBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): MintBox { val node = p.readValueAsTree() - val paramClass = node.fields().next().key.toArg() + val paramClass = + node + .fields() + .next() + .key + .toArg() return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (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) { + 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") } - } } object EventFilterBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): EventFilterBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): EventFilterBox { val node = p.readValueAsTree().fields().next() return getBox(JSON_SERDE.convertValue(node.value, node.key.toArg())) } - private fun String.toArg(): Class<*> { - return when (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) { + private fun getBox(arg: Any): EventFilterBox = + when (arg) { is ExecuteTriggerEventFilter -> EventFilterBox.ExecuteTrigger(arg) is TimeEventFilter -> EventFilterBox.Time(arg) else -> throw DeserializationException("Unknown type `$this`") } - } } object TriggerIdDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): TriggerId { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): TriggerId { val triggerName = p.readValueAsTree().asText() return getTriggerId(triggerName) } } object TransferBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): TransferBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): TransferBox { val node = p.readValueAsTree() - val paramClass = node.fields().next().key.toArg() + val paramClass = + node + .fields() + .next() + .key + .toArg() return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (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) { + 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("SetKeyValue box `$arg` not found") + else -> throw DeserializationException("Transfer box `$arg` not found") } - } } object SetKeyValueBoxDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): SetKeyValueBox { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): SetKeyValueBox { val node = p.readValueAsTree() - val paramClass = node.fields().next().key.toArg() + val paramClass = + node + .fields() + .next() + .key + .toArg() return get(JSON_SERDE.convertValue(node.fields().next().value, paramClass)) } - private fun String.toArg(): Class<*> { - return when (this) { + private fun String.toArg(): Class<*> = + when (this) { "Domain" -> SetKeyValueOfDomain::class.java "Account" -> SetKeyValueOfAccount::class.java "Asset" -> SetKeyValueOfAsset::class.java @@ -454,10 +487,9 @@ object SetKeyValueBoxDeserializer : JsonDeserializer() { "Trigger" -> SetKeyValueOfTrigger::class.java else -> throw DeserializationException("Unknown type: $this") } - } - private fun get(arg: Any): SetKeyValueBox { - return when (arg) { + private fun get(arg: Any): SetKeyValueBox = + when (arg) { is SetKeyValueOfDomain -> SetKeyValueBox.Domain(arg) is SetKeyValueOfAccount -> SetKeyValueBox.Account(arg) is SetKeyValueOfAsset -> SetKeyValueBox.Asset(arg) @@ -465,26 +497,29 @@ object SetKeyValueBoxDeserializer : JsonDeserializer() { is SetKeyValueOfTrigger -> SetKeyValueBox.Trigger(arg) else -> throw DeserializationException("SetKeyValue box `$arg` not found") } - } } /** * Deserializer for [Metadata] */ object MetadataDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Metadata { - return deserializeMetadata(p, JSON_SERDE) - } - - private fun deserializeMetadata(p: JsonParser, mapper: ObjectMapper): Metadata { + 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() if (!nodeMetadata.hasNext()) { return Metadata(mapOf()) } 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,45 +527,73 @@ object MetadataDeserializer : JsonDeserializer() { * Deserializer for [AssetType] */ object AssetTypeDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): AssetType { - return when (p.readValueAsTree().textValue()) { + 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") } - } } /** * 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() } /** * Deserializer for [Permission] */ object PermissionDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Permission { + 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,16 +601,20 @@ 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)) } /** * Deserializer for [NewAssetDefinition] */ object NewAssetDefinitionDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NewAssetDefinition { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): NewAssetDefinition { val node = p.readValueAsTree() val domainId = node["id"].asText().asAssetDefinitionId() val mintable = JSON_SERDE.convertValue(node["mintable"], Mintable::class.java) @@ -563,7 +630,10 @@ object NewAssetDefinitionDeserializer : JsonDeserializer() { * Deserializer for [NewDomain] */ object NewDomainDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): NewDomain { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): NewDomain { val node = p.readValueAsTree() val domainId = node["id"].asText().asDomainId() val logo = JSON_SERDE.convertValue(node["logo"], IpfsPath::class.java) @@ -577,7 +647,10 @@ object NewDomainDeserializer : JsonDeserializer() { * Deserializer for [Trigger] */ object TriggerDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Trigger { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Trigger { val node = p.readValueAsTree() val triggerId = TriggerId(node["id"].asText().asName()) val action = JSON_SERDE.convertValue(node["action"], Action::class.java) @@ -590,7 +663,10 @@ object TriggerDeserializer : JsonDeserializer() { * Deserializer for [ExecuteTriggerEventFilter] */ object ExecuteTriggerEventFilterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ExecuteTriggerEventFilter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): ExecuteTriggerEventFilter { val node = p.readValueAsTree() val triggerId = TriggerId(node["trigger"].asText().asName()) val authority = JSON_SERDE.convertValue(node["authority"], AccountId::class.java) @@ -603,7 +679,10 @@ object ExecuteTriggerEventFilterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Action { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Action { val node = p.readValueAsTree() val executable = JSON_SERDE.convertValue(node["executable"], Executable::class.java) val repeats = JSON_SERDE.convertValue(node["repeats"], Repeats::class.java) @@ -619,7 +698,10 @@ object ActionDeserializer : JsonDeserializer() { * Deserializer for [Executable] */ object ExecutableDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Executable { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Executable { val node = p.readValueAsTree().fields().next() val paramClass = node.key.toArg() @@ -628,38 +710,40 @@ object ExecutableDeserializer : JsonDeserializer() { return getExecutable(value) } - private fun String.toArg(): Class<*> { - return when (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) { + 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") } - } } /** * 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()) { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Repeats = + when (val node = p.readValueAsTree()) { is TextNode -> Repeats.Indefinitely() is ObjectNode -> { val field = node.fields().next() @@ -668,20 +752,22 @@ object RepeatsDeserializer : JsonDeserializer() { else -> throw DeserializationException("Unknown type: $this") } - } } /** * Deserializer for [Parameter] */ object ParameterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Parameter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Parameter { val node = p.readValueAsTree().fields().next() return get(JSON_SERDE.convertValue(node.value, node.key.toArg()), node.key) } - private fun String.toArg(): Class<*> { - return when (this) { + private fun String.toArg(): Class<*> = + when (this) { "Sumeragi" -> SumeragiParameter::class.java "Block" -> BlockParameter::class.java "Transaction" -> TransactionParameter::class.java @@ -690,10 +776,12 @@ object ParameterDeserializer : JsonDeserializer() { "Custom" -> CustomParameter::class.java else -> throw DeserializationException("Unknown type: $this") } - } - private fun get(arg: Any, type: String): Parameter { - return when (type) { + 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) @@ -702,33 +790,40 @@ object ParameterDeserializer : JsonDeserializer() { "CustomParameter" -> Parameter.Custom(arg as CustomParameter) else -> throw DeserializationException("Unknown type: $this") } - } } /** * Deserializer for [SumeragiParameter] */ object SumeragiParameterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): SumeragiParameter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): SumeragiParameter { val node = p.readValueAsTree().fields().next() val arg = JSON_SERDE.convertValue(node.value, BigInteger::class.java) return get(arg, node.key) } - private fun get(arg: BigInteger, type: String): SumeragiParameter { - return when (type) { + private fun get( + arg: BigInteger, + type: String, + ): SumeragiParameter = + when (type) { "BlockTimeMs" -> SumeragiParameter.BlockTimeMs(arg) "CommitTimeMs" -> SumeragiParameter.CommitTimeMs(arg) else -> throw DeserializationException("Unknown type: $this") } - } } /** * Deserializer for [BlockParameter] */ object BlockParameterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): BlockParameter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): BlockParameter { val node = p.readValueAsTree().fields().next() val arg = JSON_SERDE.convertValue(node.value, BigInteger::class.java) return BlockParameter.MaxTransactions(NonZeroOfu64(arg)) @@ -739,45 +834,58 @@ object BlockParameterDeserializer : JsonDeserializer() { * Deserializer for [TransactionParameter] */ object TransactionParameterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): TransactionParameter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): TransactionParameter { val node = p.readValueAsTree().fields().next() val arg = JSON_SERDE.convertValue(node.value, BigInteger::class.java) return get(arg, node.key) } - private fun get(arg: BigInteger, type: String): TransactionParameter { - return when (type) { + 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") } - } } /** * Deserializer for [SmartContractParameter] */ object SmartContractParameterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): SmartContractParameter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): SmartContractParameter { val node = p.readValueAsTree().fields().next() val arg = JSON_SERDE.convertValue(node.value, BigInteger::class.java) return get(arg, node.key) } - private fun get(arg: BigInteger, type: String): SmartContractParameter { - return when (type) { + 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") } - } } /** * Deserializer for [Schedule] */ object ScheduleDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Schedule { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): Schedule { val node = p.readValueAsTree() return Schedule( startMs = JSON_SERDE.convertValue(node["start_ms"], BigInteger::class.java), @@ -790,20 +898,25 @@ object ScheduleDeserializer : JsonDeserializer() { * Deserializer for [ExecutionTime] */ object ExecutionTimeDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): ExecutionTime { - return when (val node = p.readValueAsTree()) { + 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") } - } } /** * Deserializer for [TimeEventFilter] */ object TimeEventFilterDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): TimeEventFilter { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): TimeEventFilter { val node = p.readValueAsTree().fields().next() return TimeEventFilter(JSON_SERDE.convertValue(node.value, ExecutionTime::class.java)) } @@ -813,7 +926,10 @@ object TimeEventFilterDeserializer : JsonDeserializer() { * Deserializer for [PublicKey] */ object PublicKeyDeserializer : JsonDeserializer() { - override fun deserialize(p: JsonParser, ctxt: DeserializationContext): PublicKey { + override fun deserialize( + p: JsonParser, + ctxt: DeserializationContext, + ): PublicKey { val key = p.readValueAs(String::class.java) return PublicKey(Algorithm.Ed25519(), key.substring(6, key.length).fromHex()) } @@ -823,123 +939,136 @@ 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)) { + 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") } - } } /** * 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 +1076,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 +1089,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 +1102,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 +1115,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 +1128,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 +1151,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 +1164,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 +1177,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 +1204,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 +1216,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 +1233,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 +1246,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 +1259,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 +1272,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 +1285,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 +1298,80 @@ 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 +1380,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 +1395,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 +1411,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 +1424,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 +1437,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 +1454,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 +1467,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,46 +1480,58 @@ 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) is Parameter.Custom -> gen.writeObjectField(Parameter.Custom::class.simpleName, value.customParameter) is Parameter.Executor -> gen.writeObjectField(Parameter.Executor::class.simpleName, value.smartContractParameter) - is Parameter.SmartContract -> gen.writeObjectField( - Parameter.SmartContract::class.simpleName, - value.smartContractParameter, - ) + is Parameter.SmartContract -> + gen.writeObjectField( + Parameter.SmartContract::class.simpleName, + value.smartContractParameter, + ) 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 +1541,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) @@ -1312,7 +1578,11 @@ private inline fun InstructionBox.serializeBox(gen: JsonGenerator) { 1 -> { gen.writeStartObject() gen.writeObjectFieldStart(clazz.simpleName) - memberProperties.first().call(this)?.cast()?.serializeBox(gen) + memberProperties + .first() + .call(this) + ?.cast() + ?.serializeBox(gen) gen.writeEndObject() gen.writeEndObject() } @@ -1321,17 +1591,16 @@ private inline fun InstructionBox.serializeBox(gen: JsonGenerator) { } } -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) - TransferBox::class -> this?.cast()?.serializeBox(gen) - SetKeyValueBox::class -> this?.cast()?.serializeBox(gen) - RegisterBox::class -> this?.cast()?.serializeBox(gen) - else -> throw IrohaSdkException("Unexpected type ${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) + TransferBox::class -> this?.cast()?.serializeBox(gen) + SetKeyValueBox::class -> this?.cast()?.serializeBox(gen) + RegisterBox::class -> this?.cast()?.serializeBox(gen) + else -> throw IrohaSdkException("Unexpected type ${B::class}") + } private fun BurnBox.serializeBox(gen: JsonGenerator) = serializeBox(this, gen) @@ -1345,7 +1614,10 @@ private fun RegisterBox.serializeBox(gen: JsonGenerator) = serializeBox(this, ge private fun SetKeyValueBox.serializeBox(gen: JsonGenerator) = serializeBox(this, gen) -private fun serializeBox(obj: Any, gen: JsonGenerator) { +private fun serializeBox( + obj: Any, + gen: JsonGenerator, +) { val memberProperties = obj::class.memberProperties when (memberProperties.size) { 0 -> gen.writeString(obj::class.simpleName) @@ -1358,7 +1630,10 @@ private fun serializeBox(obj: Any, gen: JsonGenerator) { /** * Serialise a single member object or nothing at all */ -private fun serializeSingleMember(gen: JsonGenerator, value: Any) { +private fun serializeSingleMember( + gen: JsonGenerator, + value: Any, +) { val clazz = value::class val memberProperties = clazz.memberProperties when (memberProperties.size) { @@ -1386,79 +1661,43 @@ private inline fun T.serializeEnum(gen: JsonGenerator) { } } -private fun String.asClass() = runCatching { - Class.forName(this) -}.getOrNull() ?: run { - when (this) { - "kotlin.Long" -> Long::class.java - "kotlin.Int" -> Int::class.java - else -> null - } -} ?: 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 { +private fun String.asClass() = + runCatching { + Class.forName(this) + }.getOrNull() ?: run { + when (this) { + "kotlin.Long" -> Long::class.java + "kotlin.Int" -> Int::class.java + else -> null + } + } ?: throw DeserializationException("Class $this not found") + +private fun sealedDeserializeIdBox( + p: JsonParser, + mapper: ObjectMapper, +): IdBox { val node = p.readValueAsTree().fields().next() val param = node.key - val subtype = IdBox::class.nestedClasses.find { clazz -> - !clazz.isCompanion && clazz.simpleName == param - } ?: throw DeserializationException("Class with constructor($param) not found") + val subtype = + IdBox::class.nestedClasses.find { clazz -> + !clazz.isCompanion && clazz.simpleName == param + } ?: throw DeserializationException("Class with constructor($param) not found") - val argTypeName = subtype.primaryConstructor?.parameters - ?.firstOrNull()?.type?.toString() - ?: throw DeserializationException("Subtype parameter not found by $param") + val argTypeName = + subtype.primaryConstructor + ?.parameters + ?.firstOrNull() + ?.type + ?.toString() + ?: throw DeserializationException("Subtype parameter not found by $param") val arg = mapper.convertValue(node.value, argTypeName.asClass()) return subtype.primaryConstructor?.call(arg) as IdBox } -private fun getTriggerId(triggerName: String): TriggerId { - return when (triggerName.contains("$")) { +private fun getTriggerId(triggerName: String): TriggerId = + 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") - } -} 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..896fd96f9 --- /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 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..e5079cd97 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,8 @@ const val U32_MAX_VALUE = (1L shl 32) - 1 /** * Wrap an [exception][ex] in `ScaleCodecException` */ -fun wrapException(ex: Exception): Exception { - return when (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..d733ff83b 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 @@ -5,25 +5,28 @@ 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()); +enum class CompactMode( + val value: Byte, +) { + 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) { + 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..645cc678f 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 @@ -5,7 +5,9 @@ import java.math.BigInteger /** * The largest values for Integer types */ -enum class IntMax(val max: BigInteger) { +enum class IntMax( + val max: BigInteger, +) { U64(BigInteger.valueOf(2).pow(64) - BigInteger.ONE), U128(BigInteger.valueOf(2).pow(128) - BigInteger.ONE), U256(BigInteger.valueOf(2).pow(256) - BigInteger.ONE), @@ -14,40 +16,39 @@ enum class IntMax(val max: BigInteger) { ; companion object { - fun uintMaxValue(bit: Int): BigInteger { - return when (bit) { + 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) { + fun intMaxValue(bit: Int): BigInteger = + when (bit) { 128 -> I128 256 -> I256 else -> throw IllegalArgumentException("Unsupported type $bit") }.max - } } } /** * The smallest values for signed Integer types */ -enum class IntMin(val min: BigInteger) { +enum class IntMin( + val min: BigInteger, +) { I128(-BigInteger.valueOf(2).pow(127)), I256(-BigInteger.valueOf(2).pow(255)), ; companion object { - fun intMinValue(bit: Int): BigInteger { - return when (bit) { + 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..a5c91a857 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 @@ -19,15 +19,15 @@ import kotlin.math.abs /** * SCALE codec reader */ -class ScaleCodecReader(private val source: ByteArray) { +class ScaleCodecReader( + private val source: ByteArray, +) { private var pos = 0 /** * @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 +78,95 @@ 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? + 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 @@ -205,7 +189,10 @@ class ScaleCodecReader(private val source: ByteArray) { /** * Read a set */ - fun readSet(size: Int, supplier: () -> T): MutableSet { + fun readSet( + size: Int, + supplier: () -> T, + ): MutableSet { val set = HashSet(capacity(size)) for (index in 0 until size) { set.add(supplier()) @@ -216,7 +203,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,34 +218,33 @@ 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 { + 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 { val UBYTE = UByteReader() 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..4f13e4173 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 @@ -20,8 +20,9 @@ import java.math.BigInteger /** * SCALE codec writer */ -class ScaleCodecWriter(private val out: OutputStream) : Closeable { - +class ScaleCodecWriter( + private val out: OutputStream, +) : Closeable { fun writeByteArray(value: ByteArray) { out.write(value, 0, value.size) } @@ -58,7 +59,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) } @@ -70,7 +75,10 @@ class ScaleCodecWriter(private val out: OutputStream) : Closeable { out.close() } - fun write(writer: ScaleWriter, value: T) { + fun write( + writer: ScaleWriter, + value: T, + ) { writer.write(this, value) } @@ -84,16 +92,20 @@ class ScaleCodecWriter(private val out: OutputStream) : Closeable { } } - fun writeNullable(writer: ScaleWriter, value: T?) { + fun writeNullable( + writer: ScaleWriter, + value: T?, + ) { when (writer) { is BoolWriter, is BoolNullableWriter -> BOOL_NULLABLE.write(this, value as Boolean?) - else -> when (value) { - null -> BOOL.write(this, false) - else -> { - BOOL.write(this, true) - writer.write(this, value) + else -> + when (value) { + null -> BOOL.write(this, false) + else -> { + BOOL.write(this, true) + writer.write(this, value) + } } - } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleWriter.kt index 65dafbf8b..99dd3b585 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/ScaleWriter.kt @@ -8,14 +8,16 @@ import java.io.ByteArrayOutputStream * @param type */ interface ScaleWriter { - /** * Write SCALE value to the specified writer. * * @param writer writer with the data * @param instance the data to write */ - fun write(writer: ScaleCodecWriter, instance: T) + fun write( + writer: ScaleCodecWriter, + instance: T, + ) /** * Encode provided data as a SCALE value 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..0a261a720 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 @@ -5,9 +5,13 @@ import java.util.Objects /** * `UnionValue` type is [enumeration][index] with assigned [value] */ -class UnionValue(index: Int, value: T) { +class UnionValue( + index: Int, + value: T, +) { val index: Int val value: T + override fun equals(o: Any?): Boolean { if (this === o) return true if (o !is UnionValue<*>) return false @@ -17,20 +21,15 @@ 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{" + + 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..cd738db5c 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,25 +7,23 @@ 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()) { + override fun read(reader: ScaleCodecReader): Boolean = + when (val b = reader.readByte().toInt()) { 0 -> false 1 -> true else -> throw IllegalStateException("Not a boolean option: $b") } - } } /** * 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()) { + 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/EnumReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/EnumReader.kt index 9c519bdc6..bd8441a6d 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/EnumReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/EnumReader.kt @@ -13,8 +13,11 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader * @param type of Enum * @see UnionReader */ -class EnumReader?>(values: Array) : ScaleReader { +class EnumReader?>( + values: Array, +) : ScaleReader { private val values: Array + override fun read(reader: ScaleCodecReader): T { val id = reader.readUByte() for (t in values) { 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..9fadf6365 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 @@ -39,7 +39,9 @@ class Int64Reader : ScaleReader { /** * SCALE codec reader for Java Big Integers encoded as integer SCALE values. */ -class IntReader(private val bit: Int) : ScaleReader { +class IntReader( + private val bit: Int, +) : ScaleReader { override fun read(reader: ScaleCodecReader): BigInteger { val capacity = bit / 8 val buf = ByteBuffer.allocate(capacity).order(ByteOrder.LITTLE_ENDIAN) @@ -48,7 +50,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/ListReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/ListReader.kt index 87e8f9274..b079f4a6c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/ListReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/ListReader.kt @@ -6,7 +6,9 @@ import jp.co.soramitsu.iroha2.codec.ScaleReader /** * SCALE codec reader for a list of values encoded as type */ -class ListReader(private val scaleReader: ScaleReader) : ScaleReader> { +class ListReader( + private val scaleReader: ScaleReader, +) : ScaleReader> { override fun read(reader: ScaleCodecReader): List { val size = reader.readCompactInt() val result: MutableList = ArrayList(size) 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/UIntReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UIntReader.kt index 32952a578..a688557f0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UIntReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UIntReader.kt @@ -8,7 +8,9 @@ import java.math.BigInteger /** * SCALE codec reader for Java Big Integers encoded as unsigned SCALE values. */ -class UIntReader(private val bit: Int) : ScaleReader { +class UIntReader( + private val bit: Int, +) : ScaleReader { override fun read(reader: ScaleCodecReader): BigInteger { var result = BigInteger.ZERO result = result.add(BigInteger.valueOf(reader.readUByte().toLong())) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnionReader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnionReader.kt index a422591e4..42a863c2b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnionReader.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/reader/UnionReader.kt @@ -7,8 +7,9 @@ import jp.co.soramitsu.iroha2.codec.UnionValue /** * SCALE reader for [UnionValue] */ -class UnionReader(private val mapping: List>) : ScaleReader> { - +class UnionReader( + private val mapping: List>, +) : ScaleReader> { constructor(vararg mapping: ScaleReader) : this(listOf>(*mapping)) override fun read(reader: ScaleCodecReader): UnionValue { 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..0373db2e4 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,10 @@ 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/codec/writer/BoolWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/BoolWriter.kt index 4c3909f2e..58964d96c 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/BoolWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/BoolWriter.kt @@ -7,7 +7,10 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter * SCALE codec writer for Boolean values */ class BoolWriter : ScaleWriter { - override fun write(wrt: ScaleCodecWriter, value: Boolean) { + override fun write( + wrt: ScaleCodecWriter, + value: Boolean, + ) { when (value) { false -> wrt.directWrite(0) true -> wrt.directWrite(1) @@ -19,7 +22,10 @@ class BoolWriter : ScaleWriter { * SCALE codec writer for Nullable Boolean values */ class BoolNullableWriter : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: Boolean?) { + override fun write( + writer: ScaleCodecWriter, + instance: Boolean?, + ) { when (instance) { null -> writer.directWrite(0) false -> writer.directWrite(1) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactBigIntWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactBigIntWriter.kt index ce4ea7740..348bc9950 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactBigIntWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactBigIntWriter.kt @@ -10,7 +10,10 @@ import java.math.BigInteger * [Compact mode][CompactMode] SCALE writer for Big Integers */ class CompactBigIntWriter : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: BigInteger) { + override fun write( + writer: ScaleCodecWriter, + instance: BigInteger, + ) { val mode = forNumber(instance) val data = instance.toByteArray() var length = data.size diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactUIntWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactUIntWriter.kt index e9f0f6240..cb5914ea7 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactUIntWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactUIntWriter.kt @@ -9,7 +9,10 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter * [Compact mode][CompactMode] SCALE writer for unsigned Integers */ class CompactUIntWriter : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: Int) { + override fun write( + writer: ScaleCodecWriter, + instance: Int, + ) { val mode = forNumber(instance) var compact: Int var bytes: Int @@ -19,11 +22,12 @@ class CompactUIntWriter : ScaleWriter { bytes = 4 } else { compact = (instance shl 2) + mode.value - bytes = when (mode) { - CompactMode.SINGLE -> 1 - CompactMode.TWO -> 2 - else -> 4 - } + bytes = + when (mode) { + CompactMode.SINGLE -> 1 + CompactMode.TWO -> 2 + else -> 4 + } } while (bytes > 0) { writer.directWrite(compact and 0xff) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactULongWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactULongWriter.kt index 404f21bc6..f2f04447b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactULongWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/CompactULongWriter.kt @@ -10,7 +10,10 @@ import java.math.BigInteger * [Compact mode][CompactMode] SCALE writer for unsigned Long Integers */ class CompactULongWriter : ScaleWriter { - override fun write(wrt: ScaleCodecWriter, value: Long) { + override fun write( + wrt: ScaleCodecWriter, + value: Long, + ) { val mode = forNumber(value) var compact: Long var bytes: Int @@ -19,11 +22,12 @@ class CompactULongWriter : ScaleWriter { return } else { compact = (value shl 2) + mode.value - bytes = when (mode) { - CompactMode.SINGLE -> 1 - CompactMode.TWO -> 2 - else -> 4 - } + bytes = + when (mode) { + CompactMode.SINGLE -> 1 + CompactMode.TWO -> 2 + else -> 4 + } } while (bytes > 0) { wrt.directWrite(compact.toInt() and 0xff) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/IntWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/IntWriter.kt index f05132539..cbb01a711 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/IntWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/IntWriter.kt @@ -10,7 +10,10 @@ import java.math.BigInteger * SCALE codec writer for Java Integers to encode them as 32-bit integer SCALE value. */ class Int32Writer : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: Int) { + override fun write( + writer: ScaleCodecWriter, + instance: Int, + ) { require(Int.MIN_VALUE <= instance) { "Value is too small for I32: $instance" } require(instance <= Int.MAX_VALUE) { "Value is too big for I32: $instance" } @@ -25,7 +28,10 @@ class Int32Writer : ScaleWriter { * SCALE codec writer for Java Long Integers to encode them as 64-bit integer SCALE value. */ class Int64Writer : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: Long) { + override fun write( + writer: ScaleCodecWriter, + instance: Long, + ) { require(Long.MIN_VALUE <= instance) { "Value is too small for I64: $instance" } require(instance <= Long.MAX_VALUE) { "Value is too big for I64: $instance" } @@ -43,8 +49,13 @@ class Int64Writer : ScaleWriter { /** * SCALE codec writer for Java Big Integers to encode them as integer SCALE value. */ -class IntWriter(private val bit: Int) : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: BigInteger) { +class IntWriter( + private val bit: Int, +) : ScaleWriter { + override fun write( + writer: ScaleCodecWriter, + instance: BigInteger, + ) { require(IntMin.intMinValue(bit) <= instance) { "Value is too small for I$bit: $instance" } require(instance <= IntMax.intMaxValue(bit)) { "Value is too big for I$bit: $instance" } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/ListWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/ListWriter.kt index adb1bd0cb..fce062c0b 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/ListWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/ListWriter.kt @@ -6,8 +6,13 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter /** * SCALE codec writer for a list of values to be encoded as type */ -class ListWriter(private val scaleWriter: ScaleWriter) : ScaleWriter> { - override fun write(writer: ScaleCodecWriter, instance: List) { +class ListWriter( + private val scaleWriter: ScaleWriter, +) : ScaleWriter> { + override fun write( + writer: ScaleCodecWriter, + instance: List, + ) { writer.writeCompact(instance.size) for (item in instance) { scaleWriter.write(writer, item) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UByteWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UByteWriter.kt index 642905478..872d31043 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UByteWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UByteWriter.kt @@ -7,7 +7,10 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter * SCALE codec writer for Java Short Integers to encode them as unsigned byte SCALE values */ class UByteWriter : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: Short) { + override fun write( + writer: ScaleCodecWriter, + instance: Short, + ) { require(!(instance < 0 || instance > 0xff)) { "Only values in range 0..255 are supported: $instance" } writer.directWrite(instance) } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UIntWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UIntWriter.kt index 412300506..7a643878a 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UIntWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UIntWriter.kt @@ -8,8 +8,13 @@ import java.math.BigInteger /** * SCALE codec writer for Java Big Integers to encode them as unsigned integer SCALE values */ -open class UIntWriter(private val bit: Int) : ScaleWriter { - override fun write(writer: ScaleCodecWriter, instance: BigInteger) { +open class UIntWriter( + private val bit: Int, +) : ScaleWriter { + override fun write( + writer: ScaleCodecWriter, + instance: BigInteger, + ) { require(instance >= BigInteger.ZERO) { "Negative values are not supported: $instance" } require(instance <= IntMax.uintMaxValue(bit)) { "Value is too big for U$bit: $instance" } @@ -24,7 +29,10 @@ open class UIntWriter(private val bit: Int) : ScaleWriter { * SCALE codec writer for Java Integers to encode them as unsigned 16-bit integer SCALE values */ class UInt16Writer : ScaleWriter { - override fun write(wrt: ScaleCodecWriter, value: Int) { + override fun write( + wrt: ScaleCodecWriter, + value: Int, + ) { require(value >= 0) { "Negative values are not supported: $value" } wrt.directWrite(value and 0xff) wrt.directWrite(value shr 8 and 0xff) @@ -35,7 +43,10 @@ class UInt16Writer : ScaleWriter { * SCALE codec writer for Kotlin Int to encode them as unsigned 32-bit integer SCALE values */ class UInt32Writer : ScaleWriter { - override fun write(wrt: ScaleCodecWriter, value: Int) { + override fun write( + wrt: ScaleCodecWriter, + value: Int, + ) { require(value >= 0) { "Negative values are not supported: $value" } wrt.directWrite(value and 0xff) wrt.directWrite(value shr 8 and 0xff) @@ -48,7 +59,10 @@ class UInt32Writer : ScaleWriter { * SCALE codec writer for Kotlin Long to encode them as unsigned 32-bit integer SCALE values */ class ULong32Writer : ScaleWriter { - override fun write(wrt: ScaleCodecWriter, value: Long) { + override fun write( + wrt: ScaleCodecWriter, + value: Long, + ) { require(value >= 0) { "Negative values are not supported: $value" } require(value <= 0xffffffffL) { "Value is too big for U32: $value" } wrt.directWrite(value and 0xff) diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UnionWriter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UnionWriter.kt index f33f9af50..75f21c010 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UnionWriter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/codec/writer/UnionWriter.kt @@ -7,13 +7,17 @@ import jp.co.soramitsu.iroha2.codec.UnionValue /** * SCALE codec writer for [UnionValue] */ -class UnionWriter(mapping: List>) : ScaleWriter> { - +class UnionWriter( + mapping: List>, +) : ScaleWriter> { private val mapping: MutableList> constructor(vararg mapping: ScaleWriter) : this(listOf>(*mapping)) - override fun write(writer: ScaleCodecWriter, instance: UnionValue) { + override fun write( + writer: ScaleCodecWriter, + instance: UnionValue, + ) { writer.directWrite(instance.index) val actual = instance.value mapping[instance.index].write(writer, actual) 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..f81d2a440 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 @@ -20,20 +20,25 @@ public data class Account( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Account = try { - Account( - AccountId.read(reader), - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Account = + try { + Account( + AccountId.read(reader), + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Account): Unit = try { - AccountId.write(writer, instance.id) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Account, + ): Unit = + try { + AccountId.write(writer, instance.id) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..326296321 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 @@ -36,22 +36,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Created = try { - Created( - Account.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Created = + try { + Created( + Account.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Account.write(writer, instance.account) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Deleted = try { - Deleted( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Deleted = + try { + Deleted( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountId.write(writer, instance.accountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Asset = try { - Asset( - AssetEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.Asset = + try { + Asset( + AssetEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetEvent.write(writer, instance.assetEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionAdded = try { - PermissionAdded( - AccountPermissionChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionAdded = + try { + PermissionAdded( + AccountPermissionChanged.read(reader), + ) + } 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) - } + ): Unit = + try { + AccountPermissionChanged.write(writer, instance.accountPermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionRemoved = try { - PermissionRemoved( - AccountPermissionChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.PermissionRemoved = + try { + PermissionRemoved( + AccountPermissionChanged.read(reader), + ) + } 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) - } + ): Unit = + try { + AccountPermissionChanged.write(writer, instance.accountPermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.RoleGranted = try { - RoleGranted( - AccountRoleChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.RoleGranted = + try { + RoleGranted( + AccountRoleChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountRoleChanged.write(writer, instance.accountRoleChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,22 +240,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.RoleRevoked = try { - RoleRevoked( - AccountRoleChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.RoleRevoked = + try { + RoleRevoked( + AccountRoleChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountRoleChanged.write(writer, instance.accountRoleChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -260,22 +274,24 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataInserted = try { - MetadataInserted( - MetadataChangedOfAccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataInserted = + try { + MetadataInserted( + MetadataChangedOfAccountId.read(reader), + ) + } 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) - } + ): Unit = + try { + MetadataChangedOfAccountId.write(writer, instance.metadataChangedOfAccountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -292,42 +308,46 @@ public sealed class AccountEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataRemoved = try { - MetadataRemoved( - MetadataChangedOfAccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AccountEvent.MetadataRemoved = + try { + MetadataRemoved( + MetadataChangedOfAccountId.read(reader), + ) + } 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) - } + ): 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) + 3 -> PermissionAdded.read(reader) + 4 -> PermissionRemoved.read(reader) + 5 -> RoleGranted.read(reader) + 6 -> RoleRevoked.read(reader) + 7 -> MetadataInserted.read(reader) + 8 -> MetadataRemoved.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: AccountEvent, ) { - 0 -> Created.read(reader) - 1 -> Deleted.read(reader) - 2 -> Asset.read(reader) - 3 -> PermissionAdded.read(reader) - 4 -> PermissionRemoved.read(reader) - 5 -> RoleGranted.read(reader) - 6 -> RoleRevoked.read(reader) - 7 -> MetadataInserted.read(reader) - 8 -> MetadataRemoved.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AccountEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) @@ -339,7 +359,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..f877c2ad2 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 @@ -21,20 +21,25 @@ public data class AccountEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountEventFilter = try { - AccountEventFilter( - reader.readNullable(AccountId) as AccountId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AccountEventFilter = + try { + AccountEventFilter( + reader.readNullable(AccountId) as AccountId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AccountEventFilter): Unit = try { - writer.writeNullable(AccountId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AccountEventFilter, + ): Unit = + try { + writer.writeNullable(AccountId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..ad1fbe289 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 @@ -20,20 +20,25 @@ public data class AccountId( public val signatory: PublicKey, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountId = try { - AccountId( - DomainId.read(reader), - PublicKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AccountId = + try { + AccountId( + DomainId.read(reader), + PublicKey.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AccountId): Unit = try { - DomainId.write(writer, instance.domain) - PublicKey.write(writer, instance.signatory) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AccountId, + ): Unit = + try { + DomainId.write(writer, instance.domain) + PublicKey.write(writer, instance.signatory) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..ae232e7e5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateAtom.kt @@ -0,0 +1,80 @@ +// +// 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/AccountIdPredicateBox.kt deleted file mode 100644 index 8c67a2eb7..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdPredicateBox.kt +++ /dev/null @@ -1,141 +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 - -/** - * AccountIdPredicateBox - * - * Generated from 'AccountIdPredicateBox' enum - */ -public sealed class AccountIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val accountId: AccountId, - ) : AccountIdPredicateBox() { - 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.AccountIdPredicateBox.Equals = try { - Equals( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Equals, - ): Unit = try { - AccountId.write(writer, instance.accountId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'DomainId' variant - */ - public data class DomainId( - public val domainIdPredicateBox: DomainIdPredicateBox, - ) : AccountIdPredicateBox() { - 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.AccountIdPredicateBox.DomainId = try { - DomainId( - DomainIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.DomainId, - ): Unit = try { - DomainIdPredicateBox.write(writer, instance.domainIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Signatory' variant - */ - public data class Signatory( - public val publicKeyPredicateBox: PublicKeyPredicateBox, - ) : AccountIdPredicateBox() { - 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.AccountIdPredicateBox.Signatory = try { - Signatory( - PublicKeyPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountIdPredicateBox.Signatory, - ): Unit = try { - PublicKeyPredicateBox.write(writer, instance.publicKeyPredicateBox) - } 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) - 2 -> Signatory.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AccountIdPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 1 -> DomainId.write(writer, instance as DomainId) - 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/AccountIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..6063f8c91 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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 + +/** + * AccountIdProjectionOfPredicateMarker + * + * Generated from 'AccountIdProjectionOfPredicateMarker' enum + */ +public sealed class AccountIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val accountIdPredicateAtom: AccountIdPredicateAtom, + ) : AccountIdProjectionOfPredicateMarker() { + 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.AccountIdProjectionOfPredicateMarker.Atom = + try { + Atom( + AccountIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Atom, + ): Unit = + try { + AccountIdPredicateAtom.write(writer, instance.accountIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Domain' variant + */ + public data class Domain( + public val domainIdProjectionOfPredicateMarker: DomainIdProjectionOfPredicateMarker, + ) : AccountIdProjectionOfPredicateMarker() { + 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.AccountIdProjectionOfPredicateMarker.Domain = + try { + Domain( + DomainIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Domain, + ): Unit = + try { + DomainIdProjectionOfPredicateMarker.write(writer, instance.domainIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Signatory' variant + */ + public data class Signatory( + public val publicKeyProjectionOfPredicateMarker: PublicKeyProjectionOfPredicateMarker, + ) : AccountIdProjectionOfPredicateMarker() { + 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.AccountIdProjectionOfPredicateMarker.Signatory = + try { + Signatory( + PublicKeyProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AccountIdProjectionOfPredicateMarker.Signatory, + ): Unit = + try { + PublicKeyProjectionOfPredicateMarker.write(writer, instance.publicKeyProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: AccountIdProjectionOfPredicateMarker, + ) { + 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/AccountIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..c4aba456e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountIdProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..72c5bfe71 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 @@ -22,20 +22,25 @@ public data class AccountPermissionChanged( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountPermissionChanged = try { - AccountPermissionChanged( - AccountId.read(reader), - Permission.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AccountPermissionChanged = + try { + AccountPermissionChanged( + AccountId.read(reader), + Permission.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AccountPermissionChanged): Unit = try { - AccountId.write(writer, instance.account) - Permission.write(writer, instance.permission) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AccountPermissionChanged, + ): Unit = + try { + AccountId.write(writer, instance.account) + Permission.write(writer, instance.permission) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt new file mode 100644 index 000000000..b2bfb038d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// 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 + +/** + * AccountPredicateAtom + * + * Generated from 'AccountPredicateAtom' enum + */ +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): AccountPredicateAtom = + when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + 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") + } + } + } +} 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/AccountPredicateBox.kt deleted file mode 100644 index 1636d2ec0..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountPredicateBox.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 - -/** - * AccountPredicateBox - * - * Generated from 'AccountPredicateBox' enum - */ -public sealed class AccountPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AccountPredicateBox() { - 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.AccountPredicateBox.Id = try { - Id( - AccountIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Id, - ): Unit = try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Metadata' variant - */ - public data class Metadata( - public val metadataPredicateBox: MetadataPredicateBox, - ) : AccountPredicateBox() { - 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.AccountPredicateBox.Metadata = try { - Metadata( - MetadataPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AccountPredicateBox.Metadata, - ): Unit = try { - MetadataPredicateBox.write(writer, instance.metadataPredicateBox) - } 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) - 1 -> Metadata.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AccountPredicateBox) { - 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/AccountProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..a999e7152 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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..aa23f41ca --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AccountProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..3e30f1c04 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 @@ -20,20 +20,25 @@ public data class AccountRoleChanged( public val role: RoleId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AccountRoleChanged = try { - AccountRoleChanged( - AccountId.read(reader), - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AccountRoleChanged = + try { + AccountRoleChanged( + AccountId.read(reader), + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AccountRoleChanged): Unit = try { - AccountId.write(writer, instance.account) - RoleId.write(writer, instance.role) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AccountRoleChanged, + ): Unit = + try { + AccountId.write(writer, instance.account) + RoleId.write(writer, instance.role) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Action.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Action.kt index e6422e1ee..bacae3339 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Action.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Action.kt @@ -23,26 +23,31 @@ public data class Action( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Action = try { - Action( - Executable.read(reader), - Repeats.read(reader), - AccountId.read(reader), - EventFilterBox.read(reader), - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Action = + try { + Action( + Executable.read(reader), + Repeats.read(reader), + AccountId.read(reader), + EventFilterBox.read(reader), + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Action): Unit = try { - Executable.write(writer, instance.executable) - Repeats.write(writer, instance.repeats) - AccountId.write(writer, instance.authority) - EventFilterBox.write(writer, instance.filter) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Action, + ): Unit = + try { + Executable.write(writer, instance.executable) + Repeats.write(writer, instance.repeats) + AccountId.write(writer, instance.authority) + EventFilterBox.write(writer, instance.filter) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..07d8c9b7b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import kotlin.Int + +/** + * ActionPredicateAtom + * + * Generated from 'ActionPredicateAtom' enum + */ +public sealed class ActionPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): ActionPredicateAtom = + when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: ActionPredicateAtom, + ) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..b8af8adc6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Int +import kotlin.Unit + +/** + * ActionProjectionOfPredicateMarker + * + * Generated from 'ActionProjectionOfPredicateMarker' enum + */ +public sealed class ActionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val actionPredicateAtom: ActionPredicateAtom, + ) : ActionProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom = + try { + Atom( + ActionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Atom, + ): Unit = + try { + ActionPredicateAtom.write(writer, instance.actionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata( + public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker, + ) : ActionProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 1 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata = + try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.ActionProjectionOfPredicateMarker.Metadata, + ): Unit = + try { + MetadataProjectionOfPredicateMarker.write(writer, instance.metadataProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): ActionProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + 1 -> Metadata.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: ActionProjectionOfPredicateMarker, + ) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + 1 -> Metadata.write(writer, instance as Metadata) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..3fcfb4ae4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/ActionProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..226f4678d 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 @@ -25,19 +25,23 @@ public sealed class Algorithm : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Ed25519 -> Ed25519.equals(this, other) - is Secp256k1 -> Secp256k1.equals(this, other) - is BlsNormal -> BlsNormal.equals(this, other) - is BlsSmall -> BlsSmall.equals(this, 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() } + override fun equals(other: Any?): Boolean = + when (this) { + is Ed25519 -> Ed25519.equals(this, other) + is Secp256k1 -> Secp256k1.equals(this, other) + is BlsNormal -> BlsNormal.equals(this, other) + is BlsSmall -> BlsSmall.equals(this, 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() + } /** * 'Ed25519' variant @@ -50,21 +54,26 @@ public sealed class Algorithm : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519 = try { - Ed25519() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519 = + try { + Ed25519() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519, - ): 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.Algorithm.Ed25519, o2: Any?): Boolean = + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Algorithm.Ed25519, + o2: Any?, + ): Boolean = when (o2) { null -> false else -> o2::class == o1::class @@ -85,24 +94,30 @@ public sealed class Algorithm : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1 = try { - Secp256k1() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1 = + try { + Secp256k1() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1, - ): 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.Algorithm.Secp256k1, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Algorithm.Secp256k1, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Algorithm.Secp256k1".hashCode() } @@ -119,24 +134,30 @@ public sealed class Algorithm : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal = try { - BlsNormal() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal = + try { + BlsNormal() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal, - ): 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.Algorithm.BlsNormal, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Algorithm.BlsNormal, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Algorithm.BlsNormal".hashCode() } @@ -153,48 +174,57 @@ public sealed class Algorithm : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall = try { - BlsSmall() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall = + try { + BlsSmall() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall, - ): 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.Algorithm.BlsSmall, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Algorithm.BlsSmall, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Algorithm.BlsSmall".hashCode() } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: Algorithm) { + override fun write( + writer: ScaleCodecWriter, + instance: Algorithm, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Ed25519.write(writer, instance as Ed25519) 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..4eab31370 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 @@ -20,20 +20,25 @@ public data class Asset( public val `value`: AssetValue, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Asset = try { - Asset( - AssetId.read(reader), - AssetValue.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Asset = + try { + Asset( + AssetId.read(reader), + AssetValue.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Asset): Unit = try { - AssetId.write(writer, instance.id) - AssetValue.write(writer, instance.`value`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Asset, + ): Unit = + try { + AssetId.write(writer, instance.id) + AssetValue.write(writer, instance.`value`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..8bf30fea1 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 @@ -20,20 +20,25 @@ public data class AssetChanged( public val amount: AssetValue, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetChanged = try { - AssetChanged( - AssetId.read(reader), - AssetValue.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetChanged = + try { + AssetChanged( + AssetId.read(reader), + AssetValue.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetChanged): Unit = try { - AssetId.write(writer, instance.asset) - AssetValue.write(writer, instance.amount) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetChanged, + ): Unit = + try { + AssetId.write(writer, instance.asset) + AssetValue.write(writer, instance.amount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..e8db5aa60 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,30 +22,38 @@ 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 { - AssetDefinition( - AssetDefinitionId.read(reader), - AssetType.read(reader), - Mintable.read(reader), - reader.readNullable(IpfsPath) as IpfsPath?, - Metadata.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetDefinition = + try { + AssetDefinition( + AssetDefinitionId.read(reader), + AssetType.read(reader), + Mintable.read(reader), + reader.readNullable(IpfsPath) as IpfsPath?, + Metadata.read(reader), + AccountId.read(reader), + Numeric.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.id) - AssetType.write(writer, instance.type) - Mintable.write(writer, instance.mintable) - writer.writeNullable(IpfsPath, instance.logo) - Metadata.write(writer, instance.metadata) - AccountId.write(writer, instance.ownedBy) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinition, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.id) + AssetType.write(writer, instance.type) + Mintable.write(writer, instance.mintable) + 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..7c1cf2c57 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 @@ -36,22 +36,24 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Created = try { - Created( - AssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Created = + try { + Created( + AssetDefinition.read(reader), + ) + } 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) - } + ): Unit = + try { + AssetDefinition.write(writer, instance.assetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Deleted = try { - Deleted( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.Deleted = + try { + Deleted( + AssetDefinitionId.read(reader), + ) + } 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) - } + ): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,23 +104,21 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataInserted = try { - MetadataInserted( - MetadataChangedOfAssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataInserted = + try { + MetadataInserted( + MetadataChangedOfAssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataInserted, ): Unit = try { - MetadataChangedOfAssetDefinitionId.write( - writer, - instance.metadataChangedOfAssetDefinitionId, - ) + MetadataChangedOfAssetDefinitionId.write(writer, instance.metadataChangedOfAssetDefinitionId) } catch (ex: Exception) { throw wrapException(ex) } @@ -136,23 +138,21 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataRemoved = try { - MetadataRemoved( - MetadataChangedOfAssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataRemoved = + try { + MetadataRemoved( + MetadataChangedOfAssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MetadataRemoved, ): Unit = try { - MetadataChangedOfAssetDefinitionId.write( - writer, - instance.metadataChangedOfAssetDefinitionId, - ) + MetadataChangedOfAssetDefinitionId.write(writer, instance.metadataChangedOfAssetDefinitionId) } catch (ex: Exception) { throw wrapException(ex) } @@ -172,22 +172,24 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MintabilityChanged = try { - MintabilityChanged( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MintabilityChanged = + try { + MintabilityChanged( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.MintabilityChanged, - ): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinitionId) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -204,25 +206,24 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.TotalQuantityChanged = try { - TotalQuantityChanged( - AssetDefinitionTotalQuantityChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.TotalQuantityChanged = + try { + TotalQuantityChanged( + AssetDefinitionTotalQuantityChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.TotalQuantityChanged, - ): Unit = try { - AssetDefinitionTotalQuantityChanged.write( - writer, - instance.assetDefinitionTotalQuantityChanged, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + AssetDefinitionTotalQuantityChanged.write(writer, instance.assetDefinitionTotalQuantityChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -239,40 +240,44 @@ public sealed class AssetDefinitionEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.OwnerChanged = try { - OwnerChanged( - AssetDefinitionOwnerChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.OwnerChanged = + try { + OwnerChanged( + AssetDefinitionOwnerChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionEvent.OwnerChanged, - ): Unit = try { - AssetDefinitionOwnerChanged.write(writer, instance.assetDefinitionOwnerChanged) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + AssetDefinitionOwnerChanged.write(writer, instance.assetDefinitionOwnerChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> MetadataRemoved.read(reader) + 4 -> MintabilityChanged.read(reader) + 5 -> TotalQuantityChanged.read(reader) + 6 -> OwnerChanged.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinitionEvent, ) { - 0 -> Created.read(reader) - 1 -> Deleted.read(reader) - 2 -> MetadataInserted.read(reader) - 3 -> MetadataRemoved.read(reader) - 4 -> MintabilityChanged.read(reader) - 5 -> TotalQuantityChanged.read(reader) - 6 -> OwnerChanged.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) @@ -282,7 +287,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..5599791fb 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 @@ -23,20 +23,25 @@ public data class AssetDefinitionEventFilter( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionEventFilter = try { - AssetDefinitionEventFilter( - reader.readNullable(AssetDefinitionId) as AssetDefinitionId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetDefinitionEventFilter = + try { + AssetDefinitionEventFilter( + reader.readNullable(AssetDefinitionId) as AssetDefinitionId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionEventFilter): Unit = try { - writer.writeNullable(AssetDefinitionId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinitionEventFilter, + ): Unit = + try { + writer.writeNullable(AssetDefinitionId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f09e184f4 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 @@ -20,20 +20,25 @@ public data class AssetDefinitionId( public val name: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionId = try { - AssetDefinitionId( - DomainId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetDefinitionId = + try { + AssetDefinitionId( + DomainId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionId): Unit = try { - DomainId.write(writer, instance.domain) - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinitionId, + ): Unit = + try { + DomainId.write(writer, instance.domain) + Name.write(writer, instance.name) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..98a3401fd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdPredicateAtom.kt @@ -0,0 +1,80 @@ +// +// 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..19b63f744 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfPredicateMarker.kt @@ -0,0 +1,158 @@ +// +// 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..6413c9203 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionIdProjectionOfSelectorMarker.kt @@ -0,0 +1,174 @@ +// +// 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..8fb0e7a74 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 @@ -22,20 +22,25 @@ public data class AssetDefinitionOwnerChanged( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionOwnerChanged = try { - AssetDefinitionOwnerChanged( - AssetDefinitionId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetDefinitionOwnerChanged = + try { + AssetDefinitionOwnerChanged( + AssetDefinitionId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionOwnerChanged): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - AccountId.write(writer, instance.newOwner) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinitionOwnerChanged, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinition) + AccountId.write(writer, instance.newOwner) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..fa45ba581 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateAtom.kt @@ -0,0 +1,42 @@ +// +// 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/AssetDefinitionPredicateBox.kt deleted file mode 100644 index b020e0d45..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionPredicateBox.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 - -/** - * AssetDefinitionPredicateBox - * - * Generated from 'AssetDefinitionPredicateBox' enum - */ -public sealed class AssetDefinitionPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val assetDefinitionIdPredicateBox: AssetDefinitionIdPredicateBox, - ) : AssetDefinitionPredicateBox() { - 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.AssetDefinitionPredicateBox.Id = try { - Id( - AssetDefinitionIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionPredicateBox.Id, - ): Unit = try { - AssetDefinitionIdPredicateBox.write(writer, instance.assetDefinitionIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Metadata' variant - */ - public data class Metadata( - public val metadataPredicateBox: MetadataPredicateBox, - ) : AssetDefinitionPredicateBox() { - 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.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 = - try { - MetadataPredicateBox.write(writer, instance.metadataPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'OwnedBy' variant - */ - public data class OwnedBy( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AssetDefinitionPredicateBox() { - 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.AssetDefinitionPredicateBox.OwnedBy = try { - OwnedBy( - AccountIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - 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) - } - } - } - - 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) { - 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") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..456c4119c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfPredicateMarker.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.Int +import kotlin.Unit + +/** + * AssetDefinitionProjectionOfPredicateMarker + * + * Generated from 'AssetDefinitionProjectionOfPredicateMarker' enum + */ +public sealed class AssetDefinitionProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val assetDefinitionPredicateAtom: AssetDefinitionPredicateAtom, + ) : AssetDefinitionProjectionOfPredicateMarker() { + 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.AssetDefinitionProjectionOfPredicateMarker.Atom = + try { + Atom( + AssetDefinitionPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetDefinitionProjectionOfPredicateMarker.Atom, + ): Unit = + try { + AssetDefinitionPredicateAtom.write(writer, instance.assetDefinitionPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Id' variant + */ + public data class Id( + public val assetDefinitionIdProjectionOfPredicateMarker: AssetDefinitionIdProjectionOfPredicateMarker, + ) : AssetDefinitionProjectionOfPredicateMarker() { + 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.AssetDefinitionProjectionOfPredicateMarker.Id = + try { + 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) + } + } + } + + /** + * 'Metadata' variant + */ + public data class Metadata( + public val metadataProjectionOfPredicateMarker: MetadataProjectionOfPredicateMarker, + ) : AssetDefinitionProjectionOfPredicateMarker() { + 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.AssetDefinitionProjectionOfPredicateMarker.Metadata = + try { + Metadata( + MetadataProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + 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): 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 -> 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..3707ec447 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetDefinitionProjectionOfSelectorMarker.kt @@ -0,0 +1,174 @@ +// +// 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..dc9e0f8ae 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 @@ -22,20 +22,25 @@ public data class AssetDefinitionTotalQuantityChanged( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetDefinitionTotalQuantityChanged = try { - AssetDefinitionTotalQuantityChanged( - AssetDefinitionId.read(reader), - Numeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetDefinitionTotalQuantityChanged = + try { + AssetDefinitionTotalQuantityChanged( + AssetDefinitionId.read(reader), + Numeric.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetDefinitionTotalQuantityChanged): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - Numeric.write(writer, instance.totalAmount) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetDefinitionTotalQuantityChanged, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinition) + Numeric.write(writer, instance.totalAmount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f7b268aa6 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 @@ -36,22 +36,24 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Created = try { - Created( - Asset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Created = + try { + Created( + Asset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Asset.write(writer, instance.asset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Deleted = try { - Deleted( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Deleted = + try { + Deleted( + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetId.write(writer, instance.assetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Added = try { - Added( - AssetChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Added = + try { + Added( + AssetChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetChanged.write(writer, instance.assetChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Removed = try { - Removed( - AssetChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.Removed = + try { + Removed( + AssetChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetChanged.write(writer, instance.assetChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataInserted = try { - MetadataInserted( - MetadataChangedOfAssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataInserted = + try { + MetadataInserted( + MetadataChangedOfAssetId.read(reader), + ) + } 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) - } + ): Unit = + try { + MetadataChangedOfAssetId.write(writer, instance.metadataChangedOfAssetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,39 +206,43 @@ public sealed class AssetEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataRemoved = try { - MetadataRemoved( - MetadataChangedOfAssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetEvent.MetadataRemoved = + try { + MetadataRemoved( + MetadataChangedOfAssetId.read(reader), + ) + } 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) - } + ): 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: AssetEvent, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: AssetEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) @@ -237,7 +251,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..a08e21437 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 @@ -21,20 +21,25 @@ public data class AssetEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetEventFilter = try { - AssetEventFilter( - reader.readNullable(AssetId) as AssetId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetEventFilter = + try { + AssetEventFilter( + reader.readNullable(AssetId) as AssetId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetEventFilter): Unit = try { - writer.writeNullable(AssetId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetEventFilter, + ): Unit = + try { + writer.writeNullable(AssetId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..81ea2f78a 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 @@ -20,20 +20,25 @@ public data class AssetId( public val definition: AssetDefinitionId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): AssetId = try { - AssetId( - AccountId.read(reader), - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): AssetId = + try { + AssetId( + AccountId.read(reader), + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: AssetId): Unit = try { - AccountId.write(writer, instance.account) - AssetDefinitionId.write(writer, instance.definition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: AssetId, + ): Unit = + try { + AccountId.write(writer, instance.account) + AssetDefinitionId.write(writer, instance.definition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..641add126 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateAtom.kt @@ -0,0 +1,78 @@ +// +// 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/AssetIdPredicateBox.kt deleted file mode 100644 index 0150bef74..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdPredicateBox.kt +++ /dev/null @@ -1,141 +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 - -/** - * AssetIdPredicateBox - * - * Generated from 'AssetIdPredicateBox' enum - */ -public sealed class AssetIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val assetId: AssetId, - ) : AssetIdPredicateBox() { - 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.AssetIdPredicateBox.Equals = try { - Equals( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.Equals, - ): Unit = try { - AssetId.write(writer, instance.assetId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'DefinitionId' variant - */ - public data class DefinitionId( - public val assetDefinitionIdPredicateBox: AssetDefinitionIdPredicateBox, - ) : AssetIdPredicateBox() { - 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.AssetIdPredicateBox.DefinitionId = try { - DefinitionId( - AssetDefinitionIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.DefinitionId, - ): Unit = try { - AssetDefinitionIdPredicateBox.write(writer, instance.assetDefinitionIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'AccountId' variant - */ - public data class AccountId( - public val accountIdPredicateBox: AccountIdPredicateBox, - ) : AssetIdPredicateBox() { - 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.AssetIdPredicateBox.AccountId = try { - AccountId( - AccountIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.AssetIdPredicateBox.AccountId, - ): Unit = try { - AccountIdPredicateBox.write(writer, instance.accountIdPredicateBox) - } 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) { - 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") } - } - } -} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..129acffcc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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 + +/** + * AssetIdProjectionOfPredicateMarker + * + * Generated from 'AssetIdProjectionOfPredicateMarker' enum + */ +public sealed class AssetIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val assetIdPredicateAtom: AssetIdPredicateAtom, + ) : AssetIdProjectionOfPredicateMarker() { + 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.AssetIdProjectionOfPredicateMarker.Atom = + try { + Atom( + AssetIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Atom, + ): Unit = + try { + AssetIdPredicateAtom.write(writer, instance.assetIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Account' variant + */ + public data class Account( + public val accountIdProjectionOfPredicateMarker: AccountIdProjectionOfPredicateMarker, + ) : AssetIdProjectionOfPredicateMarker() { + 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.AssetIdProjectionOfPredicateMarker.Account = + try { + Account( + AccountIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Account, + ): Unit = + try { + AccountIdProjectionOfPredicateMarker.write(writer, instance.accountIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Definition' variant + */ + public data class Definition( + public val assetDefinitionIdProjectionOfPredicateMarker: AssetDefinitionIdProjectionOfPredicateMarker, + ) : AssetIdProjectionOfPredicateMarker() { + 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.AssetIdProjectionOfPredicateMarker.Definition = + try { + Definition( + AssetDefinitionIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.AssetIdProjectionOfPredicateMarker.Definition, + ): Unit = + try { + AssetDefinitionIdProjectionOfPredicateMarker.write(writer, instance.assetDefinitionIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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 -> 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..58ac01bc7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetIdProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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/PeerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetPredicateAtom.kt similarity index 51% 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/AssetPredicateAtom.kt index e3e35d08d..6a8d23489 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/AssetPredicateAtom.kt @@ -11,27 +11,30 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * PeerPredicateBox + * AssetPredicateAtom * - * Generated from 'PeerPredicateBox' enum + * Generated from 'AssetPredicateAtom' enum */ -public sealed class PeerPredicateBox : ModelEnum { +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): 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): AssetPredicateAtom = + 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: AssetPredicateAtom, + ) { 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/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..977aab395 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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..98a5f26ef --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..2d84b0423 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 @@ -36,25 +36,24 @@ public sealed class AssetTransferBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetTransferBox.Numeric = try { - Numeric( - TransferOfAssetAndNumericAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetTransferBox.Numeric = + try { + Numeric( + TransferOfAssetAndNumericAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TransferOfAssetAndNumericAndAccount.write(writer, instance.transferOfAssetAndNumericAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -71,43 +70,45 @@ public sealed class AssetTransferBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetTransferBox.Store = try { - Store( - TransferOfAssetAndMetadataAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetTransferBox.Store = + try { + Store( + TransferOfAssetAndMetadataAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TransferOfAssetAndMetadataAndAccount.write(writer, instance.transferOfAssetAndMetadataAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: AssetTransferBox) { + 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..0b4fe0a3d 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 @@ -25,13 +25,17 @@ public sealed class AssetType : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Store -> Store.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is Store -> Store.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is Store -> Store.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is Store -> Store.hashCode() + else -> super.hashCode() + } /** * 'Numeric' variant @@ -46,22 +50,24 @@ public sealed class AssetType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetType.Numeric = try { - Numeric( - NumericSpec.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetType.Numeric = + try { + Numeric( + NumericSpec.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + NumericSpec.write(writer, instance.numericSpec) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -76,21 +82,26 @@ public sealed class AssetType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetType.Store = try { - Store() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetType.Store = + try { + Store() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.AssetType.Store, - ): 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.AssetType.Store, o2: Any?): Boolean = + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.AssetType.Store, + o2: Any?, + ): Boolean = when (o2) { null -> false else -> o2::class == o1::class @@ -101,20 +112,23 @@ public sealed class AssetType : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: AssetType) { + 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..5f9717245 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 @@ -36,22 +36,26 @@ public sealed class AssetValue : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValue.Numeric = try { - Numeric( - jp.co.soramitsu.iroha2.generated.Numeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValue.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.AssetValue.Numeric, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Numeric.write(writer, instance.numeric) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Numeric + .write(writer, instance.numeric) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +72,45 @@ public sealed class AssetValue : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValue.Store = try { - Store( - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.AssetValue.Store = + try { + Store( + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: AssetValue) { + 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..61572d9b2 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValuePredicateAtom.kt @@ -0,0 +1,144 @@ +// +// 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..4b5da63b6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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..f6c888dce --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/AssetValueProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..5201595b4 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 @@ -20,20 +20,25 @@ public data class BlockEvent( public val status: BlockStatus, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockEvent = try { - BlockEvent( - BlockHeader.read(reader), - BlockStatus.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockEvent = + try { + BlockEvent( + BlockHeader.read(reader), + BlockStatus.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockEvent): Unit = try { - BlockHeader.write(writer, instance.`header`) - BlockStatus.write(writer, instance.status) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockEvent, + ): Unit = + try { + BlockHeader.write(writer, instance.`header`) + BlockStatus.write(writer, instance.status) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..fee42f945 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 @@ -20,20 +20,25 @@ public data class BlockEventFilter( public val status: BlockStatus? = null, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockEventFilter = try { - BlockEventFilter( - reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, - reader.readNullable(BlockStatus) as BlockStatus?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockEventFilter = + try { + BlockEventFilter( + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + reader.readNullable(BlockStatus) as BlockStatus?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockEventFilter): Unit = try { - writer.writeNullable(NonZeroOfu64, instance.height) - writer.writeNullable(BlockStatus, instance.status) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockEventFilter, + ): Unit = + try { + writer.writeNullable(NonZeroOfu64, instance.height) + writer.writeNullable(BlockStatus, instance.status) + } 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/BlockHashPredicateBox.kt deleted file mode 100644 index a40986bcb..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHashPredicateBox.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 - -/** - * BlockHashPredicateBox - * - * Generated from 'BlockHashPredicateBox' enum - */ -public sealed class BlockHashPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val hashOf: HashOf, - ) : BlockHashPredicateBox() { - 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.BlockHashPredicateBox.Equals = try { - Equals( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockHashPredicateBox.Equals, - ): Unit = try { - HashOf.write(writer, instance.hashOf) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockHashPredicateBox = 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: BlockHashPredicateBox) { - 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/BlockHeader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeader.kt index 7393cf9c7..06af001eb 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,31 +24,33 @@ 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 { - BlockHeader( - NonZeroOfu64.read(reader), - reader.readNullable(HashOf) as HashOf?, - HashOf.read(reader) as HashOf>, - reader.readUint64(), - reader.readUint32(), - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockHeader = + try { + BlockHeader( + NonZeroOfu64.read(reader), + reader.readNullable(HashOf) as HashOf?, + HashOf.read(reader) as HashOf>, + reader.readUint64(), + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockHeader): Unit = try { - NonZeroOfu64.write(writer, instance.height) - writer.writeNullable(HashOf, instance.prevBlockHash) - HashOf.write(writer, instance.transactionsHash) - writer.writeUint64(instance.creationTimeMs) - writer.writeUint32(instance.viewChangeIndex) - writer.writeUint64(instance.consensusEstimationMs) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockHeader, + ): Unit = + try { + NonZeroOfu64.write(writer, instance.height) + writer.writeNullable(HashOf, instance.prevBlockHash) + HashOf.write(writer, instance.transactionsHash) + writer.writeUint64(instance.creationTimeMs) + writer.writeUint32(instance.viewChangeIndex) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt new file mode 100644 index 000000000..37b1b49de --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashPredicateAtom.kt @@ -0,0 +1,80 @@ +// +// 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 + +/** + * BlockHeaderHashPredicateAtom + * + * Generated from 'BlockHeaderHashPredicateAtom' enum + */ +public sealed class BlockHeaderHashPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals( + public val hashOf: HashOf, + ) : BlockHeaderHashPredicateAtom() { + 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.BlockHeaderHashPredicateAtom.Equals = + try { + Equals( + HashOf.read(reader) as HashOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderHashPredicateAtom.Equals, + ): Unit = + try { + HashOf.write(writer, instance.hashOf) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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") + } + + 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") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..a17bef4d3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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 + +/** + * BlockHeaderHashProjectionOfPredicateMarker + * + * Generated from 'BlockHeaderHashProjectionOfPredicateMarker' enum + */ +public sealed class BlockHeaderHashProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val blockHeaderHashPredicateAtom: BlockHeaderHashPredicateAtom, + ) : BlockHeaderHashProjectionOfPredicateMarker() { + 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.BlockHeaderHashProjectionOfPredicateMarker.Atom = + try { + Atom( + BlockHeaderHashPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.BlockHeaderHashProjectionOfPredicateMarker.Atom, + ): Unit = + try { + BlockHeaderHashPredicateAtom.write(writer, instance.blockHeaderHashPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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: BlockHeaderHashProjectionOfPredicateMarker, + ) { + 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/BlockHeaderHashProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..46b43742a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderHashProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..ed5419112 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateAtom.kt @@ -0,0 +1,42 @@ +// +// 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/BlockHeaderPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateBox.kt deleted file mode 100644 index 62559f878..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderPredicateBox.kt +++ /dev/null @@ -1,75 +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 - -/** - * BlockHeaderPredicateBox - * - * Generated from 'BlockHeaderPredicateBox' enum - */ -public sealed class BlockHeaderPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Hash' variant - */ - public data class Hash( - public val blockHashPredicateBox: BlockHashPredicateBox, - ) : BlockHeaderPredicateBox() { - 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.BlockHeaderPredicateBox.Hash = try { - Hash( - BlockHashPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.BlockHeaderPredicateBox.Hash, - ): Unit = try { - BlockHashPredicateBox.write(writer, instance.blockHashPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - 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") } - - override fun write(writer: ScaleCodecWriter, instance: BlockHeaderPredicateBox) { - 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") } - } - } -} 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..5394cfa26 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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..05d12dbca --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/BlockHeaderProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..545b15607 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 @@ -19,18 +19,23 @@ public data class BlockMessage( public val signedBlock: SignedBlock, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockMessage = try { - BlockMessage( - SignedBlock.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockMessage = + try { + BlockMessage( + SignedBlock.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockMessage): Unit = try { - SignedBlock.write(writer, instance.signedBlock) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockMessage, + ): Unit = + try { + SignedBlock.write(writer, instance.signedBlock) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..0805faf3a 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 @@ -36,38 +36,43 @@ public sealed class BlockParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockParameter.MaxTransactions = try { - MaxTransactions( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockParameter.MaxTransactions = + try { + MaxTransactions( + NonZeroOfu64.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> MaxTransactions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: BlockParameter) { + 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..f5236d649 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 @@ -19,18 +19,23 @@ public data class BlockParameters( public val maxTransactions: NonZeroOfu64, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockParameters = try { - BlockParameters( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockParameters = + try { + BlockParameters( + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockParameters): Unit = try { - NonZeroOfu64.write(writer, instance.maxTransactions) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockParameters, + ): Unit = + try { + NonZeroOfu64.write(writer, instance.maxTransactions) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..4f5f72761 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 @@ -18,32 +18,31 @@ import kotlin.collections.List */ public data class BlockPayload( public val `header`: BlockHeader, - public val transactions: List, - public val eventRecommendations: List, + 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) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: BlockPayload): Unit = try { - BlockHeader.write(writer, instance.`header`) - writer.writeCompact(instance.transactions.size) - instance.transactions.forEach { value -> - CommittedTransaction.write(writer, value) + override fun read(reader: ScaleCodecReader): BlockPayload = + try { + BlockPayload( + BlockHeader.read(reader), + reader.readVec(reader.readCompactInt()) { SignedTransaction.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) } - writer.writeCompact(instance.eventRecommendations.size) - instance.eventRecommendations.forEach { value -> - EventBox.write(writer, value) + + override fun write( + writer: ScaleCodecWriter, + instance: BlockPayload, + ): Unit = + try { + BlockHeader.write(writer, instance.`header`) + writer.writeCompact(instance.transactions.size) + instance.transactions.forEach { value -> + SignedTransaction.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } 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..dc06373bc 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 @@ -25,13 +25,17 @@ public sealed class BlockRejectionReason : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is ConsensusBlockRejection -> ConsensusBlockRejection.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is ConsensusBlockRejection -> ConsensusBlockRejection.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is ConsensusBlockRejection -> ConsensusBlockRejection.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is ConsensusBlockRejection -> ConsensusBlockRejection.hashCode() + else -> super.hashCode() + } /** * 'ConsensusBlockRejection' variant @@ -44,45 +48,51 @@ 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, instance: jp.co.soramitsu.iroha2.generated.BlockRejectionReason.ConsensusBlockRejection, - ): 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.BlockRejectionReason.ConsensusBlockRejection, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): 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() - ) { - 0 -> ConsensusBlockRejection.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: BlockRejectionReason) { + 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..ea084ae89 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 @@ -21,20 +21,25 @@ public data class BlockSignature( public val signatureOf: SignatureOf, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockSignature = try { - BlockSignature( - reader.readUint64(), - SignatureOf.read(reader) as SignatureOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockSignature = + try { + BlockSignature( + reader.readUint64(), + SignatureOf.read(reader) as SignatureOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockSignature): Unit = try { - writer.writeUint64(instance.u64) - SignatureOf.write(writer, instance.signatureOf) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockSignature, + ): Unit = + try { + writer.writeUint64(instance.u64) + SignatureOf.write(writer, instance.signatureOf) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..1094867b2 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 @@ -25,17 +25,63 @@ public sealed class BlockStatus : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Approved -> Approved.equals(this, other) - is Committed -> Committed.equals(this, other) - is Applied -> Applied.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is Approved -> Approved.hashCode() - is Committed -> Committed.hashCode() - is Applied -> Applied.hashCode() - else -> super.hashCode() } + 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) + } + + 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() + } + + /** + * '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,26 +92,32 @@ 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() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Approved = + try { + Approved() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Approved, - ): 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.BlockStatus.Approved, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.BlockStatus.Approved, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".BlockStatus.Approved".hashCode() } @@ -82,24 +134,26 @@ public sealed class BlockStatus : ModelEnum { 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( - BlockRejectionReason.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Rejected = + try { + Rejected( + BlockRejectionReason.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + BlockRejectionReason.write(writer, instance.blockRejectionReason) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -112,26 +166,32 @@ 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() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Committed = + try { + Committed() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Committed, - ): 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.BlockStatus.Committed, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.BlockStatus.Committed, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".BlockStatus.Committed".hashCode() } @@ -146,50 +206,61 @@ 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() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BlockStatus.Applied = + try { + Applied() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.BlockStatus.Applied, - ): 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.BlockStatus.Applied, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.BlockStatus.Applied, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".BlockStatus.Applied".hashCode() } } 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) { + 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..2e5f5a5da 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 @@ -21,18 +21,23 @@ public data class BlockSubscriptionRequest( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): BlockSubscriptionRequest = try { - BlockSubscriptionRequest( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BlockSubscriptionRequest = + try { + BlockSubscriptionRequest( + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BlockSubscriptionRequest): Unit = try { - NonZeroOfu64.write(writer, instance.nonZeroOfu64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BlockSubscriptionRequest, + ): Unit = + try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..14e0f8fa8 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 @@ -48,11 +48,12 @@ public sealed class BurnBox : ModelEnum { 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) - } + ): Unit = + try { + BurnOfNumericAndAsset.write(writer, instance.burnOfNumericAndAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,40 +70,45 @@ public sealed class BurnBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BurnBox.TriggerRepetitions = try { - TriggerRepetitions( - BurnOfu32AndTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.BurnBox.TriggerRepetitions = + try { + TriggerRepetitions( + BurnOfu32AndTrigger.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Asset.read(reader) - 1 -> TriggerRepetitions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: BurnBox) { + 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..ec236d4fc 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 @@ -18,22 +21,29 @@ import kotlin.Unit 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( - Numeric.read(reader), - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BurnOfNumericAndAsset = + try { + BurnOfNumericAndAsset( + Numeric.read(reader), + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BurnOfNumericAndAsset): Unit = try { - Numeric.write(writer, instance.`object`) - AssetId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BurnOfNumericAndAsset, + ): Unit = + try { + Numeric.write(writer, instance.`object`) + AssetId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..014609a64 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 @@ -19,22 +22,29 @@ import kotlin.Unit 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( - reader.readUint32(), - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): BurnOfu32AndTrigger = + try { + BurnOfu32AndTrigger( + reader.readUint32(), + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: BurnOfu32AndTrigger): Unit = try { - writer.writeUint32(instance.`object`) - TriggerId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: BurnOfu32AndTrigger, + ): Unit = + try { + writer.writeUint32(instance.`object`) + TriggerId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt new file mode 100644 index 000000000..8081aa0c4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnAsset.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanBurnAsset + * + * Generated from 'CanBurnAsset' regular structure + */ +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: 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..d1e41c2bf 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 @@ -17,22 +18,27 @@ import kotlin.Unit */ public data class CanBurnAssetWithDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanBurnAssetWithDefinition = try { - CanBurnAssetWithDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanBurnAssetWithDefinition = + try { + CanBurnAssetWithDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanBurnAssetWithDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CanBurnAssetWithDefinition, + ): 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/CanBurnUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserAsset.kt deleted file mode 100644 index c33542aea..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserAsset.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 - -/** - * CanBurnUserAsset - * - * Generated from 'CanBurnUserAsset' regular structure - */ -public data class CanBurnUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanBurnUserAsset = try { - CanBurnUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanBurnUserAsset): 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/CanBurnUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserTrigger.kt deleted file mode 100644 index 09d8e0339..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanBurnUserTrigger.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 - -/** - * CanBurnUserTrigger - * - * Generated from 'CanBurnUserTrigger' regular structure - */ -public data class CanBurnUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanBurnUserTrigger = try { - CanBurnUserTrigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanBurnUserTrigger): 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/CanExecuteTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteTrigger.kt new file mode 100644 index 000000000..2de73c2c1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteTrigger.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanExecuteTrigger + * + * Generated from 'CanExecuteTrigger' regular structure + */ +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: 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/CanExecuteUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteUserTrigger.kt deleted file mode 100644 index a5b5900ce..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanExecuteUserTrigger.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 - -/** - * CanExecuteUserTrigger - * - * Generated from 'CanExecuteUserTrigger' regular structure - */ -public data class CanExecuteUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanExecuteUserTrigger = try { - CanExecuteUserTrigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanExecuteUserTrigger): 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/CanManagePeers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManagePeers.kt new file mode 100644 index 000000000..0d74c89ee --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManagePeers.kt @@ -0,0 +1,51 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +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 + +/** + * CanManagePeers + * + * Generated from 'CanManagePeers' tuple structure + */ +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: CanManagePeers, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: CanManagePeers, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".CanManagePeers".hashCode() + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt new file mode 100644 index 000000000..bde3e37c9 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanManageRoles.kt @@ -0,0 +1,51 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +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 + +/** + * CanManageRoles + * + * Generated from 'CanManageRoles' tuple structure + */ +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: CanManageRoles, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: CanManageRoles, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".CanManageRoles".hashCode() + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt new file mode 100644 index 000000000..d7831ef44 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintAsset.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanMintAsset + * + * Generated from 'CanMintAsset' regular structure + */ +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: 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..972ae7bbb 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 @@ -17,22 +18,27 @@ import kotlin.Unit */ public data class CanMintAssetWithDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanMintAssetWithDefinition = try { - CanMintAssetWithDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanMintAssetWithDefinition = + try { + CanMintAssetWithDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanMintAssetWithDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CanMintAssetWithDefinition, + ): 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/CanMintUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserAsset.kt deleted file mode 100644 index 1f237f34c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserAsset.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 - -/** - * CanMintUserAsset - * - * Generated from 'CanMintUserAsset' regular structure - */ -public data class CanMintUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanMintUserAsset = try { - CanMintUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanMintUserAsset): 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/CanMintUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserTrigger.kt deleted file mode 100644 index 4f2f09288..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanMintUserTrigger.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 - -/** - * CanMintUserTrigger - * - * Generated from 'CanMintUserTrigger' regular structure - */ -public data class CanMintUserTrigger( - public val trigger: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanMintUserTrigger = try { - CanMintUserTrigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanMintUserTrigger): 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/CanModifyAccountMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAccountMetadata.kt new file mode 100644 index 000000000..a799a5bdd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAccountMetadata.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyAccountMetadata + * + * Generated from 'CanModifyAccountMetadata' regular structure + */ +public data class CanModifyAccountMetadata( + public val account: AccountId, +) : ModelPermission { + public companion object : + 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: 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/CanModifyAssetDefinitionMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetDefinitionMetadata.kt new file mode 100644 index 000000000..675fb029a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetDefinitionMetadata.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyAssetDefinitionMetadata + * + * Generated from 'CanModifyAssetDefinitionMetadata' regular structure + */ +public data class CanModifyAssetDefinitionMetadata( + public val assetDefinition: AssetDefinitionId, +) : ModelPermission { + public companion object : + 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: 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/CanModifyAssetMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetMetadata.kt new file mode 100644 index 000000000..a86c4fead --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyAssetMetadata.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyAssetMetadata + * + * Generated from 'CanModifyAssetMetadata' regular structure + */ +public data class CanModifyAssetMetadata( + public val asset: AssetId, +) : ModelPermission { + public companion object : + 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: 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/CanModifyDomainMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyDomainMetadata.kt new file mode 100644 index 000000000..a6135639c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyDomainMetadata.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyDomainMetadata + * + * Generated from 'CanModifyDomainMetadata' regular structure + */ +public data class CanModifyDomainMetadata( + public val domain: DomainId, +) : ModelPermission { + public companion object : + 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: 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/CanModifyTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTrigger.kt new file mode 100644 index 000000000..577cdc786 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTrigger.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyTrigger + * + * Generated from 'CanModifyTrigger' regular structure + */ +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: 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/CanModifyTriggerMetadata.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTriggerMetadata.kt new file mode 100644 index 000000000..5ef2d2fc5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanModifyTriggerMetadata.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanModifyTriggerMetadata + * + * Generated from 'CanModifyTriggerMetadata' regular structure + */ +public data class CanModifyTriggerMetadata( + public val trigger: TriggerId, +) : ModelPermission { + public companion object : + 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: 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/CanRegisterAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccount.kt new file mode 100644 index 000000000..28f1c0888 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccount.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanRegisterAccount + * + * Generated from 'CanRegisterAccount' regular structure + */ +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: 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/CanRegisterAccountInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccountInDomain.kt deleted file mode 100644 index dea60174e..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAccountInDomain.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 - -/** - * CanRegisterAccountInDomain - * - * Generated from 'CanRegisterAccountInDomain' regular structure - */ -public data class CanRegisterAccountInDomain( - public val domain: DomainId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterAccountInDomain = try { - CanRegisterAccountInDomain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAccountInDomain): 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/CanRegisterAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAsset.kt new file mode 100644 index 000000000..efba287bc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAsset.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanRegisterAsset + * + * Generated from 'CanRegisterAsset' regular structure + */ +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: 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/CanRegisterAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinition.kt new file mode 100644 index 000000000..faa4422de --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinition.kt @@ -0,0 +1,44 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanRegisterAssetDefinition + * + * Generated from 'CanRegisterAssetDefinition' regular structure + */ +public data class CanRegisterAssetDefinition( + public val domain: DomainId, +) : ModelPermission { + public companion object : + 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: 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/CanRegisterAssetDefinitionInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinitionInDomain.kt deleted file mode 100644 index 858dc873a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterAssetDefinitionInDomain.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 - -/** - * CanRegisterAssetDefinitionInDomain - * - * Generated from 'CanRegisterAssetDefinitionInDomain' regular structure - */ -public data class CanRegisterAssetDefinitionInDomain( - public val domain: DomainId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterAssetDefinitionInDomain = try { - CanRegisterAssetDefinitionInDomain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetDefinitionInDomain): 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..16128d1a0 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 @@ -17,19 +18,23 @@ import kotlin.Unit */ public data class CanRegisterAssetWithDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterAssetWithDefinition = try { - CanRegisterAssetWithDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanRegisterAssetWithDefinition = + try { + CanRegisterAssetWithDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanRegisterAssetWithDefinition): Unit = + override fun write( + writer: ScaleCodecWriter, + instance: CanRegisterAssetWithDefinition, + ): Unit = try { AssetDefinitionId.write(writer, instance.assetDefinition) } catch (ex: Exception) { diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt new file mode 100644 index 000000000..a6d339bc2 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterDomain.kt @@ -0,0 +1,51 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +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 + +/** + * CanRegisterDomain + * + * Generated from 'CanRegisterDomain' tuple structure + */ +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: CanRegisterDomain, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: CanRegisterDomain, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".CanRegisterDomain".hashCode() + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt new file mode 100644 index 000000000..d06b14e3b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterTrigger.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanRegisterTrigger + * + * Generated from 'CanRegisterTrigger' regular structure + */ +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: 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/CanRegisterUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterUserTrigger.kt deleted file mode 100644 index 415c2f987..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRegisterUserTrigger.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 - -/** - * CanRegisterUserTrigger - * - * Generated from 'CanRegisterUserTrigger' regular structure - */ -public data class CanRegisterUserTrigger( - public val account: AccountId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRegisterUserTrigger = try { - CanRegisterUserTrigger( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRegisterUserTrigger): 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/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/CanRemoveKeyValueInAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAssetDefinition.kt deleted file mode 100644 index da5718ba5..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInAssetDefinition.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 - -/** - * CanRemoveKeyValueInAssetDefinition - * - * Generated from 'CanRemoveKeyValueInAssetDefinition' regular structure - */ -public data class CanRemoveKeyValueInAssetDefinition( - public val assetDefinition: AssetDefinitionId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInAssetDefinition = try { - CanRemoveKeyValueInAssetDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInAssetDefinition): 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/CanRemoveKeyValueInDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInDomain.kt deleted file mode 100644 index ed241bfea..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInDomain.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 - -/** - * CanRemoveKeyValueInDomain - * - * Generated from 'CanRemoveKeyValueInDomain' regular structure - */ -public data class CanRemoveKeyValueInDomain( - public val domain: DomainId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInDomain = try { - CanRemoveKeyValueInDomain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInDomain): 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/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/CanRemoveKeyValueInUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInUserAsset.kt deleted file mode 100644 index 2a955e704..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanRemoveKeyValueInUserAsset.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 - -/** - * CanRemoveKeyValueInUserAsset - * - * Generated from 'CanRemoveKeyValueInUserAsset' regular structure - */ -public data class CanRemoveKeyValueInUserAsset( - public val asset: AssetId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanRemoveKeyValueInUserAsset = try { - CanRemoveKeyValueInUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanRemoveKeyValueInUserAsset): 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/CanSetKeyValueInAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAccount.kt deleted file mode 100644 index 024ef5a7b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInAccount.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 - -/** - * CanSetKeyValueInAccount - * - * Generated from 'CanSetKeyValueInAccount' regular structure - */ -public data class CanSetKeyValueInAccount( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInAccount = try { - CanSetKeyValueInAccount( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInAccount): 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/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/CanSetKeyValueInTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInTrigger.kt deleted file mode 100644 index 844a06c7f..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetKeyValueInTrigger.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 - -/** - * CanSetKeyValueInTrigger - * - * Generated from 'CanSetKeyValueInTrigger' regular structure - */ -public data class CanSetKeyValueInTrigger( - public val trigger: TriggerId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanSetKeyValueInTrigger = try { - CanSetKeyValueInTrigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanSetKeyValueInTrigger): 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/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/CanSetParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetParameters.kt new file mode 100644 index 000000000..41088c63d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanSetParameters.kt @@ -0,0 +1,51 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +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 + +/** + * CanSetParameters + * + * Generated from 'CanSetParameters' tuple structure + */ +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: CanSetParameters, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: CanSetParameters, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".CanSetParameters".hashCode() + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt new file mode 100644 index 000000000..c4265e2e5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferAsset.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanTransferAsset + * + * Generated from 'CanTransferAsset' regular structure + */ +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: 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..bacb394ad 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 @@ -17,19 +18,23 @@ import kotlin.Unit */ public data class CanTransferAssetWithDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanTransferAssetWithDefinition = try { - CanTransferAssetWithDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanTransferAssetWithDefinition = + try { + CanTransferAssetWithDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanTransferAssetWithDefinition): Unit = + override fun write( + writer: ScaleCodecWriter, + instance: CanTransferAssetWithDefinition, + ): Unit = try { AssetDefinitionId.write(writer, instance.assetDefinition) } catch (ex: Exception) { 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/CanTransferUserAsset.kt deleted file mode 100644 index 2c4322986..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanTransferUserAsset.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 - -/** - * CanTransferUserAsset - * - * Generated from 'CanTransferUserAsset' regular structure - */ -public data class CanTransferUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanTransferUserAsset = try { - CanTransferUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanTransferUserAsset): 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/CanUnregisterAccount.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAccount.kt index dae14c76d..4a88da43a 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 @@ -17,20 +18,25 @@ import kotlin.Unit */ public data class CanUnregisterAccount( public val account: AccountId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterAccount = try { - CanUnregisterAccount( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanUnregisterAccount = + try { + CanUnregisterAccount( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAccount): Unit = try { - AccountId.write(writer, instance.account) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CanUnregisterAccount, + ): 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/CanUnregisterAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAsset.kt new file mode 100644 index 000000000..64d01e146 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAsset.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanUnregisterAsset + * + * Generated from 'CanUnregisterAsset' regular structure + */ +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: 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..6007cb185 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 @@ -17,22 +18,27 @@ import kotlin.Unit */ public data class CanUnregisterAssetDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterAssetDefinition = try { - CanUnregisterAssetDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanUnregisterAssetDefinition = + try { + CanUnregisterAssetDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAssetDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CanUnregisterAssetDefinition, + ): 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/CanUnregisterAssetWithDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterAssetWithDefinition.kt index 026066d46..777a8bbde 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 @@ -17,19 +18,23 @@ import kotlin.Unit */ public data class CanUnregisterAssetWithDefinition( public val assetDefinition: AssetDefinitionId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterAssetWithDefinition = try { - CanUnregisterAssetWithDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanUnregisterAssetWithDefinition = + try { + CanUnregisterAssetWithDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterAssetWithDefinition): Unit = + override fun write( + writer: ScaleCodecWriter, + instance: CanUnregisterAssetWithDefinition, + ): Unit = try { AssetDefinitionId.write(writer, instance.assetDefinition) } catch (ex: Exception) { 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..0b3cc10a7 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 @@ -17,20 +18,25 @@ import kotlin.Unit */ public data class CanUnregisterDomain( public val domain: DomainId, -) { +) : ModelPermission { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterDomain = try { - CanUnregisterDomain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CanUnregisterDomain = + try { + CanUnregisterDomain( + DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterDomain): Unit = try { - DomainId.write(writer, instance.domain) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CanUnregisterDomain, + ): 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/CanUnregisterTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterTrigger.kt new file mode 100644 index 000000000..20c80575b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterTrigger.kt @@ -0,0 +1,42 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Unit + +/** + * CanUnregisterTrigger + * + * Generated from 'CanUnregisterTrigger' regular structure + */ +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: 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/CanUnregisterUserAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserAsset.kt deleted file mode 100644 index c29a1a1c8..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserAsset.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 - -/** - * CanUnregisterUserAsset - * - * Generated from 'CanUnregisterUserAsset' regular structure - */ -public data class CanUnregisterUserAsset( - public val asset: AssetId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterUserAsset = try { - CanUnregisterUserAsset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterUserAsset): 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/CanUnregisterUserTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserTrigger.kt deleted file mode 100644 index 80340de0b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUnregisterUserTrigger.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 - -/** - * CanUnregisterUserTrigger - * - * Generated from 'CanUnregisterUserTrigger' regular structure - */ -public data class CanUnregisterUserTrigger( - public val account: AccountId, -) { - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CanUnregisterUserTrigger = try { - CanUnregisterUserTrigger( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: CanUnregisterUserTrigger): 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/CanUpgradeExecutor.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUpgradeExecutor.kt new file mode 100644 index 000000000..c2558e4a1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CanUpgradeExecutor.kt @@ -0,0 +1,51 @@ +// +// Auto-generated file. DO NOT EDIT! +// +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 +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 + +/** + * CanUpgradeExecutor + * + * Generated from 'CanUpgradeExecutor' tuple structure + */ +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: CanUpgradeExecutor, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: CanUpgradeExecutor, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + 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..e4d2d8ae7 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 @@ -20,18 +20,23 @@ public data class ChainId( public val string: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ChainId = try { - ChainId( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ChainId = + try { + ChainId( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ChainId): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ChainId, + ): 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/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..0424b2cd6 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,24 +16,32 @@ 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( - SignedTransaction.read(reader), - reader.readNullable(TransactionRejectionReason) as TransactionRejectionReason?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CommittedTransaction = + try { + CommittedTransaction( + HashOf.read(reader) as HashOf, + SignedTransaction.read(reader), + reader.readNullable(TransactionRejectionReason) as TransactionRejectionReason?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CommittedTransaction): Unit = try { - SignedTransaction.write(writer, instance.`value`) - writer.writeNullable(TransactionRejectionReason, instance.error) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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) { + throw wrapException(ex) + } } } 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..54e14c642 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionPredicateAtom.kt @@ -0,0 +1,42 @@ +// +// 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..f359884f9 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfPredicateMarker.kt @@ -0,0 +1,196 @@ +// +// 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..9b3a93bea --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CommittedTransactionProjectionOfSelectorMarker.kt @@ -0,0 +1,216 @@ +// +// 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..f91bc8072 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccount.kt @@ -0,0 +1,195 @@ +// +// 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/CompoundPredicateOfAccountPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccountPredicateBox.kt deleted file mode 100644 index 45b664893..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAccountPredicateBox.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 - -/** - * CompoundPredicateOfAccountPredicateBox - * - * Generated from 'CompoundPredicateOfAccountPredicateBox' enum - */ -public sealed class CompoundPredicateOfAccountPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val accountPredicateBox: AccountPredicateBox, - ) : CompoundPredicateOfAccountPredicateBox() { - 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.CompoundPredicateOfAccountPredicateBox.Atom = try { - Atom( - AccountPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Atom, - ): Unit = try { - AccountPredicateBox.write(writer, instance.accountPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfAccountPredicateBox: CompoundPredicateOfAccountPredicateBox, - ) : CompoundPredicateOfAccountPredicateBox() { - 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.CompoundPredicateOfAccountPredicateBox.Not = try { - Not( - CompoundPredicateOfAccountPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfAccountPredicateBox.write( - writer, - instance.compoundPredicateOfAccountPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfAccountPredicateBox() { - 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.CompoundPredicateOfAccountPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccountPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAccountPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfAccountPredicateBox() { - 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.CompoundPredicateOfAccountPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAccountPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAccountPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAccountPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfAccountPredicateBox = 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: CompoundPredicateOfAccountPredicateBox) { - 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..bc8abba76 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAsset.kt @@ -0,0 +1,195 @@ +// +// 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/CompoundPredicateOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinition.kt new file mode 100644 index 000000000..f3aa7b757 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetDefinition.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfAssetDefinition + * + * Generated from 'CompoundPredicateOfAssetDefinition' enum + */ +public sealed class CompoundPredicateOfAssetDefinition : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val assetDefinitionProjectionOfPredicateMarker: AssetDefinitionProjectionOfPredicateMarker, + ) : CompoundPredicateOfAssetDefinition() { + 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.CompoundPredicateOfAssetDefinition.Atom = + try { + Atom( + AssetDefinitionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Atom, + ): Unit = + try { + AssetDefinitionProjectionOfPredicateMarker.write(writer, instance.assetDefinitionProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfAssetDefinition: CompoundPredicateOfAssetDefinition, + ) : CompoundPredicateOfAssetDefinition() { + 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.CompoundPredicateOfAssetDefinition.Not = + try { + Not( + CompoundPredicateOfAssetDefinition.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Not, + ): Unit = + try { + CompoundPredicateOfAssetDefinition.write(writer, instance.compoundPredicateOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfAssetDefinition() { + 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.CompoundPredicateOfAssetDefinition.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinition.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAssetDefinition.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfAssetDefinition() { + 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.CompoundPredicateOfAssetDefinition.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetDefinition.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetDefinition.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfAssetDefinition.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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/CompoundPredicateOfAssetPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetPredicateBox.kt deleted file mode 100644 index 41dcffd98..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfAssetPredicateBox.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 - -/** - * CompoundPredicateOfAssetPredicateBox - * - * Generated from 'CompoundPredicateOfAssetPredicateBox' enum - */ -public sealed class CompoundPredicateOfAssetPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val assetPredicateBox: AssetPredicateBox, - ) : CompoundPredicateOfAssetPredicateBox() { - 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.CompoundPredicateOfAssetPredicateBox.Atom = try { - Atom( - AssetPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Atom, - ): Unit = try { - AssetPredicateBox.write(writer, instance.assetPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfAssetPredicateBox: CompoundPredicateOfAssetPredicateBox, - ) : CompoundPredicateOfAssetPredicateBox() { - 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.CompoundPredicateOfAssetPredicateBox.Not = try { - Not( - CompoundPredicateOfAssetPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfAssetPredicateBox.write( - writer, - instance.compoundPredicateOfAssetPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfAssetPredicateBox() { - 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.CompoundPredicateOfAssetPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAssetPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfAssetPredicateBox() { - 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.CompoundPredicateOfAssetPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfAssetPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfAssetPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfAssetPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfAssetPredicateBox = 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: CompoundPredicateOfAssetPredicateBox) { - 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/CompoundPredicateOfBlockHeader.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeader.kt new file mode 100644 index 000000000..8a57592a6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfBlockHeader.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfBlockHeader + * + * Generated from 'CompoundPredicateOfBlockHeader' enum + */ +public sealed class CompoundPredicateOfBlockHeader : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val blockHeaderProjectionOfPredicateMarker: BlockHeaderProjectionOfPredicateMarker, + ) : CompoundPredicateOfBlockHeader() { + 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.CompoundPredicateOfBlockHeader.Atom = + try { + Atom( + BlockHeaderProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Atom, + ): Unit = + try { + BlockHeaderProjectionOfPredicateMarker.write(writer, instance.blockHeaderProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfBlockHeader: CompoundPredicateOfBlockHeader, + ) : CompoundPredicateOfBlockHeader() { + 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.CompoundPredicateOfBlockHeader.Not = + try { + Not( + CompoundPredicateOfBlockHeader.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Not, + ): Unit = + try { + CompoundPredicateOfBlockHeader.write(writer, instance.compoundPredicateOfBlockHeader) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfBlockHeader() { + 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.CompoundPredicateOfBlockHeader.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeader.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfBlockHeader.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfBlockHeader() { + 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.CompoundPredicateOfBlockHeader.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfBlockHeader.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfBlockHeader.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfBlockHeader.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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/CompoundPredicateOfCommittedTransaction.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfCommittedTransaction.kt new file mode 100644 index 000000000..4535b8492 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfCommittedTransaction.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfCommittedTransaction + * + * Generated from 'CompoundPredicateOfCommittedTransaction' enum + */ +public sealed class CompoundPredicateOfCommittedTransaction : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val committedTransactionProjectionOfPredicateMarker: CommittedTransactionProjectionOfPredicateMarker, + ) : CompoundPredicateOfCommittedTransaction() { + 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.CompoundPredicateOfCommittedTransaction.Atom = + try { + Atom( + CommittedTransactionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Atom, + ): Unit = + try { + CommittedTransactionProjectionOfPredicateMarker.write(writer, instance.committedTransactionProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfCommittedTransaction: CompoundPredicateOfCommittedTransaction, + ) : CompoundPredicateOfCommittedTransaction() { + 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.CompoundPredicateOfCommittedTransaction.Not = + try { + Not( + CompoundPredicateOfCommittedTransaction.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Not, + ): Unit = + try { + CompoundPredicateOfCommittedTransaction.write(writer, instance.compoundPredicateOfCommittedTransaction) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfCommittedTransaction() { + 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.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.CompoundPredicateOfCommittedTransaction.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfCommittedTransaction.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfCommittedTransaction() { + 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.CompoundPredicateOfCommittedTransaction.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfCommittedTransaction.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfCommittedTransaction.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfCommittedTransaction.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt new file mode 100644 index 000000000..79e9455aa --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomain.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfDomain + * + * Generated from 'CompoundPredicateOfDomain' enum + */ +public sealed class CompoundPredicateOfDomain : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val domainProjectionOfPredicateMarker: DomainProjectionOfPredicateMarker, + ) : CompoundPredicateOfDomain() { + 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.CompoundPredicateOfDomain.Atom = + try { + Atom( + DomainProjectionOfPredicateMarker.read(reader), + ) + } 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 compoundPredicateOfDomain: CompoundPredicateOfDomain, + ) : CompoundPredicateOfDomain() { + 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.CompoundPredicateOfDomain.Not = + try { + Not( + CompoundPredicateOfDomain.read(reader), + ) + } 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, + ) : CompoundPredicateOfDomain() { + 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.CompoundPredicateOfDomain.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomain.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + 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) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfDomain() { + 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.CompoundPredicateOfDomain.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomain.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomain.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfDomain.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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/CompoundPredicateOfDomainPredicateBox.kt deleted file mode 100644 index 08a709838..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfDomainPredicateBox.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 - -/** - * CompoundPredicateOfDomainPredicateBox - * - * Generated from 'CompoundPredicateOfDomainPredicateBox' enum - */ -public sealed class CompoundPredicateOfDomainPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val domainPredicateBox: DomainPredicateBox, - ) : CompoundPredicateOfDomainPredicateBox() { - 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.CompoundPredicateOfDomainPredicateBox.Atom = try { - Atom( - DomainPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Atom, - ): Unit = try { - DomainPredicateBox.write(writer, instance.domainPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfDomainPredicateBox: CompoundPredicateOfDomainPredicateBox, - ) : CompoundPredicateOfDomainPredicateBox() { - 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.CompoundPredicateOfDomainPredicateBox.Not = try { - Not( - CompoundPredicateOfDomainPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfDomainPredicateBox.write( - writer, - instance.compoundPredicateOfDomainPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfDomainPredicateBox() { - 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.CompoundPredicateOfDomainPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomainPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfDomainPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfDomainPredicateBox() { - 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.CompoundPredicateOfDomainPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfDomainPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfDomainPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfDomainPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfDomainPredicateBox = 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: CompoundPredicateOfDomainPredicateBox) { - 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/CompoundPredicateOfPeerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerId.kt new file mode 100644 index 000000000..6ce46ca9b --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerId.kt @@ -0,0 +1,195 @@ +// +// 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/CompoundPredicateOfPeerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerPredicateBox.kt deleted file mode 100644 index c173ec28c..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPeerPredicateBox.kt +++ /dev/null @@ -1,188 +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 - -/** - * CompoundPredicateOfPeerPredicateBox - * - * Generated from 'CompoundPredicateOfPeerPredicateBox' enum - */ -public sealed class CompoundPredicateOfPeerPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val peerPredicateBox: PeerPredicateBox, - ) : CompoundPredicateOfPeerPredicateBox() { - 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.CompoundPredicateOfPeerPredicateBox.Atom = try { - Atom( - PeerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Atom, - ): Unit = try { - PeerPredicateBox.write(writer, instance.peerPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfPeerPredicateBox: CompoundPredicateOfPeerPredicateBox, - ) : CompoundPredicateOfPeerPredicateBox() { - 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.CompoundPredicateOfPeerPredicateBox.Not = try { - Not( - CompoundPredicateOfPeerPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfPeerPredicateBox.write( - writer, - instance.compoundPredicateOfPeerPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfPeerPredicateBox() { - 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.CompoundPredicateOfPeerPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfPeerPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfPeerPredicateBox() { - 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.CompoundPredicateOfPeerPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPeerPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPeerPredicateBox.Or, - ): Unit = - try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfPeerPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfPeerPredicateBox = 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: CompoundPredicateOfPeerPredicateBox) { - 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/CompoundPredicateOfPermission.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermission.kt new file mode 100644 index 000000000..67333c062 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermission.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfPermission + * + * Generated from 'CompoundPredicateOfPermission' enum + */ +public sealed class CompoundPredicateOfPermission : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val permissionProjectionOfPredicateMarker: PermissionProjectionOfPredicateMarker, + ) : CompoundPredicateOfPermission() { + 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.CompoundPredicateOfPermission.Atom = + try { + Atom( + PermissionProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Atom, + ): Unit = + try { + PermissionProjectionOfPredicateMarker.write(writer, instance.permissionProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfPermission: CompoundPredicateOfPermission, + ) : CompoundPredicateOfPermission() { + 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.CompoundPredicateOfPermission.Not = + try { + Not( + CompoundPredicateOfPermission.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Not, + ): Unit = + try { + CompoundPredicateOfPermission.write(writer, instance.compoundPredicateOfPermission) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfPermission() { + 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.CompoundPredicateOfPermission.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermission.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfPermission.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfPermission() { + 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.CompoundPredicateOfPermission.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermission.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermission.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfPermission.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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/CompoundPredicateOfPermissionPredicateBox.kt deleted file mode 100644 index 90ad9bb31..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfPermissionPredicateBox.kt +++ /dev/null @@ -1,188 +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 - -/** - * CompoundPredicateOfPermissionPredicateBox - * - * Generated from 'CompoundPredicateOfPermissionPredicateBox' enum - */ -public sealed class CompoundPredicateOfPermissionPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val permissionPredicateBox: PermissionPredicateBox, - ) : CompoundPredicateOfPermissionPredicateBox() { - 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.CompoundPredicateOfPermissionPredicateBox.Atom = try { - Atom( - PermissionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Atom, - ): Unit = try { - PermissionPredicateBox.write(writer, instance.permissionPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfPermissionPredicateBox: CompoundPredicateOfPermissionPredicateBox, - ) : CompoundPredicateOfPermissionPredicateBox() { - 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.CompoundPredicateOfPermissionPredicateBox.Not = try { - Not( - CompoundPredicateOfPermissionPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfPermissionPredicateBox.write( - writer, - instance.compoundPredicateOfPermissionPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfPermissionPredicateBox() { - 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.CompoundPredicateOfPermissionPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermissionPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfPermissionPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfPermissionPredicateBox() { - 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.CompoundPredicateOfPermissionPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfPermissionPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfPermissionPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfPermissionPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfPermissionPredicateBox = - 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: CompoundPredicateOfPermissionPredicateBox, - ) { - 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/CompoundPredicateOfRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRole.kt new file mode 100644 index 000000000..eca00a639 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRole.kt @@ -0,0 +1,195 @@ +// +// 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/CompoundPredicateOfRolePredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleId.kt similarity index 50% 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/CompoundPredicateOfRoleId.kt index 83ddb0d6f..dc7263c15 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/CompoundPredicateOfRoleId.kt @@ -14,11 +14,11 @@ import kotlin.Unit import kotlin.collections.List /** - * CompoundPredicateOfRolePredicateBox + * CompoundPredicateOfRoleId * - * Generated from 'CompoundPredicateOfRolePredicateBox' enum + * Generated from 'CompoundPredicateOfRoleId' enum */ -public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { +public sealed class CompoundPredicateOfRoleId : ModelEnum { /** * @return Discriminator of variant in enum */ @@ -28,31 +28,33 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { * 'Atom' variant */ public data class Atom( - public val rolePredicateBox: RolePredicateBox, - ) : CompoundPredicateOfRolePredicateBox() { + public val roleIdProjectionOfPredicateMarker: RoleIdProjectionOfPredicateMarker, + ) : CompoundPredicateOfRoleId() { 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 { - Atom( - RolePredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.CompoundPredicateOfRolePredicateBox.Atom, - ): Unit = try { - RolePredicateBox.write(writer, instance.rolePredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Atom, + ): Unit = + try { + RoleIdProjectionOfPredicateMarker.write(writer, instance.roleIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -60,34 +62,33 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { * 'Not' variant */ public data class Not( - public val compoundPredicateOfRolePredicateBox: CompoundPredicateOfRolePredicateBox, - ) : CompoundPredicateOfRolePredicateBox() { + public val compoundPredicateOfRoleId: CompoundPredicateOfRoleId, + ) : CompoundPredicateOfRoleId() { 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 { - Not( - CompoundPredicateOfRolePredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.CompoundPredicateOfRolePredicateBox.Not, - ): Unit = try { - CompoundPredicateOfRolePredicateBox.write( - writer, - instance.compoundPredicateOfRolePredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Not, + ): Unit = + try { + CompoundPredicateOfRoleId.write(writer, instance.compoundPredicateOfRoleId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -95,34 +96,36 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { * 'And' variant */ public data class And( - public val vec: List, - ) : CompoundPredicateOfRolePredicateBox() { + public val vec: List, + ) : CompoundPredicateOfRoleId() { 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 { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRolePredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.CompoundPredicateOfRolePredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfRolePredicateBox.write(writer, value) + 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) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -130,31 +133,32 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { * 'Or' variant */ public data class Or( - public val vec: List, - ) : CompoundPredicateOfRolePredicateBox() { + public val vec: List, + ) : CompoundPredicateOfRoleId() { 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 { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRolePredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.CompoundPredicateOfRolePredicateBox.Or, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleId.Or, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - CompoundPredicateOfRolePredicateBox.write(writer, value) + CompoundPredicateOfRoleId.write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -163,26 +167,29 @@ public sealed class CompoundPredicateOfRolePredicateBox : ModelEnum { } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfRolePredicateBox = 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") } + 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: CompoundPredicateOfRolePredicateBox) { + 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") } + 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/CompoundPredicateOfRoleIdPredicateBox.kt deleted file mode 100644 index 4c871c6cd..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfRoleIdPredicateBox.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 - -/** - * CompoundPredicateOfRoleIdPredicateBox - * - * Generated from 'CompoundPredicateOfRoleIdPredicateBox' enum - */ -public sealed class CompoundPredicateOfRoleIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Atom' variant - */ - public data class Atom( - public val roleIdPredicateBox: RoleIdPredicateBox, - ) : CompoundPredicateOfRoleIdPredicateBox() { - 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.CompoundPredicateOfRoleIdPredicateBox.Atom = try { - Atom( - RoleIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Atom, - ): Unit = try { - RoleIdPredicateBox.write(writer, instance.roleIdPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Not' variant - */ - public data class Not( - public val compoundPredicateOfRoleIdPredicateBox: CompoundPredicateOfRoleIdPredicateBox, - ) : CompoundPredicateOfRoleIdPredicateBox() { - 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.CompoundPredicateOfRoleIdPredicateBox.Not = try { - Not( - CompoundPredicateOfRoleIdPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Not, - ): Unit = try { - CompoundPredicateOfRoleIdPredicateBox.write( - writer, - instance.compoundPredicateOfRoleIdPredicateBox, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'And' variant - */ - public data class And( - public val vec: List, - ) : CompoundPredicateOfRoleIdPredicateBox() { - 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.CompoundPredicateOfRoleIdPredicateBox.And = try { - And( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleIdPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.And, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfRoleIdPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Or' variant - */ - public data class Or( - public val vec: List, - ) : CompoundPredicateOfRoleIdPredicateBox() { - 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.CompoundPredicateOfRoleIdPredicateBox.Or = try { - Or( - reader.readVec(reader.readCompactInt()) { CompoundPredicateOfRoleIdPredicateBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfRoleIdPredicateBox.Or, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - CompoundPredicateOfRoleIdPredicateBox.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): CompoundPredicateOfRoleIdPredicateBox = 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: CompoundPredicateOfRoleIdPredicateBox) { - 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/CompoundPredicateOfSignedBlock.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlock.kt new file mode 100644 index 000000000..c8131100d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfSignedBlock.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfSignedBlock + * + * Generated from 'CompoundPredicateOfSignedBlock' enum + */ +public sealed class CompoundPredicateOfSignedBlock : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val signedBlockProjectionOfPredicateMarker: SignedBlockProjectionOfPredicateMarker, + ) : CompoundPredicateOfSignedBlock() { + 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.CompoundPredicateOfSignedBlock.Atom = + try { + Atom( + SignedBlockProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Atom, + ): Unit = + try { + SignedBlockProjectionOfPredicateMarker.write(writer, instance.signedBlockProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfSignedBlock: CompoundPredicateOfSignedBlock, + ) : CompoundPredicateOfSignedBlock() { + 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.CompoundPredicateOfSignedBlock.Not = + try { + Not( + CompoundPredicateOfSignedBlock.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Not, + ): Unit = + try { + CompoundPredicateOfSignedBlock.write(writer, instance.compoundPredicateOfSignedBlock) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfSignedBlock() { + 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.CompoundPredicateOfSignedBlock.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlock.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfSignedBlock.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfSignedBlock() { + 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.CompoundPredicateOfSignedBlock.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfSignedBlock.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfSignedBlock.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfSignedBlock.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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..d242cb9dd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTrigger.kt @@ -0,0 +1,195 @@ +// +// 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/CompoundPredicateOfTriggerId.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerId.kt new file mode 100644 index 000000000..907e91641 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/CompoundPredicateOfTriggerId.kt @@ -0,0 +1,195 @@ +// +// 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 + +/** + * CompoundPredicateOfTriggerId + * + * Generated from 'CompoundPredicateOfTriggerId' enum + */ +public sealed class CompoundPredicateOfTriggerId : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val triggerIdProjectionOfPredicateMarker: TriggerIdProjectionOfPredicateMarker, + ) : CompoundPredicateOfTriggerId() { + 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.CompoundPredicateOfTriggerId.Atom = + try { + Atom( + TriggerIdProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Atom, + ): Unit = + try { + TriggerIdProjectionOfPredicateMarker.write(writer, instance.triggerIdProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Not' variant + */ + public data class Not( + public val compoundPredicateOfTriggerId: CompoundPredicateOfTriggerId, + ) : CompoundPredicateOfTriggerId() { + 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.CompoundPredicateOfTriggerId.Not = + try { + Not( + CompoundPredicateOfTriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Not, + ): Unit = + try { + CompoundPredicateOfTriggerId.write(writer, instance.compoundPredicateOfTriggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'And' variant + */ + public data class And( + public val vec: List, + ) : CompoundPredicateOfTriggerId() { + 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.CompoundPredicateOfTriggerId.And = + try { + And( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.And, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfTriggerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Or' variant + */ + public data class Or( + public val vec: List, + ) : CompoundPredicateOfTriggerId() { + 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.CompoundPredicateOfTriggerId.Or = + try { + Or( + reader.readVec(reader.readCompactInt()) { CompoundPredicateOfTriggerId.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.CompoundPredicateOfTriggerId.Or, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + CompoundPredicateOfTriggerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + 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") + } + + 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") + } + } + } +} 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..e8772077b 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 @@ -36,38 +36,43 @@ public sealed class ConfigurationEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ConfigurationEvent.Changed = try { - Changed( - ParameterChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ConfigurationEvent.Changed = + try { + Changed( + ParameterChanged.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Changed.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: ConfigurationEvent) { + 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..293b9a297 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 @@ -22,18 +22,23 @@ public data class ConfigurationEventFilter( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ConfigurationEventFilter = try { - ConfigurationEventFilter( - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ConfigurationEventFilter = + try { + ConfigurationEventFilter( + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ConfigurationEventFilter): Unit = try { - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ConfigurationEventFilter, + ): Unit = + try { + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..520d82a02 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 /** @@ -17,21 +16,26 @@ import kotlin.Unit * Generated from 'CustomInstruction' regular structure */ public data class CustomInstruction( - public val payload: String, + public val payload: Json, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CustomInstruction = try { - CustomInstruction( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CustomInstruction = + try { + CustomInstruction( + 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CustomInstruction, + ): Unit = + try { + 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..53470a0d6 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 /** @@ -18,23 +17,28 @@ import kotlin.Unit */ public data class CustomParameter( public val id: CustomParameterId, - public val payload: String, + public val payload: Json, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CustomParameter = try { - CustomParameter( - CustomParameterId.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CustomParameter = + try { + CustomParameter( + CustomParameterId.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CustomParameter): Unit = try { - CustomParameterId.write(writer, instance.id) - writer.writeAsList(instance.payload.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CustomParameter, + ): Unit = + try { + CustomParameterId.write(writer, instance.id) + 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..aeec8572c 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 @@ -19,18 +19,23 @@ public data class CustomParameterId( public val name: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): CustomParameterId = try { - CustomParameterId( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): CustomParameterId = + try { + CustomParameterId( + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: CustomParameterId): Unit = try { - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: CustomParameterId, + ): 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/DataEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DataEvent.kt index 426dfe055..d156b86c9 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 @@ -48,11 +48,12 @@ public sealed class DataEvent : ModelEnum { 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) - } + ): Unit = + try { + PeerEvent.write(writer, instance.peerEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,22 +70,24 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Domain = try { - Domain( - DomainEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Domain = + try { + Domain( + DomainEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DomainEvent.write(writer, instance.domainEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,22 +104,24 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Trigger = try { - Trigger( - TriggerEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Trigger = + try { + Trigger( + TriggerEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerEvent.write(writer, instance.triggerEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -145,11 +150,12 @@ public sealed class DataEvent : ModelEnum { 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) - } + ): Unit = + try { + RoleEvent.write(writer, instance.roleEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -166,22 +172,24 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Configuration = try { - Configuration( - ConfigurationEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Configuration = + try { + Configuration( + ConfigurationEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ConfigurationEvent.write(writer, instance.configurationEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -198,39 +206,43 @@ public sealed class DataEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Executor = try { - Executor( - ExecutorEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEvent.Executor = + try { + Executor( + ExecutorEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ExecutorEvent.write(writer, instance.executorEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: DataEvent, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: DataEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Peer.write(writer, instance as Peer) @@ -239,7 +251,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..bdb7ddea7 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 @@ -24,13 +24,17 @@ public sealed class DataEventFilter : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: kotlin.Any?): Boolean = when (this) { - is Any -> Any.equals(this, other) - else -> super.equals(other) } + override fun equals(other: kotlin.Any?): Boolean = + when (this) { + is Any -> Any.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is Any -> Any.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is Any -> Any.hashCode() + else -> super.hashCode() + } /** * 'Any' variant @@ -43,24 +47,30 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Any = try { - Any() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Any = + try { + Any() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.DataEventFilter.Any, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.DataEventFilter.Any, o2: kotlin.Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.DataEventFilter.Any, + o2: kotlin.Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".DataEventFilter.Any".hashCode() } @@ -79,22 +89,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Peer = try { - Peer( - PeerEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Peer = + try { + Peer( + PeerEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + PeerEventFilter.write(writer, instance.peerEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -111,22 +123,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Domain = try { - Domain( - DomainEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Domain = + try { + Domain( + DomainEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DomainEventFilter.write(writer, instance.domainEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -143,22 +157,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Account = try { - Account( - AccountEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Account = + try { + Account( + AccountEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountEventFilter.write(writer, instance.accountEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -175,22 +191,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Asset = try { - Asset( - AssetEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Asset = + try { + Asset( + AssetEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetEventFilter.write(writer, instance.assetEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -207,22 +225,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.AssetDefinition = try { - AssetDefinition( - AssetDefinitionEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.AssetDefinition = + try { + AssetDefinition( + AssetDefinitionEventFilter.read(reader), + ) + } 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) - } + ): Unit = + try { + AssetDefinitionEventFilter.write(writer, instance.assetDefinitionEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -239,22 +259,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Trigger = try { - Trigger( - TriggerEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Trigger = + try { + Trigger( + TriggerEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerEventFilter.write(writer, instance.triggerEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -271,22 +293,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Role = try { - Role( - RoleEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Role = + try { + Role( + RoleEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RoleEventFilter.write(writer, instance.roleEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -303,22 +327,24 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Configuration = try { - Configuration( - ConfigurationEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Configuration = + try { + Configuration( + ConfigurationEventFilter.read(reader), + ) + } 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) - } + ): Unit = + try { + ConfigurationEventFilter.write(writer, instance.configurationEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -335,43 +361,47 @@ public sealed class DataEventFilter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 9 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Executor = try { - Executor( - ExecutorEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DataEventFilter.Executor = + try { + Executor( + ExecutorEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ExecutorEventFilter.write(writer, instance.executorEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> Account.read(reader) + 4 -> Asset.read(reader) + 5 -> AssetDefinition.read(reader) + 6 -> Trigger.read(reader) + 7 -> Role.read(reader) + 8 -> Configuration.read(reader) + 9 -> Executor.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: DataEventFilter, ) { - 0 -> Any.read(reader) - 1 -> Peer.read(reader) - 2 -> Domain.read(reader) - 3 -> Account.read(reader) - 4 -> Asset.read(reader) - 5 -> AssetDefinition.read(reader) - 6 -> Trigger.read(reader) - 7 -> Role.read(reader) - 8 -> Configuration.read(reader) - 9 -> Executor.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: DataEventFilter) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Any.write(writer, instance as Any) @@ -384,7 +414,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/Domain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Domain.kt index 98d99c95d..533455e46 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Domain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Domain.kt @@ -22,24 +22,29 @@ public data class Domain( public val ownedBy: AccountId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Domain = try { - Domain( - DomainId.read(reader), - reader.readNullable(IpfsPath) as IpfsPath?, - Metadata.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Domain = + try { + Domain( + DomainId.read(reader), + reader.readNullable(IpfsPath) as IpfsPath?, + Metadata.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Domain): Unit = try { - DomainId.write(writer, instance.id) - writer.writeNullable(IpfsPath, instance.logo) - Metadata.write(writer, instance.metadata) - AccountId.write(writer, instance.ownedBy) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Domain, + ): Unit = + try { + DomainId.write(writer, instance.id) + writer.writeNullable(IpfsPath, instance.logo) + Metadata.write(writer, instance.metadata) + AccountId.write(writer, instance.ownedBy) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..2002f55e6 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 @@ -36,22 +36,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Created = try { - Created( - Domain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Created = + try { + Created( + Domain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Domain.write(writer, instance.domain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Deleted = try { - Deleted( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Deleted = + try { + Deleted( + DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DomainId.write(writer, instance.domainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.AssetDefinition = try { - AssetDefinition( - AssetDefinitionEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.AssetDefinition = + try { + AssetDefinition( + AssetDefinitionEvent.read(reader), + ) + } 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) - } + ): Unit = + try { + AssetDefinitionEvent.write(writer, instance.assetDefinitionEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Account = try { - Account( - AccountEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.Account = + try { + Account( + AccountEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountEvent.write(writer, instance.accountEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataInserted = try { - MetadataInserted( - MetadataChangedOfDomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataInserted = + try { + MetadataInserted( + MetadataChangedOfDomainId.read(reader), + ) + } 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) - } + ): Unit = + try { + MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataRemoved = try { - MetadataRemoved( - MetadataChangedOfDomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.MetadataRemoved = + try { + MetadataRemoved( + MetadataChangedOfDomainId.read(reader), + ) + } 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) - } + ): Unit = + try { + MetadataChangedOfDomainId.write(writer, instance.metadataChangedOfDomainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,40 +240,44 @@ public sealed class DomainEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.OwnerChanged = try { - OwnerChanged( - DomainOwnerChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.DomainEvent.OwnerChanged = + try { + OwnerChanged( + DomainOwnerChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DomainOwnerChanged.write(writer, instance.domainOwnerChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> Account.read(reader) + 4 -> MetadataInserted.read(reader) + 5 -> MetadataRemoved.read(reader) + 6 -> OwnerChanged.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: DomainEvent, ) { - 0 -> Created.read(reader) - 1 -> Deleted.read(reader) - 2 -> AssetDefinition.read(reader) - 3 -> Account.read(reader) - 4 -> MetadataInserted.read(reader) - 5 -> MetadataRemoved.read(reader) - 6 -> OwnerChanged.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: DomainEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) @@ -271,7 +287,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..c113755dc 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 @@ -21,20 +21,25 @@ public data class DomainEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainEventFilter = try { - DomainEventFilter( - reader.readNullable(DomainId) as DomainId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): DomainEventFilter = + try { + DomainEventFilter( + reader.readNullable(DomainId) as DomainId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: DomainEventFilter): Unit = try { - writer.writeNullable(DomainId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: DomainEventFilter, + ): Unit = + try { + writer.writeNullable(DomainId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..be7f67208 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 @@ -19,18 +19,23 @@ public data class DomainId( public val name: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainId = try { - DomainId( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): DomainId = + try { + DomainId( + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: DomainId): Unit = try { - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: DomainId, + ): 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/DomainIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateAtom.kt new file mode 100644 index 000000000..126332892 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateAtom.kt @@ -0,0 +1,78 @@ +// +// 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/DomainIdPredicateBox.kt deleted file mode 100644 index c0ddd21c5..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdPredicateBox.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 - -/** - * DomainIdPredicateBox - * - * Generated from 'DomainIdPredicateBox' enum - */ -public sealed class DomainIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val domainId: DomainId, - ) : DomainIdPredicateBox() { - 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.DomainIdPredicateBox.Equals = try { - Equals( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Equals, - ): Unit = try { - DomainId.write(writer, instance.domainId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Name' variant - */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : DomainIdPredicateBox() { - 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.DomainIdPredicateBox.Name = try { - Name( - StringPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.DomainIdPredicateBox.Name, - ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) - } 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) - 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: DomainIdPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 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/DomainIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..cc412d942 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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 + +/** + * DomainIdProjectionOfPredicateMarker + * + * Generated from 'DomainIdProjectionOfPredicateMarker' enum + */ +public sealed class DomainIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val domainIdPredicateAtom: DomainIdPredicateAtom, + ) : DomainIdProjectionOfPredicateMarker() { + 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.DomainIdProjectionOfPredicateMarker.Atom = + try { + Atom( + DomainIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Atom, + ): Unit = + try { + DomainIdPredicateAtom.write(writer, instance.domainIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Name' variant + */ + public data class Name( + public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker, + ) : DomainIdProjectionOfPredicateMarker() { + 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.DomainIdProjectionOfPredicateMarker.Name = + try { + Name( + NameProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.DomainIdProjectionOfPredicateMarker.Name, + ): Unit = + try { + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: DomainIdProjectionOfPredicateMarker, + ) { + 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/DomainIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..a84e1e3f2 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainIdProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..fd12a6239 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 @@ -20,20 +20,25 @@ public data class DomainOwnerChanged( public val newOwner: AccountId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): DomainOwnerChanged = try { - DomainOwnerChanged( - DomainId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): DomainOwnerChanged = + try { + DomainOwnerChanged( + DomainId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: DomainOwnerChanged): Unit = try { - DomainId.write(writer, instance.domain) - AccountId.write(writer, instance.newOwner) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: DomainOwnerChanged, + ): Unit = + try { + DomainId.write(writer, instance.domain) + AccountId.write(writer, instance.newOwner) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..26ce3e6c3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// 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..9f8c72adf --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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..04b1062b3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/DomainProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..18728162a 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 @@ -36,22 +36,24 @@ public sealed class EventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Pipeline = try { - Pipeline( - PipelineEventBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.Pipeline = + try { + Pipeline( + PipelineEventBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + PipelineEventBox.write(writer, instance.pipelineEventBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -80,11 +82,12 @@ public sealed class EventBox : ModelEnum { 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) - } + ): Unit = + try { + DataEvent.write(writer, instance.dataEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -113,11 +116,12 @@ public sealed class EventBox : ModelEnum { 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) - } + ): Unit = + try { + TimeEvent.write(writer, instance.timeEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -134,22 +138,24 @@ public sealed class EventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.ExecuteTrigger = try { - ExecuteTrigger( - ExecuteTriggerEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.ExecuteTrigger = + try { + ExecuteTrigger( + ExecuteTriggerEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ExecuteTriggerEvent.write(writer, instance.executeTriggerEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -166,38 +172,42 @@ public sealed class EventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.TriggerCompleted = try { - TriggerCompleted( - TriggerCompletedEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventBox.TriggerCompleted = + try { + TriggerCompleted( + TriggerCompletedEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerCompletedEvent.write(writer, instance.triggerCompletedEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: EventBox, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: EventBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Pipeline.write(writer, instance as Pipeline) @@ -205,7 +215,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..4879e3642 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 @@ -36,22 +36,24 @@ public sealed class EventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Pipeline = try { - Pipeline( - PipelineEventFilterBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Pipeline = + try { + Pipeline( + PipelineEventFilterBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + PipelineEventFilterBox.write(writer, instance.pipelineEventFilterBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class EventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Data = try { - Data( - DataEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Data = + try { + Data( + DataEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DataEventFilter.write(writer, instance.dataEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class EventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Time = try { - Time( - TimeEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.Time = + try { + Time( + TimeEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TimeEventFilter.write(writer, instance.timeEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class EventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.ExecuteTrigger = try { - ExecuteTrigger( - ExecuteTriggerEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.ExecuteTrigger = + try { + ExecuteTrigger( + ExecuteTriggerEventFilter.read(reader), + ) + } 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) - } + ): Unit = + try { + ExecuteTriggerEventFilter.write(writer, instance.executeTriggerEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,38 +172,42 @@ public sealed class EventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.TriggerCompleted = try { - TriggerCompleted( - TriggerCompletedEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.EventFilterBox.TriggerCompleted = + try { + TriggerCompleted( + TriggerCompletedEventFilter.read(reader), + ) + } 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) - } + ): 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: EventFilterBox, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: EventFilterBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Pipeline.write(writer, instance as Pipeline) @@ -203,7 +215,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..aa048839e 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 @@ -19,18 +19,23 @@ public data class EventMessage( public val eventBox: EventBox, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): EventMessage = try { - EventMessage( - EventBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): EventMessage = + try { + EventMessage( + EventBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: EventMessage): Unit = try { - EventBox.write(writer, instance.eventBox) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: EventMessage, + ): Unit = + try { + EventBox.write(writer, instance.eventBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..71571c84d 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 @@ -22,21 +22,26 @@ public data class EventSubscriptionRequest( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): EventSubscriptionRequest = try { - EventSubscriptionRequest( - reader.readVec(reader.readCompactInt()) { EventFilterBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): EventSubscriptionRequest = + try { + EventSubscriptionRequest( + reader.readVec(reader.readCompactInt()) { EventFilterBox.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: EventSubscriptionRequest): Unit = try { - writer.writeCompact(instance.vecOfEventFilterBox.size) - instance.vecOfEventFilterBox.forEach { value -> - EventFilterBox.write(writer, value) + override fun write( + writer: ScaleCodecWriter, + instance: EventSubscriptionRequest, + ): Unit = + try { + writer.writeCompact(instance.vecOfEventFilterBox.size) + instance.vecOfEventFilterBox.forEach { value -> + EventFilterBox.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } 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..4a41e8191 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 @@ -37,25 +37,27 @@ public sealed class Executable : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Executable.Instructions = try { - Instructions( - reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Executable.Instructions = + try { + Instructions( + reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + InstructionBox.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -72,40 +74,45 @@ public sealed class Executable : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Executable.Wasm = try { - Wasm( - WasmSmartContract.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Executable.Wasm = + try { + Wasm( + WasmSmartContract.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + WasmSmartContract.write(writer, instance.wasmSmartContract) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: Executable) { + 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..f323826ad 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 /** @@ -18,23 +20,30 @@ import kotlin.Unit */ public data class ExecuteTrigger( public val trigger: TriggerId, - public val args: String? = null, -) { + 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ExecuteTrigger = + try { + ExecuteTrigger( + TriggerId.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ExecuteTrigger): Unit = try { - TriggerId.write(writer, instance.trigger) - writer.writeNullable(instance.args) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ExecuteTrigger, + ): Unit = + try { + TriggerId.write(writer, instance.trigger) + 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..f30babb64 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,25 +18,30 @@ 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ExecuteTriggerEvent = + try { + ExecuteTriggerEvent( + TriggerId.read(reader), + AccountId.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ExecuteTriggerEvent): Unit = try { - TriggerId.write(writer, instance.triggerId) - AccountId.write(writer, instance.authority) - writer.writeNullable(instance.args) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ExecuteTriggerEvent, + ): Unit = + try { + TriggerId.write(writer, instance.triggerId) + AccountId.write(writer, instance.authority) + 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..2c0782ae3 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 @@ -22,20 +22,25 @@ public data class ExecuteTriggerEventFilter( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ExecuteTriggerEventFilter = try { - ExecuteTriggerEventFilter( - reader.readNullable(TriggerId) as TriggerId?, - reader.readNullable(AccountId) as AccountId?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ExecuteTriggerEventFilter = + try { + ExecuteTriggerEventFilter( + reader.readNullable(TriggerId) as TriggerId?, + reader.readNullable(AccountId) as AccountId?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ExecuteTriggerEventFilter): Unit = try { - writer.writeNullable(TriggerId, instance.triggerId) - writer.writeNullable(AccountId, instance.authority) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ExecuteTriggerEventFilter, + ): Unit = + try { + writer.writeNullable(TriggerId, instance.triggerId) + writer.writeNullable(AccountId, instance.authority) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..d329dd531 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 @@ -25,13 +25,17 @@ public sealed class ExecutionTime : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is PreCommit -> PreCommit.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is PreCommit -> PreCommit.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is PreCommit -> PreCommit.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is PreCommit -> PreCommit.hashCode() + else -> super.hashCode() + } /** * 'PreCommit' variant @@ -44,24 +48,30 @@ public sealed class ExecutionTime : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit = try { - PreCommit() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit = + try { + PreCommit() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.ExecutionTime.PreCommit, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".ExecutionTime.PreCommit".hashCode() } @@ -80,40 +90,47 @@ public sealed class ExecutionTime : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutionTime.Schedule = try { - Schedule( - jp.co.soramitsu.iroha2.generated.Schedule.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutionTime.Schedule = + try { + Schedule( + jp.co.soramitsu.iroha2.generated.Schedule + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Schedule + .write(writer, instance.schedule) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: ExecutionTime) { + 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..954db47a3 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 @@ -19,18 +19,23 @@ public data class Executor( public val wasm: WasmSmartContract, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Executor = try { - Executor( - WasmSmartContract.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Executor = + try { + Executor( + WasmSmartContract.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Executor): Unit = try { - WasmSmartContract.write(writer, instance.wasm) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Executor, + ): Unit = + try { + WasmSmartContract.write(writer, instance.wasm) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..2d562e9b2 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,47 +23,51 @@ 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.readVec(reader.readCompactInt()) { reader.readString() }, - reader.readVec(reader.readCompactInt()) { reader.readString() }, - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: ExecutorDataModel): Unit = try { - writer.writeCompact(instance.parameters.size) - instance.parameters.toSortedMap( - CustomParameterId.comparator(), - ).forEach { (key, value) -> - CustomParameterId.write(writer, key) - CustomParameter.write(writer, value) - } - writer.writeCompact(instance.instructions.size) - instance.instructions.sortedWith( - String.comparator(), - ).forEach { value -> - writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + override fun read(reader: ScaleCodecReader): ExecutorDataModel = + try { + ExecutorDataModel( + reader.readMap(reader.readCompactInt(), { CustomParameterId.read(reader) }, { CustomParameter.read(reader) }), + reader.readVec(reader.readCompactInt()) { reader.readString() }, + reader.readVec(reader.readCompactInt()) { reader.readString() }, + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) } - writer.writeCompact(instance.permissions.size) - instance.permissions.sortedWith( - String.comparator(), - ).forEach { value -> - writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + + override fun write( + writer: ScaleCodecWriter, + instance: ExecutorDataModel, + ): Unit = + try { + writer.writeCompact(instance.parameters.size) + instance.parameters + .toSortedMap( + CustomParameterId.comparator(), + ).forEach { (key, value) -> + CustomParameterId.write(writer, key) + CustomParameter.write(writer, value) + } + writer.writeCompact(instance.instructions.size) + instance.instructions + .sortedWith( + String.comparator(), + ).forEach { value -> + writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + } + writer.writeCompact(instance.permissions.size) + instance.permissions + .sortedWith( + String.comparator(), + ).forEach { value -> + writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + } + Json.write(writer, instance.schema) + } catch (ex: Exception) { + throw wrapException(ex) } - writer.writeAsList(instance.schema.toByteArray(Charsets.UTF_8)) - } 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..61866ad27 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 @@ -36,38 +36,43 @@ public sealed class ExecutorEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutorEvent.Upgraded = try { - Upgraded( - ExecutorUpgrade.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ExecutorEvent.Upgraded = + try { + Upgraded( + ExecutorUpgrade.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ExecutorUpgrade.write(writer, instance.executorUpgrade) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: ExecutorEvent) { + 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..a05099e85 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 @@ -20,18 +20,23 @@ public data class ExecutorEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ExecutorEventFilter = try { - ExecutorEventFilter( - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ExecutorEventFilter = + try { + ExecutorEventFilter( + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ExecutorEventFilter): Unit = try { - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ExecutorEventFilter, + ): Unit = + try { + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..772e709de 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 @@ -19,18 +19,23 @@ public data class ExecutorUpgrade( public val newDataModel: ExecutorDataModel, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ExecutorUpgrade = try { - ExecutorUpgrade( - ExecutorDataModel.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ExecutorUpgrade = + try { + ExecutorUpgrade( + ExecutorDataModel.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ExecutorUpgrade): Unit = try { - ExecutorDataModel.write(writer, instance.newDataModel) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ExecutorUpgrade, + ): Unit = + try { + ExecutorDataModel.write(writer, instance.newDataModel) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f037c4d4d 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 @@ -16,21 +16,26 @@ import kotlin.Unit * Generated from 'FetchSize' regular structure */ public data class FetchSize( - public val fetchSize: NonZeroOfu32? = null, + public val fetchSize: NonZeroOfu64? = null, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FetchSize = try { - FetchSize( - reader.readNullable(NonZeroOfu32) as NonZeroOfu32?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FetchSize = + try { + FetchSize( + 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) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FetchSize, + ): Unit = + try { + writer.writeNullable(NonZeroOfu64, instance.fetchSize) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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/FindAccountById.kt deleted file mode 100644 index 684034e0a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccountById.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 - -/** - * FindAccountById - * - * Generated from 'FindAccountById' regular structure - */ -public data class FindAccountById( - public val id: AccountId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountById = try { - FindAccountById( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAccountById): Unit = try { - AccountId.write(writer, instance.id) - } 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..8546f0aa1 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 @@ -20,20 +20,25 @@ public data class FindAccountMetadata( public val key: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountMetadata = try { - FindAccountMetadata( - AccountId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAccountMetadata = + try { + FindAccountMetadata( + AccountId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAccountMetadata): Unit = try { - AccountId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAccountMetadata, + ): 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/FindAccounts.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAccounts.kt index f497845e5..41b5b3289 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,25 +16,34 @@ import kotlin.Unit /** * FindAccounts * - * Generated from 'FindAccounts' regular structure + * Generated from 'FindAccounts' tuple structure */ public class FindAccounts { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccounts = try { - FindAccounts() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAccounts = + try { + FindAccounts() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAccounts): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAccounts, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindAccounts, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindAccounts, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindAccounts".hashCode() } 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..b6aefc0e8 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 @@ -19,18 +19,23 @@ public data class FindAccountsWithAsset( public val assetDefinition: AssetDefinitionId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAccountsWithAsset = try { - FindAccountsWithAsset( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAccountsWithAsset = + try { + FindAccountsWithAsset( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAccountsWithAsset): Unit = try { - AssetDefinitionId.write(writer, instance.assetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAccountsWithAsset, + ): 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/FindActiveTriggerIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindActiveTriggerIds.kt index 4c9688a10..fb848d073 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,25 +16,34 @@ import kotlin.Unit /** * FindActiveTriggerIds * - * Generated from 'FindActiveTriggerIds' regular structure + * Generated from 'FindActiveTriggerIds' tuple structure */ public class FindActiveTriggerIds { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindActiveTriggerIds = try { - FindActiveTriggerIds() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindActiveTriggerIds = + try { + FindActiveTriggerIds() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindActiveTriggerIds): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindActiveTriggerIds, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindActiveTriggerIds, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindActiveTriggerIds, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindActiveTriggerIds".hashCode() } 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/FindAllAssets.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssets.kt deleted file mode 100644 index 025e17006..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllAssets.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 - -/** - * FindAllAssets - * - * Generated from 'FindAllAssets' regular structure - */ -public class FindAllAssets { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllAssets = try { - FindAllAssets() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllAssets): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllAssets, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllAssets".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/FindAllBlocks.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlocks.kt deleted file mode 100644 index 1ce79fa0d..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllBlocks.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 - -/** - * FindAllBlocks - * - * Generated from 'FindAllBlocks' regular structure - */ -public class FindAllBlocks { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllBlocks = try { - FindAllBlocks() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllBlocks): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllBlocks, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllBlocks".hashCode() - } -} 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/FindAllDomains.kt deleted file mode 100644 index 0e1b0ade0..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllDomains.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 - -/** - * FindAllDomains - * - * Generated from 'FindAllDomains' regular structure - */ -public class FindAllDomains { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllDomains = try { - FindAllDomains() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllDomains): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllDomains, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllDomains".hashCode() - } -} 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/FindAllParameters.kt deleted file mode 100644 index 3cbf81082..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllParameters.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 - -/** - * FindAllParameters - * - * Generated from 'FindAllParameters' regular structure - */ -public class FindAllParameters { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllParameters = try { - FindAllParameters() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllParameters): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllParameters, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllParameters".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/FindAllRoleIds.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoleIds.kt deleted file mode 100644 index c964d9ab4..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAllRoleIds.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 - -/** - * FindAllRoleIds - * - * Generated from 'FindAllRoleIds' regular structure - */ -public class FindAllRoleIds { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAllRoleIds = try { - FindAllRoleIds() - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAllRoleIds): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: FindAllRoleIds, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } - - override fun hashCode(): Int = ".FindAllRoleIds".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/FindAssetById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetById.kt deleted file mode 100644 index e9757c51a..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetById.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 - -/** - * FindAssetById - * - * Generated from 'FindAssetById' 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), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindAssetById): Unit = try { - AssetId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} 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..db171cfd1 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 @@ -22,20 +22,25 @@ public data class FindAssetDefinitionMetadata( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetDefinitionMetadata = try { - FindAssetDefinitionMetadata( - AssetDefinitionId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAssetDefinitionMetadata = + try { + FindAssetDefinitionMetadata( + AssetDefinitionId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAssetDefinitionMetadata): Unit = try { - AssetDefinitionId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAssetDefinitionMetadata, + ): 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/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..e4652360b 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 @@ -20,20 +20,25 @@ public data class FindAssetMetadata( public val key: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetMetadata = try { - FindAssetMetadata( - AssetId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAssetMetadata = + try { + FindAssetMetadata( + AssetId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAssetMetadata): Unit = try { - AssetId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAssetMetadata, + ): 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/FindAssetQuantityById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindAssetQuantityById.kt index bc6c76a13..1b3f6e1d2 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 @@ -19,18 +19,23 @@ public data class FindAssetQuantityById( public val id: AssetId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetQuantityById = try { - FindAssetQuantityById( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAssetQuantityById = + try { + FindAssetQuantityById( + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAssetQuantityById): Unit = try { - AssetId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAssetQuantityById, + ): Unit = + try { + AssetId.write(writer, instance.id) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..5c1660add 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,25 +16,34 @@ import kotlin.Unit /** * FindAssets * - * Generated from 'FindAssets' regular structure + * Generated from 'FindAssets' tuple structure */ public class FindAssets { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssets = try { - FindAssets() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAssets = + try { + FindAssets() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAssets): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAssets, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindAssets, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindAssets, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindAssets".hashCode() } 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..27937b871 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,25 +16,34 @@ import kotlin.Unit /** * FindAssetsDefinitions * - * Generated from 'FindAssetsDefinitions' regular structure + * Generated from 'FindAssetsDefinitions' tuple structure */ public class FindAssetsDefinitions { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindAssetsDefinitions = try { - FindAssetsDefinitions() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindAssetsDefinitions = + try { + FindAssetsDefinitions() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindAssetsDefinitions): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindAssetsDefinitions, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindAssetsDefinitions, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindAssetsDefinitions, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindAssetsDefinitions".hashCode() } 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..bf0f7608e 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,25 +16,34 @@ import kotlin.Unit /** * FindBlockHeaders * - * Generated from 'FindBlockHeaders' regular structure + * Generated from 'FindBlockHeaders' tuple structure */ public class FindBlockHeaders { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindBlockHeaders = try { - FindBlockHeaders() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindBlockHeaders = + try { + FindBlockHeaders() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindBlockHeaders): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindBlockHeaders, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindBlockHeaders, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindBlockHeaders, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindBlockHeaders".hashCode() } 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..2659055a2 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,25 +16,34 @@ import kotlin.Unit /** * FindBlocks * - * Generated from 'FindBlocks' regular structure + * Generated from 'FindBlocks' tuple structure */ public class FindBlocks { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindBlocks = try { - FindBlocks() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindBlocks = + try { + FindBlocks() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindBlocks): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindBlocks, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindBlocks, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindBlocks, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindBlocks".hashCode() } 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/FindDomainById.kt deleted file mode 100644 index f2043fecb..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomainById.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 - -/** - * FindDomainById - * - * Generated from 'FindDomainById' 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), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindDomainById): Unit = try { - DomainId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } - } -} 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..13bd8bc4a 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 @@ -20,20 +20,25 @@ public data class FindDomainMetadata( public val key: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindDomainMetadata = try { - FindDomainMetadata( - DomainId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindDomainMetadata = + try { + FindDomainMetadata( + DomainId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindDomainMetadata): Unit = try { - DomainId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindDomainMetadata, + ): 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/FindDomains.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindDomains.kt index f38ee835e..092f18781 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,25 +16,34 @@ import kotlin.Unit /** * FindDomains * - * Generated from 'FindDomains' regular structure + * Generated from 'FindDomains' tuple structure */ public class FindDomains { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindDomains = try { - FindDomains() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindDomains = + try { + FindDomains() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindDomains): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindDomains, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindDomains, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindDomains, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindDomains".hashCode() } 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..ba2ee86b4 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 @@ -36,22 +36,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Asset = try { - Asset( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Asset = + try { + Asset( + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetId.write(writer, instance.assetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.AssetDefinition = try { - AssetDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.AssetDefinition = + try { + AssetDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetDefinitionId.write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Account = try { - Account( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Account = + try { + Account( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AccountId.write(writer, instance.accountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Domain = try { - Domain( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Domain = + try { + Domain( + DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + DomainId.write(writer, instance.domainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.MetadataKey = try { - MetadataKey( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.MetadataKey = + try { + MetadataKey( + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Name.write(writer, instance.name) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Block = try { - Block( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Block = + try { + Block( + HashOf.read(reader) as HashOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + HashOf.write(writer, instance.hashOf) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,22 +240,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Transaction = try { - Transaction( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Transaction = + try { + Transaction( + HashOf.read(reader) as HashOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + HashOf.write(writer, instance.hashOf) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -272,11 +286,12 @@ public sealed class FindError : ModelEnum { 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) - } + ): Unit = + try { + PeerId.write(writer, instance.peerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -293,22 +308,24 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Trigger = try { - Trigger( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Trigger = + try { + Trigger( + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerId.write(writer, instance.triggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -337,11 +354,12 @@ public sealed class FindError : ModelEnum { 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) - } + ): Unit = + try { + RoleId.write(writer, instance.roleId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -358,22 +376,26 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 10 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.Permission = try { - Permission( - jp.co.soramitsu.iroha2.generated.Permission.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.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.FindError.Permission, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Permission.write(writer, instance.permission) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Permission + .write(writer, instance.permission) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -390,45 +412,51 @@ public sealed class FindError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 11 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.PublicKey = try { - PublicKey( - jp.co.soramitsu.iroha2.generated.PublicKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.FindError.PublicKey = + try { + PublicKey( + 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.FindError.PublicKey, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.PublicKey.write(writer, instance.publicKey) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.PublicKey + .write(writer, instance.publicKey) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> Domain.read(reader) + 4 -> MetadataKey.read(reader) + 5 -> Block.read(reader) + 6 -> Transaction.read(reader) + 7 -> Peer.read(reader) + 8 -> Trigger.read(reader) + 9 -> Role.read(reader) + 10 -> Permission.read(reader) + 11 -> PublicKey.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: FindError, ) { - 0 -> Asset.read(reader) - 1 -> AssetDefinition.read(reader) - 2 -> Account.read(reader) - 3 -> Domain.read(reader) - 4 -> MetadataKey.read(reader) - 5 -> Block.read(reader) - 6 -> Transaction.read(reader) - 7 -> Peer.read(reader) - 8 -> Trigger.read(reader) - 9 -> Role.read(reader) - 10 -> Permission.read(reader) - 11 -> PublicKey.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: FindError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Asset.write(writer, instance as Asset) @@ -443,7 +471,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..0ed652ecd 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,25 +16,34 @@ import kotlin.Unit /** * FindExecutorDataModel * - * Generated from 'FindExecutorDataModel' regular structure + * Generated from 'FindExecutorDataModel' tuple structure */ public class FindExecutorDataModel { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindExecutorDataModel = try { - FindExecutorDataModel() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindExecutorDataModel = + try { + FindExecutorDataModel() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindExecutorDataModel): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindExecutorDataModel, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindExecutorDataModel, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindExecutorDataModel, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindExecutorDataModel".hashCode() } 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..41fffbcd5 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,25 +16,34 @@ import kotlin.Unit /** * FindParameters * - * Generated from 'FindParameters' regular structure + * Generated from 'FindParameters' tuple structure */ public class FindParameters { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindParameters = try { - FindParameters() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindParameters = + try { + FindParameters() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindParameters): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindParameters, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindParameters, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindParameters, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindParameters".hashCode() } 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..2cbd56b00 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,25 +16,34 @@ import kotlin.Unit /** * FindPeers * - * Generated from 'FindPeers' regular structure + * Generated from 'FindPeers' tuple structure */ public class FindPeers { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindPeers = try { - FindPeers() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindPeers = + try { + FindPeers() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindPeers): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindPeers, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindPeers, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindPeers, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindPeers".hashCode() } 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..af37ef9d2 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 @@ -21,18 +21,23 @@ public data class FindPermissionsByAccountId( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindPermissionsByAccountId = try { - FindPermissionsByAccountId( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindPermissionsByAccountId = + try { + FindPermissionsByAccountId( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindPermissionsByAccountId): Unit = try { - AccountId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindPermissionsByAccountId, + ): Unit = + try { + AccountId.write(writer, instance.id) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..cca8e1916 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,25 +16,34 @@ import kotlin.Unit /** * FindRoleIds * - * Generated from 'FindRoleIds' regular structure + * Generated from 'FindRoleIds' tuple structure */ public class FindRoleIds { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindRoleIds = try { - FindRoleIds() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindRoleIds = + try { + FindRoleIds() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindRoleIds): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindRoleIds, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindRoleIds, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindRoleIds, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindRoleIds".hashCode() } 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..2e3a9802a 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,25 +16,34 @@ import kotlin.Unit /** * FindRoles * - * Generated from 'FindRoles' regular structure + * Generated from 'FindRoles' tuple structure */ public class FindRoles { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindRoles = try { - FindRoles() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindRoles = + try { + FindRoles() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindRoles): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindRoles, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindRoles, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindRoles, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindRoles".hashCode() } 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..afde5c706 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 @@ -19,18 +19,23 @@ public data class FindRolesByAccountId( public val id: AccountId, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindRolesByAccountId = try { - FindRolesByAccountId( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindRolesByAccountId = + try { + FindRolesByAccountId( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindRolesByAccountId): Unit = try { - AccountId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindRolesByAccountId, + ): Unit = + try { + AccountId.write(writer, instance.id) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..8e3b17b83 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,25 +16,34 @@ import kotlin.Unit /** * FindTransactions * - * Generated from 'FindTransactions' regular structure + * Generated from 'FindTransactions' tuple structure */ public class FindTransactions { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTransactions = try { - FindTransactions() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindTransactions = + try { + FindTransactions() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindTransactions): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindTransactions, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindTransactions, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindTransactions, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindTransactions".hashCode() } 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/FindTriggerById.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerById.kt deleted file mode 100644 index 62bcc12a0..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggerById.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 - -/** - * FindTriggerById - * - * Generated from 'FindTriggerById' regular structure - */ -public data class FindTriggerById( - public val id: TriggerId, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggerById = try { - FindTriggerById( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write(writer: ScaleCodecWriter, instance: FindTriggerById): Unit = try { - TriggerId.write(writer, instance.id) - } 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..c821d9b1d 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 @@ -20,20 +20,25 @@ public data class FindTriggerMetadata( public val key: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggerMetadata = try { - FindTriggerMetadata( - TriggerId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindTriggerMetadata = + try { + FindTriggerMetadata( + TriggerId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindTriggerMetadata): Unit = try { - TriggerId.write(writer, instance.id) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindTriggerMetadata, + ): 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/FindTriggers.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/FindTriggers.kt index 1c6f355f8..90db7971b 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,25 +16,34 @@ import kotlin.Unit /** * FindTriggers * - * Generated from 'FindTriggers' regular structure + * Generated from 'FindTriggers' tuple structure */ public class FindTriggers { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): FindTriggers = try { - FindTriggers() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): FindTriggers = + try { + FindTriggers() + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: FindTriggers): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: FindTriggers, + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } - public fun equals(o1: FindTriggers, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: FindTriggers, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".FindTriggers".hashCode() } 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..8e23c94ba 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 @@ -17,24 +17,29 @@ import kotlin.Unit * Generated from 'ForwardCursor' regular structure */ public data class ForwardCursor( - public val query: String? = null, - public val cursor: NonZeroOfu64? = null, + 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?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ForwardCursor = + try { + ForwardCursor( + 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) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ForwardCursor, + ): Unit = + try { + 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..b802944df --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmAction.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.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/GenesisWasmTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmTrigger.kt new file mode 100644 index 000000000..7d303e475 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/GenesisWasmTrigger.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 + +/** + * GenesisWasmTrigger + * + * Generated from 'GenesisWasmTrigger' regular structure + */ +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: 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..75d5e89bc 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 @@ -36,22 +36,24 @@ public sealed class GrantBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.Permission = try { - Permission( - GrantOfPermissionAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.Permission = + try { + Permission( + GrantOfPermissionAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + GrantOfPermissionAndAccount.write(writer, instance.grantOfPermissionAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -80,11 +82,12 @@ public sealed class GrantBox : ModelEnum { 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) - } + ): Unit = + try { + GrantOfRoleIdAndAccount.write(writer, instance.grantOfRoleIdAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,42 +104,47 @@ public sealed class GrantBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.RolePermission = try { - RolePermission( - GrantOfPermissionAndRole.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.GrantBox.RolePermission = + try { + RolePermission( + GrantOfPermissionAndRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + GrantOfPermissionAndRole.write(writer, instance.grantOfPermissionAndRole) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: GrantBox) { + override fun write( + writer: ScaleCodecWriter, + instance: GrantBox, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..c212019b1 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class GrantOfPermissionAndAccount( public val `object`: Permission, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): GrantOfPermissionAndAccount = try { - GrantOfPermissionAndAccount( - Permission.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): GrantOfPermissionAndAccount = + try { + GrantOfPermissionAndAccount( + Permission.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: GrantOfPermissionAndAccount): Unit = try { - Permission.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: GrantOfPermissionAndAccount, + ): Unit = + try { + Permission.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..632552e41 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class GrantOfPermissionAndRole( public val `object`: Permission, public val destination: RoleId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): GrantOfPermissionAndRole = try { - GrantOfPermissionAndRole( - Permission.read(reader), - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): GrantOfPermissionAndRole = + try { + GrantOfPermissionAndRole( + Permission.read(reader), + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: GrantOfPermissionAndRole): Unit = try { - Permission.write(writer, instance.`object`) - RoleId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: GrantOfPermissionAndRole, + ): Unit = + try { + Permission.write(writer, instance.`object`) + RoleId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f0c586084 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class GrantOfRoleIdAndAccount( public val `object`: RoleId, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): GrantOfRoleIdAndAccount = try { - GrantOfRoleIdAndAccount( - RoleId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): GrantOfRoleIdAndAccount = + try { + GrantOfRoleIdAndAccount( + RoleId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: GrantOfRoleIdAndAccount): Unit = try { - RoleId.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: GrantOfRoleIdAndAccount, + ): Unit = + try { + RoleId.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..6a9bc83df 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 @@ -32,18 +32,23 @@ public data class Hash( override fun hashCode(): Int = arrayOfU8.contentHashCode() public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Hash = try { - Hash( - reader.readByteArray(32), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Hash = + try { + Hash( + reader.readByteArray(32), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Hash): Unit = try { - writer.writeByteArray(instance.arrayOfU8) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Hash, + ): Unit = + try { + writer.writeByteArray(instance.arrayOfU8) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..c8420ea58 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,24 +14,29 @@ import kotlin.Unit /** * HashOf * - * Generated from 'HashOf' regular structure + * Generated from 'HashOf>' regular structure */ public data class HashOf( public val hash: Hash, ) { public companion object : ScaleReader>, ScaleWriter> { - override fun read(reader: ScaleCodecReader): HashOf = try { - HashOf( - Hash.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): HashOf = + try { + HashOf( + Hash.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: HashOf): Unit = try { - Hash.write(writer, instance.hash) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: HashOf, + ): Unit = + try { + Hash.write(writer, instance.hash) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..180138ff3 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 @@ -39,7 +39,8 @@ public sealed class IdBox : ModelEnum { override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.DomainId = try { DomainId( - jp.co.soramitsu.iroha2.generated.DomainId.read(reader), + jp.co.soramitsu.iroha2.generated.DomainId + .read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -48,11 +49,13 @@ public sealed class IdBox : ModelEnum { 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.DomainId + .write(writer, instance.domainId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,22 +72,26 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AccountId = try { - AccountId( - jp.co.soramitsu.iroha2.generated.AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AccountId = + try { + AccountId( + 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.IdBox.AccountId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.AccountId.write(writer, instance.accountId) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.AccountId + .write(writer, instance.accountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,22 +108,26 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AssetDefinitionId = try { - AssetDefinitionId( - jp.co.soramitsu.iroha2.generated.AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AssetDefinitionId = + try { + AssetDefinitionId( + 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.IdBox.AssetDefinitionId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.AssetDefinitionId.write(writer, instance.assetDefinitionId) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.AssetDefinitionId + .write(writer, instance.assetDefinitionId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -136,7 +147,8 @@ public sealed class IdBox : ModelEnum { override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.AssetId = try { AssetId( - jp.co.soramitsu.iroha2.generated.AssetId.read(reader), + jp.co.soramitsu.iroha2.generated.AssetId + .read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -145,11 +157,13 @@ public sealed class IdBox : ModelEnum { 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.AssetId + .write(writer, instance.assetId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -169,7 +183,8 @@ public sealed class IdBox : ModelEnum { override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.PeerId = try { PeerId( - jp.co.soramitsu.iroha2.generated.PeerId.read(reader), + jp.co.soramitsu.iroha2.generated.PeerId + .read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -178,11 +193,13 @@ public sealed class IdBox : ModelEnum { 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.PeerId + .write(writer, instance.peerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -199,22 +216,26 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.TriggerId = try { - TriggerId( - jp.co.soramitsu.iroha2.generated.TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.TriggerId = + try { + TriggerId( + jp.co.soramitsu.iroha2.generated.TriggerId + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.TriggerId + .write(writer, instance.triggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -234,7 +255,8 @@ public sealed class IdBox : ModelEnum { override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.RoleId = try { RoleId( - jp.co.soramitsu.iroha2.generated.RoleId.read(reader), + jp.co.soramitsu.iroha2.generated.RoleId + .read(reader), ) } catch (ex: Exception) { throw wrapException(ex) @@ -243,11 +265,13 @@ public sealed class IdBox : ModelEnum { 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.RoleId + .write(writer, instance.roleId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -264,22 +288,26 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.Permission = try { - Permission( - jp.co.soramitsu.iroha2.generated.Permission.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.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.IdBox.Permission, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Permission.write(writer, instance.permission) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Permission + .write(writer, instance.permission) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -296,39 +324,48 @@ public sealed class IdBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.CustomParameterId = try { - CustomParameterId( - jp.co.soramitsu.iroha2.generated.CustomParameterId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.IdBox.CustomParameterId = + try { + CustomParameterId( + jp.co.soramitsu.iroha2.generated.CustomParameterId + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.CustomParameterId + .write(writer, instance.customParameterId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): IdBox = when (val discriminant = reader.readUByte()) { - 0 -> DomainId.read(reader) - 1 -> AccountId.read(reader) - 2 -> AssetDefinitionId.read(reader) - 3 -> AssetId.read(reader) - 4 -> PeerId.read(reader) - 5 -> TriggerId.read(reader) - 6 -> RoleId.read(reader) - 7 -> Permission.read(reader) - 8 -> CustomParameterId.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: IdBox) { + override fun read(reader: ScaleCodecReader): IdBox = + when (val discriminant = reader.readUByte()) { + 0 -> DomainId.read(reader) + 1 -> AccountId.read(reader) + 2 -> AssetDefinitionId.read(reader) + 3 -> AssetId.read(reader) + 4 -> PeerId.read(reader) + 5 -> TriggerId.read(reader) + 6 -> RoleId.read(reader) + 7 -> Permission.read(reader) + 8 -> CustomParameterId.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: IdBox, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> DomainId.write(writer, instance as DomainId) @@ -340,7 +377,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..7a85e9410 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 @@ -36,22 +36,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Register = try { - Register( - RegisterBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Register = + try { + Register( + RegisterBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterBox.write(writer, instance.registerBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Unregister = try { - Unregister( - UnregisterBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Unregister = + try { + Unregister( + UnregisterBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterBox.write(writer, instance.unregisterBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Mint = try { - Mint( - MintBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Mint = + try { + Mint( + MintBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + MintBox.write(writer, instance.mintBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Burn = try { - Burn( - BurnBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Burn = + try { + Burn( + BurnBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + BurnBox.write(writer, instance.burnBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Transfer = try { - Transfer( - TransferBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Transfer = + try { + Transfer( + TransferBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TransferBox.write(writer, instance.transferBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.SetKeyValue = try { - SetKeyValue( - SetKeyValueBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.SetKeyValue = + try { + SetKeyValue( + SetKeyValueBox.read(reader), + ) + } 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) - } + ): Unit = + try { + SetKeyValueBox.write(writer, instance.setKeyValueBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,22 +240,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.RemoveKeyValue = try { - RemoveKeyValue( - RemoveKeyValueBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.RemoveKeyValue = + try { + RemoveKeyValue( + RemoveKeyValueBox.read(reader), + ) + } 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) - } + ): Unit = + try { + RemoveKeyValueBox.write(writer, instance.removeKeyValueBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -260,22 +274,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Grant = try { - Grant( - GrantBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Grant = + try { + Grant( + GrantBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + GrantBox.write(writer, instance.grantBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -292,22 +308,24 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Revoke = try { - Revoke( - RevokeBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Revoke = + try { + Revoke( + RevokeBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RevokeBox.write(writer, instance.revokeBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -324,22 +342,26 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 9 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.ExecuteTrigger = try { - ExecuteTrigger( - jp.co.soramitsu.iroha2.generated.ExecuteTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.ExecuteTrigger = + try { + ExecuteTrigger( + jp.co.soramitsu.iroha2.generated.ExecuteTrigger + .read(reader), + ) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.ExecuteTrigger + .write(writer, instance.executeTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -356,22 +378,26 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 10 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.SetParameter = try { - SetParameter( - jp.co.soramitsu.iroha2.generated.SetParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.SetParameter = + try { + SetParameter( + jp.co.soramitsu.iroha2.generated.SetParameter + .read(reader), + ) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.SetParameter + .write(writer, instance.setParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -388,22 +414,26 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 11 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Upgrade = try { - Upgrade( - jp.co.soramitsu.iroha2.generated.Upgrade.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Upgrade = + try { + Upgrade( + jp.co.soramitsu.iroha2.generated.Upgrade + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Upgrade + .write(writer, instance.upgrade) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -420,22 +450,26 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 12 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Log = try { - Log( - jp.co.soramitsu.iroha2.generated.Log.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Log = + try { + Log( + jp.co.soramitsu.iroha2.generated.Log + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Log + .write(writer, instance.log) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -452,47 +486,51 @@ public sealed class InstructionBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 13 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Custom = try { - Custom( - CustomInstruction.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionBox.Custom = + try { + Custom( + CustomInstruction.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + CustomInstruction.write(writer, instance.customInstruction) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> Burn.read(reader) + 4 -> Transfer.read(reader) + 5 -> SetKeyValue.read(reader) + 6 -> RemoveKeyValue.read(reader) + 7 -> Grant.read(reader) + 8 -> Revoke.read(reader) + 9 -> ExecuteTrigger.read(reader) + 10 -> SetParameter.read(reader) + 11 -> Upgrade.read(reader) + 12 -> Log.read(reader) + 13 -> Custom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: InstructionBox, ) { - 0 -> Register.read(reader) - 1 -> Unregister.read(reader) - 2 -> Mint.read(reader) - 3 -> Burn.read(reader) - 4 -> Transfer.read(reader) - 5 -> SetKeyValue.read(reader) - 6 -> RemoveKeyValue.read(reader) - 7 -> Grant.read(reader) - 8 -> Revoke.read(reader) - 9 -> ExecuteTrigger.read(reader) - 10 -> SetParameter.read(reader) - 11 -> Upgrade.read(reader) - 12 -> Log.read(reader) - 13 -> Custom.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: InstructionBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Register.write(writer, instance as Register) @@ -509,7 +547,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..289709aff 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 @@ -37,13 +37,14 @@ public sealed class InstructionEvaluationError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Unsupported = try { - Unsupported( - InstructionType.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Unsupported = + try { + Unsupported( + InstructionType.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -70,22 +71,24 @@ 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, instance: jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.PermissionParameter, - ): 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) + } } } @@ -102,44 +105,49 @@ public sealed class InstructionEvaluationError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Type = try { - Type( - TypeError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionEvaluationError.Type = + try { + Type( + TypeError.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Unsupported.read(reader) - 1 -> PermissionParameter.read(reader) - 2 -> Type.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: InstructionEvaluationError) { + override fun write( + writer: ScaleCodecWriter, + instance: InstructionEvaluationError, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..690304176 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 @@ -37,22 +37,24 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Evaluate = try { - Evaluate( - InstructionEvaluationError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Evaluate = + try { + Evaluate( + InstructionEvaluationError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Evaluate, - ): Unit = try { - InstructionEvaluationError.write(writer, instance.instructionEvaluationError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + InstructionEvaluationError.write(writer, instance.instructionEvaluationError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,22 +71,24 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Query = try { - Query( - QueryExecutionFail.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Query = + try { + Query( + QueryExecutionFail.read(reader), + ) + } 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) - } + ): Unit = + try { + QueryExecutionFail.write(writer, instance.queryExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,13 +105,14 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Conversion = try { - Conversion( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Conversion = + try { + Conversion( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -134,22 +139,24 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Find = try { - Find( - FindError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Find = + try { + Find( + FindError.read(reader), + ) + } 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) - } + ): Unit = + try { + FindError.write(writer, instance.findError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -166,13 +173,14 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Repetition = try { - Repetition( - RepetitionError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Repetition = + try { + Repetition( + RepetitionError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -199,13 +207,14 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Mintability = try { - Mintability( - MintabilityError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Mintability = + try { + Mintability( + MintabilityError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -232,22 +241,24 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Math = try { - Math( - MathError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.Math = + try { + Math( + MathError.read(reader), + ) + } 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) - } + ): Unit = + try { + MathError.write(writer, instance.mathError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -264,22 +275,24 @@ public sealed class InstructionExecutionError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvalidParameter = try { - InvalidParameter( - InvalidParameterError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvalidParameter = + try { + InvalidParameter( + InvalidParameterError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvalidParameter, - ): Unit = try { - InvalidParameterError.write(writer, instance.invalidParameterError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + InvalidParameterError.write(writer, instance.invalidParameterError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -296,44 +309,48 @@ 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, instance: jp.co.soramitsu.iroha2.generated.InstructionExecutionError.InvariantViolation, - ): 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) + } } } 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) + 3 -> Find.read(reader) + 4 -> Repetition.read(reader) + 5 -> Mintability.read(reader) + 6 -> Math.read(reader) + 7 -> InvalidParameter.read(reader) + 8 -> InvariantViolation.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: InstructionExecutionError, ) { - 0 -> Evaluate.read(reader) - 1 -> Query.read(reader) - 2 -> Conversion.read(reader) - 3 -> Find.read(reader) - 4 -> Repetition.read(reader) - 5 -> Mintability.read(reader) - 6 -> Math.read(reader) - 7 -> InvalidParameter.read(reader) - 8 -> InvariantViolation.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: InstructionExecutionError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Evaluate.write(writer, instance as Evaluate) @@ -345,7 +362,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..99cb659d3 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 @@ -23,20 +23,25 @@ public data class InstructionExecutionFail( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): InstructionExecutionFail = try { - InstructionExecutionFail( - InstructionBox.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): InstructionExecutionFail = + try { + InstructionExecutionFail( + InstructionBox.read(reader), + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: InstructionExecutionFail): Unit = try { - InstructionBox.write(writer, instance.instruction) - writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: InstructionExecutionFail, + ): Unit = + try { + InstructionBox.write(writer, instance.instruction) + writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f0fea6067 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 @@ -25,39 +25,43 @@ public sealed class InstructionType : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Register -> Register.equals(this, other) - is Unregister -> Unregister.equals(this, other) - is Mint -> Mint.equals(this, other) - is Burn -> Burn.equals(this, other) - is Transfer -> Transfer.equals(this, other) - is SetKeyValue -> SetKeyValue.equals(this, other) - is RemoveKeyValue -> RemoveKeyValue.equals(this, other) - is Grant -> Grant.equals(this, other) - is Revoke -> Revoke.equals(this, other) - is ExecuteTrigger -> ExecuteTrigger.equals(this, other) - is SetParameter -> SetParameter.equals(this, other) - is Upgrade -> Upgrade.equals(this, other) - is Log -> Log.equals(this, other) - is Custom -> Custom.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is Register -> Register.hashCode() - is Unregister -> Unregister.hashCode() - is Mint -> Mint.hashCode() - is Burn -> Burn.hashCode() - is Transfer -> Transfer.hashCode() - is SetKeyValue -> SetKeyValue.hashCode() - is RemoveKeyValue -> RemoveKeyValue.hashCode() - is Grant -> Grant.hashCode() - is Revoke -> Revoke.hashCode() - is ExecuteTrigger -> ExecuteTrigger.hashCode() - is SetParameter -> SetParameter.hashCode() - is Upgrade -> Upgrade.hashCode() - is Log -> Log.hashCode() - is Custom -> Custom.hashCode() - else -> super.hashCode() } + override fun equals(other: Any?): Boolean = + when (this) { + is Register -> Register.equals(this, other) + is Unregister -> Unregister.equals(this, other) + is Mint -> Mint.equals(this, other) + is Burn -> Burn.equals(this, other) + is Transfer -> Transfer.equals(this, other) + is SetKeyValue -> SetKeyValue.equals(this, other) + is RemoveKeyValue -> RemoveKeyValue.equals(this, other) + is Grant -> Grant.equals(this, other) + is Revoke -> Revoke.equals(this, other) + is ExecuteTrigger -> ExecuteTrigger.equals(this, other) + is SetParameter -> SetParameter.equals(this, other) + is Upgrade -> Upgrade.equals(this, other) + is Log -> Log.equals(this, other) + is Custom -> Custom.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = + when (this) { + is Register -> Register.hashCode() + is Unregister -> Unregister.hashCode() + is Mint -> Mint.hashCode() + is Burn -> Burn.hashCode() + is Transfer -> Transfer.hashCode() + is SetKeyValue -> SetKeyValue.hashCode() + is RemoveKeyValue -> RemoveKeyValue.hashCode() + is Grant -> Grant.hashCode() + is Revoke -> Revoke.hashCode() + is ExecuteTrigger -> ExecuteTrigger.hashCode() + is SetParameter -> SetParameter.hashCode() + is Upgrade -> Upgrade.hashCode() + is Log -> Log.hashCode() + is Custom -> Custom.hashCode() + else -> super.hashCode() + } /** * 'Register' variant @@ -70,24 +74,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Register = try { - Register() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Register = + try { + Register() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Register, - ): 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.InstructionType.Register, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Register, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Register".hashCode() } @@ -104,24 +114,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Unregister = try { - Unregister() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Unregister = + try { + Unregister() + } 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) - } + ): 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 - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Unregister, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Unregister".hashCode() } @@ -138,24 +154,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Mint = try { - Mint() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Mint = + try { + Mint() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Mint, - ): 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.InstructionType.Mint, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Mint, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Mint".hashCode() } @@ -172,24 +194,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Burn = try { - Burn() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Burn = + try { + Burn() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Burn, - ): 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.InstructionType.Burn, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Burn, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Burn".hashCode() } @@ -206,24 +234,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Transfer = try { - Transfer() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Transfer = + try { + Transfer() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Transfer, - ): 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.InstructionType.Transfer, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Transfer, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Transfer".hashCode() } @@ -240,24 +274,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue = try { - SetKeyValue() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue = + try { + SetKeyValue() + } 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) - } + ): 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 - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.SetKeyValue, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.SetKeyValue".hashCode() } @@ -274,27 +314,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue = try { - RemoveKeyValue() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue = + try { + RemoveKeyValue() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.InstructionType.RemoveKeyValue, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.RemoveKeyValue".hashCode() } @@ -311,24 +354,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 7 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Grant = try { - Grant() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Grant = + try { + Grant() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Grant, - ): 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.InstructionType.Grant, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Grant, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Grant".hashCode() } @@ -345,24 +394,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 8 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Revoke = try { - Revoke() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Revoke = + try { + Revoke() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Revoke, - ): 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.InstructionType.Revoke, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Revoke, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Revoke".hashCode() } @@ -379,27 +434,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 9 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger = try { - ExecuteTrigger() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger = + try { + ExecuteTrigger() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.InstructionType.ExecuteTrigger, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.ExecuteTrigger".hashCode() } @@ -416,27 +474,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 10 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter = try { - SetParameter() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter = + try { + SetParameter() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.InstructionType.SetParameter, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.SetParameter".hashCode() } @@ -453,24 +514,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 11 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade = try { - Upgrade() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade = + try { + Upgrade() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade, - ): 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.InstructionType.Upgrade, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Upgrade, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Upgrade".hashCode() } @@ -487,24 +554,30 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 12 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Log = try { - Log() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Log = + try { + Log() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Log, - ): 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.InstructionType.Log, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Log, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Log".hashCode() } @@ -521,51 +594,59 @@ public sealed class InstructionType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 13 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Custom = try { - Custom() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InstructionType.Custom = + try { + Custom() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InstructionType.Custom, - ): 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.InstructionType.Custom, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.InstructionType.Custom, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".InstructionType.Custom".hashCode() } } 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) + 3 -> Burn.read(reader) + 4 -> Transfer.read(reader) + 5 -> SetKeyValue.read(reader) + 6 -> RemoveKeyValue.read(reader) + 7 -> Grant.read(reader) + 8 -> Revoke.read(reader) + 9 -> ExecuteTrigger.read(reader) + 10 -> SetParameter.read(reader) + 11 -> Upgrade.read(reader) + 12 -> Log.read(reader) + 13 -> Custom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: InstructionType, ) { - 0 -> Register.read(reader) - 1 -> Unregister.read(reader) - 2 -> Mint.read(reader) - 3 -> Burn.read(reader) - 4 -> Transfer.read(reader) - 5 -> SetKeyValue.read(reader) - 6 -> RemoveKeyValue.read(reader) - 7 -> Grant.read(reader) - 8 -> Revoke.read(reader) - 9 -> ExecuteTrigger.read(reader) - 10 -> SetParameter.read(reader) - 11 -> Upgrade.read(reader) - 12 -> Log.read(reader) - 13 -> Custom.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: InstructionType) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Register.write(writer, instance as Register) @@ -582,7 +663,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..2d2c2af75 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 @@ -26,13 +26,17 @@ public sealed class InvalidParameterError : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is TimeTriggerInThePast -> TimeTriggerInThePast.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is TimeTriggerInThePast -> TimeTriggerInThePast.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is TimeTriggerInThePast -> TimeTriggerInThePast.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is TimeTriggerInThePast -> TimeTriggerInThePast.hashCode() + else -> super.hashCode() + } /** * 'Wasm' variant @@ -47,22 +51,24 @@ public sealed class InvalidParameterError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InvalidParameterError.Wasm = try { - Wasm( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InvalidParameterError.Wasm = + try { + Wasm( + reader.readString(), + ) + } 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) - } + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -77,47 +83,53 @@ public sealed class InvalidParameterError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InvalidParameterError.TimeTriggerInThePast = try { - TimeTriggerInThePast() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.InvalidParameterError.TimeTriggerInThePast = + try { + TimeTriggerInThePast() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.InvalidParameterError.TimeTriggerInThePast, - ): 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.InvalidParameterError.TimeTriggerInThePast, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): 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() - ) { - 0 -> Wasm.read(reader) - 1 -> TimeTriggerInThePast.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: InvalidParameterError) { + 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..06f534c32 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 @@ -20,18 +20,23 @@ public data class IpfsPath( public val string: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): IpfsPath = try { - IpfsPath( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): IpfsPath = + try { + IpfsPath( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: IpfsPath): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: IpfsPath, + ): 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/Ipv4Addr.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Ipv4Addr.kt index ff92ed36c..a1d3a6ebe 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 @@ -32,18 +32,23 @@ public data class Ipv4Addr( override fun hashCode(): Int = arrayOfU8.contentHashCode() public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Ipv4Addr = try { - Ipv4Addr( - reader.readByteArray(4), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Ipv4Addr = + try { + Ipv4Addr( + reader.readByteArray(4), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Ipv4Addr): Unit = try { - writer.writeByteArray(instance.arrayOfU8) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Ipv4Addr, + ): Unit = + try { + writer.writeByteArray(instance.arrayOfU8) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..3a48bf855 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 @@ -21,20 +21,25 @@ public data class Ipv6Addr( public val arrayOfU16: Array, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Ipv6Addr = try { - Ipv6Addr( - reader.readArray(8) { reader.readUint16() }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Ipv6Addr = + try { + Ipv6Addr( + reader.readArray(8) { reader.readUint16() }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Ipv6Addr): Unit = try { - instance.arrayOfU16.forEach { value -> - writer.writeUint16(value) + override fun write( + writer: ScaleCodecWriter, + instance: Ipv6Addr, + ): Unit = + try { + instance.arrayOfU16.forEach { value -> + writer.writeUint16(value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.kt new file mode 100644 index 000000000..7a0b5a21e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Json.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.String +import kotlin.Unit + +/** + * Json + * + * Generated from 'Json' regular structure + */ +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: 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..938f827de --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonPredicateAtom.kt @@ -0,0 +1,78 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Int +import kotlin.Unit + +/** + * JsonPredicateAtom + * + * Generated from 'JsonPredicateAtom' enum + */ +public sealed class JsonPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals( + public val json: Json, + ) : JsonPredicateAtom() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonPredicateAtom.Equals = + try { + Equals( + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.JsonPredicateAtom.Equals, + ): Unit = + try { + Json.write(writer, instance.json) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : ScaleReader, ScaleWriter { + override fun read(reader: ScaleCodecReader): JsonPredicateAtom = + when (val discriminant = reader.readUByte()) { + 0 -> Equals.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: JsonPredicateAtom, + ) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Equals.write(writer, instance as Equals) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..86499dafe --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// Auto-generated file. DO NOT EDIT! +// +package jp.co.soramitsu.iroha2.generated + +import jp.co.soramitsu.iroha2.ModelEnum +import jp.co.soramitsu.iroha2.codec.ScaleCodecReader +import jp.co.soramitsu.iroha2.codec.ScaleCodecWriter +import jp.co.soramitsu.iroha2.codec.ScaleReader +import jp.co.soramitsu.iroha2.codec.ScaleWriter +import jp.co.soramitsu.iroha2.wrapException +import kotlin.Int +import kotlin.Unit + +/** + * JsonProjectionOfPredicateMarker + * + * Generated from 'JsonProjectionOfPredicateMarker' enum + */ +public sealed class JsonProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val jsonPredicateAtom: JsonPredicateAtom, + ) : JsonProjectionOfPredicateMarker() { + override fun discriminant(): Int = DISCRIMINANT + + public companion object : + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 0 + + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom = + try { + Atom( + JsonPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.JsonProjectionOfPredicateMarker.Atom, + ): Unit = + try { + JsonPredicateAtom.write(writer, instance.jsonPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): JsonProjectionOfPredicateMarker = + when (val discriminant = reader.readUByte()) { + 0 -> Atom.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: JsonProjectionOfPredicateMarker, + ) { + writer.directWrite(instance.discriminant()) + when (val discriminant = instance.discriminant()) { + 0 -> Atom.write(writer, instance as Atom) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + } + } +} diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..9ffaf8e0c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/JsonProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..88567821e 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 @@ -25,21 +25,25 @@ public sealed class Level : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is TRACE -> TRACE.equals(this, other) - is DEBUG -> DEBUG.equals(this, other) - is INFO -> INFO.equals(this, other) - is WARN -> WARN.equals(this, other) - is ERROR -> ERROR.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is TRACE -> TRACE.hashCode() - is DEBUG -> DEBUG.hashCode() - is INFO -> INFO.hashCode() - is WARN -> WARN.hashCode() - is ERROR -> ERROR.hashCode() - else -> super.hashCode() } + override fun equals(other: Any?): Boolean = + when (this) { + is TRACE -> TRACE.equals(this, other) + is DEBUG -> DEBUG.equals(this, other) + is INFO -> INFO.equals(this, other) + is WARN -> WARN.equals(this, other) + is ERROR -> ERROR.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = + when (this) { + is TRACE -> TRACE.hashCode() + is DEBUG -> DEBUG.hashCode() + is INFO -> INFO.hashCode() + is WARN -> WARN.hashCode() + is ERROR -> ERROR.hashCode() + else -> super.hashCode() + } /** * 'TRACE' variant @@ -62,16 +66,20 @@ public sealed class Level : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.TRACE, - ): 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.Level.TRACE, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Level.TRACE, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Level.TRACE".hashCode() } @@ -98,16 +106,20 @@ public sealed class Level : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.DEBUG, - ): 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.Level.DEBUG, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Level.DEBUG, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Level.DEBUG".hashCode() } @@ -124,25 +136,30 @@ public sealed class Level : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.INFO = try { - INFO() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.INFO = + try { + INFO() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.INFO, - ): 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.Level.INFO, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Level.INFO, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Level.INFO".hashCode() } @@ -159,25 +176,30 @@ public sealed class Level : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.WARN = try { - WARN() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Level.WARN = + try { + WARN() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.WARN, - ): 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.Level.WARN, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Level.WARN, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Level.WARN".hashCode() } @@ -204,31 +226,40 @@ public sealed class Level : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Level.ERROR, - ): 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.Level.ERROR, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Level.ERROR, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Level.ERROR".hashCode() } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Level = when (val discriminant = reader.readUByte()) { - 0 -> TRACE.read(reader) - 1 -> DEBUG.read(reader) - 2 -> INFO.read(reader) - 3 -> WARN.read(reader) - 4 -> ERROR.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: Level) { + override fun read(reader: ScaleCodecReader): Level = + when (val discriminant = reader.readUByte()) { + 0 -> TRACE.read(reader) + 1 -> DEBUG.read(reader) + 2 -> INFO.read(reader) + 3 -> WARN.read(reader) + 4 -> ERROR.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: Level, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> TRACE.write(writer, instance as TRACE) @@ -236,7 +267,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..ad801dcb6 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 @@ -21,20 +21,25 @@ public data class Log( public val msg: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Log = try { - Log( - Level.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Log = + try { + Log( + Level.read(reader), + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Log): Unit = try { - Level.write(writer, instance.level) - writer.writeAsList(instance.msg.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Log, + ): Unit = + try { + Level.write(writer, instance.level) + writer.writeAsList(instance.msg.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b9f0f0cd6 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 @@ -26,23 +26,27 @@ public sealed class MathError : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Overflow -> Overflow.equals(this, other) - is NotEnoughQuantity -> NotEnoughQuantity.equals(this, other) - is DivideByZero -> DivideByZero.equals(this, other) - is NegativeValue -> NegativeValue.equals(this, other) - is DomainViolation -> DomainViolation.equals(this, other) - is Unknown -> Unknown.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is Overflow -> Overflow.hashCode() - is NotEnoughQuantity -> NotEnoughQuantity.hashCode() - is DivideByZero -> DivideByZero.hashCode() - is NegativeValue -> NegativeValue.hashCode() - is DomainViolation -> DomainViolation.hashCode() - is Unknown -> Unknown.hashCode() - else -> super.hashCode() } + override fun equals(other: Any?): Boolean = + when (this) { + is Overflow -> Overflow.equals(this, other) + is NotEnoughQuantity -> NotEnoughQuantity.equals(this, other) + is DivideByZero -> DivideByZero.equals(this, other) + is NegativeValue -> NegativeValue.equals(this, other) + is DomainViolation -> DomainViolation.equals(this, other) + is Unknown -> Unknown.equals(this, other) + else -> super.equals(other) + } + + override fun hashCode(): Int = + when (this) { + is Overflow -> Overflow.hashCode() + is NotEnoughQuantity -> NotEnoughQuantity.hashCode() + is DivideByZero -> DivideByZero.hashCode() + is NegativeValue -> NegativeValue.hashCode() + is DomainViolation -> DomainViolation.hashCode() + is Unknown -> Unknown.hashCode() + else -> super.hashCode() + } /** * 'Overflow' variant @@ -55,24 +59,30 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.Overflow = try { - Overflow() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.Overflow = + try { + Overflow() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.Overflow, - ): 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.MathError.Overflow, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.Overflow, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.Overflow".hashCode() } @@ -89,24 +99,30 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity = try { - NotEnoughQuantity() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity = + try { + NotEnoughQuantity() + } 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) - } + ): 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 - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.NotEnoughQuantity, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.NotEnoughQuantity".hashCode() } @@ -123,24 +139,30 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.DivideByZero = try { - DivideByZero() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.DivideByZero = + try { + DivideByZero() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.DivideByZero, - ): 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.MathError.DivideByZero, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.DivideByZero, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.DivideByZero".hashCode() } @@ -157,24 +179,30 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.NegativeValue = try { - NegativeValue() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.NegativeValue = + try { + NegativeValue() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.NegativeValue, - ): 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.MathError.NegativeValue, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.NegativeValue, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.NegativeValue".hashCode() } @@ -191,24 +219,30 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.DomainViolation = try { - DomainViolation() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.DomainViolation = + try { + DomainViolation() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.DomainViolation, - ): 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.MathError.DomainViolation, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.DomainViolation, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MathError.DomainViolation".hashCode() } @@ -225,21 +259,26 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.Unknown = try { - Unknown() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.Unknown = + try { + Unknown() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.MathError.Unknown, - ): 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.MathError.Unknown, o2: Any?): Boolean = + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.MathError.Unknown, + o2: Any?, + ): Boolean = when (o2) { null -> false else -> o2::class == o1::class @@ -262,40 +301,44 @@ public sealed class MathError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.FixedPointConversion = try { - FixedPointConversion( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MathError.FixedPointConversion = + try { + FixedPointConversion( + reader.readString(), + ) + } 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) - } + ): 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) + 3 -> NegativeValue.read(reader) + 4 -> DomainViolation.read(reader) + 5 -> Unknown.read(reader) + 6 -> FixedPointConversion.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: MathError, ) { - 0 -> Overflow.read(reader) - 1 -> NotEnoughQuantity.read(reader) - 2 -> DivideByZero.read(reader) - 3 -> NegativeValue.read(reader) - 4 -> DomainViolation.read(reader) - 5 -> Unknown.read(reader) - 6 -> FixedPointConversion.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: MathError) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Overflow.write(writer, instance as Overflow) @@ -305,7 +348,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..b27486fc4 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 @@ -19,27 +18,33 @@ import kotlin.collections.Map * Generated from 'Metadata' regular structure */ public data class Metadata( - public val sortedMapOfName: Map, + 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() }), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Metadata = + try { + Metadata( + reader.readMap(reader.readCompactInt(), { Name.read(reader) }, { Json.read(reader) }), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Metadata): Unit = try { - writer.writeCompact(instance.sortedMapOfName.size) - instance.sortedMapOfName.toSortedMap( - Name.comparator(), - ).forEach { (key, value) -> - Name.write(writer, key) - writer.writeAsList(value.toByteArray(Charsets.UTF_8)) + override fun write( + writer: ScaleCodecWriter, + instance: Metadata, + ): Unit = + try { + writer.writeCompact(instance.sortedMapOfName.size) + instance.sortedMapOfName + .toSortedMap( + Name.comparator(), + ).forEach { (key, value) -> + Name.write(writer, key) + Json.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } 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..76b24e352 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,27 +18,32 @@ 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, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataChangedOfAccountId = try { - MetadataChangedOfAccountId( - AccountId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MetadataChangedOfAccountId = + try { + MetadataChangedOfAccountId( + AccountId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MetadataChangedOfAccountId, + ): Unit = + try { + AccountId.write(writer, instance.target) + Name.write(writer, instance.key) + 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..700a4a0d5 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,27 +18,32 @@ 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, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataChangedOfAssetDefinitionId = try { - MetadataChangedOfAssetDefinitionId( - AssetDefinitionId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MetadataChangedOfAssetDefinitionId = + try { + MetadataChangedOfAssetDefinitionId( + AssetDefinitionId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MetadataChangedOfAssetDefinitionId, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.target) + Name.write(writer, instance.key) + 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..c4a845543 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,27 +18,32 @@ 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, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataChangedOfAssetId = try { - MetadataChangedOfAssetId( - AssetId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MetadataChangedOfAssetId = + try { + MetadataChangedOfAssetId( + AssetId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MetadataChangedOfAssetId, + ): Unit = + try { + AssetId.write(writer, instance.target) + Name.write(writer, instance.key) + 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..b9bb64fba 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,27 +18,32 @@ 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, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataChangedOfDomainId = try { - MetadataChangedOfDomainId( - DomainId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MetadataChangedOfDomainId = + try { + MetadataChangedOfDomainId( + DomainId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MetadataChangedOfDomainId, + ): Unit = + try { + DomainId.write(writer, instance.target) + Name.write(writer, instance.key) + 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..e996ea761 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,27 +18,32 @@ 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, ScaleWriter { - override fun read(reader: ScaleCodecReader): MetadataChangedOfTriggerId = try { - MetadataChangedOfTriggerId( - TriggerId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MetadataChangedOfTriggerId = + try { + MetadataChangedOfTriggerId( + TriggerId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MetadataChangedOfTriggerId, + ): Unit = + try { + TriggerId.write(writer, instance.target) + Name.write(writer, instance.key) + 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..b33c0fffe --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfPredicateMarker.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.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..e885b4a34 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataKeyProjectionOfSelectorMarker.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.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 55% 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..b1d8a467c 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,30 @@ 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..15b0c69fd --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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..6d54f06e2 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MetadataProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..3b56fd8c2 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 @@ -48,11 +48,12 @@ public sealed class MintBox : ModelEnum { 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) - } + ): Unit = + try { + MintOfNumericAndAsset.write(writer, instance.mintOfNumericAndAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,40 +70,45 @@ public sealed class MintBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintBox.TriggerRepetitions = try { - TriggerRepetitions( - MintOfu32AndTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintBox.TriggerRepetitions = + try { + TriggerRepetitions( + MintOfu32AndTrigger.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Asset.read(reader) - 1 -> TriggerRepetitions.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: MintBox) { + 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..de2586562 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 @@ -18,22 +21,29 @@ import kotlin.Unit 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( - Numeric.read(reader), - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MintOfNumericAndAsset = + try { + MintOfNumericAndAsset( + Numeric.read(reader), + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: MintOfNumericAndAsset): Unit = try { - Numeric.write(writer, instance.`object`) - AssetId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MintOfNumericAndAsset, + ): Unit = + try { + Numeric.write(writer, instance.`object`) + AssetId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..1da1d2f22 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 @@ -19,22 +22,29 @@ import kotlin.Unit 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( - reader.readUint32(), - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): MintOfu32AndTrigger = + try { + MintOfu32AndTrigger( + reader.readUint32(), + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: MintOfu32AndTrigger): Unit = try { - writer.writeUint32(instance.`object`) - TriggerId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: MintOfu32AndTrigger, + ): Unit = + try { + writer.writeUint32(instance.`object`) + TriggerId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..c19b89cba 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 @@ -25,15 +25,19 @@ public sealed class MintabilityError : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is MintUnmintable -> MintUnmintable.equals(this, other) - is ForbidMintOnMintable -> ForbidMintOnMintable.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is MintUnmintable -> MintUnmintable.equals(this, other) + is ForbidMintOnMintable -> ForbidMintOnMintable.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is MintUnmintable -> MintUnmintable.hashCode() - is ForbidMintOnMintable -> ForbidMintOnMintable.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is MintUnmintable -> MintUnmintable.hashCode() + is ForbidMintOnMintable -> ForbidMintOnMintable.hashCode() + else -> super.hashCode() + } /** * 'MintUnmintable' variant @@ -46,27 +50,30 @@ public sealed class MintabilityError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable = try { - MintUnmintable() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable = + try { + MintUnmintable() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.MintabilityError.MintUnmintable, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MintabilityError.MintUnmintable".hashCode() } @@ -83,11 +90,12 @@ public sealed class MintabilityError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable = try { - ForbidMintOnMintable() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable = + try { + ForbidMintOnMintable() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -101,30 +109,34 @@ public sealed class MintabilityError : ModelEnum { public fun equals( o1: jp.co.soramitsu.iroha2.generated.MintabilityError.ForbidMintOnMintable, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".MintabilityError.ForbidMintOnMintable".hashCode() } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: MintabilityError) { + 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..8f39510c3 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 @@ -25,17 +25,21 @@ public sealed class Mintable : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Infinitely -> Infinitely.equals(this, other) - is Once -> Once.equals(this, other) - is Not -> Not.equals(this, 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() } + override fun equals(other: Any?): Boolean = + when (this) { + is Infinitely -> Infinitely.equals(this, other) + is Once -> Once.equals(this, other) + is Not -> Not.equals(this, 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() + } /** * 'Infinitely' variant @@ -48,24 +52,30 @@ public sealed class Mintable : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Infinitely = try { - Infinitely() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Mintable.Infinitely = + try { + Infinitely() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Infinitely, - ): 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.Mintable.Infinitely, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Mintable.Infinitely, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Mintable.Infinitely".hashCode() } @@ -92,12 +102,16 @@ public sealed class Mintable : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Once, - ): 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.Mintable.Once, o2: Any?): Boolean = + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Mintable.Once, + o2: Any?, + ): Boolean = when (o2) { null -> false else -> o2::class == o1::class @@ -128,38 +142,45 @@ public sealed class Mintable : ModelEnum { override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Mintable.Not, - ): 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.Mintable.Not, o2: Any?): Boolean = when - (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Mintable.Not, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Mintable.Not".hashCode() } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: Mintable) { + override fun write( + writer: ScaleCodecWriter, + instance: Mintable, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..3d1a43acc 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 @@ -21,20 +21,25 @@ public data class Mismatch( public val `actual`: AssetType, ) { public companion object : ScaleReader>, ScaleWriter> { - override fun read(reader: ScaleCodecReader): Mismatch = try { - Mismatch( - AssetType.read(reader), - AssetType.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Mismatch = + try { + Mismatch( + AssetType.read(reader), + AssetType.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Mismatch): Unit = try { - AssetType.write(writer, instance.expected) - AssetType.write(writer, instance.`actual`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Mismatch, + ): Unit = + try { + AssetType.write(writer, instance.expected) + AssetType.write(writer, instance.`actual`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..67922d4ba --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigAccountArgs.kt @@ -0,0 +1,66 @@ +// +// 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..1f0d97ffb --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigApprove.kt @@ -0,0 +1,46 @@ +// +// 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..c849d8818 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigInstructionBox.kt @@ -0,0 +1,152 @@ +// +// 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..d21049072 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigProposalValue.kt @@ -0,0 +1,67 @@ +// +// 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..51624119d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigPropose.kt @@ -0,0 +1,52 @@ +// +// 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..9483366c1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigRegister.kt @@ -0,0 +1,45 @@ +// +// 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..742e73c23 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigSpec.kt @@ -0,0 +1,57 @@ +// +// 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..fded2794e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/MultisigTransactionArgs.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.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..f9d460d2a 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 @@ -20,18 +20,23 @@ public data class Name( public val string: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Name = try { - Name( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Name = + try { + Name( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Name): Unit = try { - writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Name, + ): 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/NameProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..140813db9 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..f5d4e4bce --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NameProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..dd6c489a1 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 @@ -20,20 +20,25 @@ public data class NewAccount( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NewAccount = try { - NewAccount( - AccountId.read(reader), - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NewAccount = + try { + NewAccount( + AccountId.read(reader), + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NewAccount): Unit = try { - AccountId.write(writer, instance.id) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NewAccount, + ): Unit = + try { + AccountId.write(writer, instance.id) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAssetDefinition.kt index 723b7c43c..66c90ad76 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAssetDefinition.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewAssetDefinition.kt @@ -23,26 +23,31 @@ public data class NewAssetDefinition( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NewAssetDefinition = try { - NewAssetDefinition( - AssetDefinitionId.read(reader), - AssetType.read(reader), - Mintable.read(reader), - reader.readNullable(IpfsPath) as IpfsPath?, - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NewAssetDefinition = + try { + NewAssetDefinition( + AssetDefinitionId.read(reader), + AssetType.read(reader), + Mintable.read(reader), + reader.readNullable(IpfsPath) as IpfsPath?, + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NewAssetDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.id) - AssetType.write(writer, instance.type) - Mintable.write(writer, instance.mintable) - writer.writeNullable(IpfsPath, instance.logo) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NewAssetDefinition, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.id) + AssetType.write(writer, instance.type) + Mintable.write(writer, instance.mintable) + writer.writeNullable(IpfsPath, instance.logo) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewDomain.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewDomain.kt index da7638840..dcb8fb755 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewDomain.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewDomain.kt @@ -21,22 +21,27 @@ public data class NewDomain( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NewDomain = try { - NewDomain( - DomainId.read(reader), - reader.readNullable(IpfsPath) as IpfsPath?, - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NewDomain = + try { + NewDomain( + DomainId.read(reader), + reader.readNullable(IpfsPath) as IpfsPath?, + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NewDomain): Unit = try { - DomainId.write(writer, instance.id) - writer.writeNullable(IpfsPath, instance.logo) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NewDomain, + ): Unit = + try { + DomainId.write(writer, instance.id) + writer.writeNullable(IpfsPath, instance.logo) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.kt new file mode 100644 index 000000000..ae93ae460 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NewRole.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 + +/** + * NewRole + * + * Generated from 'NewRole' regular structure + */ +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: 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/NonZeroOfu16.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu16.kt new file mode 100644 index 000000000..cc89623e5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NonZeroOfu16.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.Int +import kotlin.Unit + +/** + * NonZeroOfu16 + * + * Generated from 'NonZeroOfu16' regular structure + */ +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: 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..e28363684 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 @@ -20,18 +20,23 @@ public data class NonZeroOfu32( public val u32: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NonZeroOfu32 = try { - NonZeroOfu32( - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NonZeroOfu32 = + try { + NonZeroOfu32( + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NonZeroOfu32): Unit = try { - writer.writeUint32(instance.u32) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NonZeroOfu32, + ): Unit = + try { + writer.writeUint32(instance.u32) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b2a8bbf66 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 @@ -20,18 +20,23 @@ public data class NonZeroOfu64( public val u64: BigInteger, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NonZeroOfu64 = try { - NonZeroOfu64( - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NonZeroOfu64 = + try { + NonZeroOfu64( + reader.readUint64(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NonZeroOfu64): Unit = try { - writer.writeUint64(instance.u64) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NonZeroOfu64, + ): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..78270d18e 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 @@ -24,20 +24,25 @@ public data class Numeric( public val scale: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Numeric = try { - Numeric( - reader.read(CompactBigIntReader()), - reader.readCompactInt().toLong(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Numeric = + try { + Numeric( + reader.read(CompactBigIntReader()), + reader.readCompactInt().toLong(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Numeric): Unit = try { - writer.write(CompactULongWriter(), instance.mantissa.toLong()) - writer.write(CompactULongWriter(), instance.scale.toLong()) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Numeric, + ): Unit = + try { + writer.write(CompactULongWriter(), instance.mantissa.toLong()) + writer.write(CompactULongWriter(), instance.scale.toLong()) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..3ab8c6e62 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// 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..488d8768a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..d7bafa26a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/NumericProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..3109c2827 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 @@ -20,18 +20,23 @@ public data class NumericSpec( public val scale: Long? = null, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): NumericSpec = try { - NumericSpec( - reader.readNullable(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): NumericSpec = + try { + NumericSpec( + reader.readNullable(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: NumericSpec): Unit = try { - writer.writeNullable(instance.scale) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: NumericSpec, + ): Unit = + try { + writer.writeNullable(instance.scale) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..872801ae6 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 /** @@ -16,24 +17,29 @@ import kotlin.Unit * Generated from 'Pagination' regular structure */ public data class Pagination( - public val limit: NonZeroOfu32? = null, - public val start: NonZeroOfu64? = null, + 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?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Pagination = + try { + Pagination( + 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) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Pagination, + ): Unit = + try { + 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..75b5541c1 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 @@ -36,22 +36,24 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Sumeragi = try { - Sumeragi( - SumeragiParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Sumeragi = + try { + Sumeragi( + SumeragiParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SumeragiParameter.write(writer, instance.sumeragiParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Block = try { - Block( - BlockParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Block = + try { + Block( + BlockParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + BlockParameter.write(writer, instance.blockParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Transaction = try { - Transaction( - TransactionParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Transaction = + try { + Transaction( + TransactionParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TransactionParameter.write(writer, instance.transactionParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.SmartContract = try { - SmartContract( - SmartContractParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.SmartContract = + try { + SmartContract( + SmartContractParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SmartContractParameter.write(writer, instance.smartContractParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Executor = try { - Executor( - SmartContractParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Executor = + try { + Executor( + SmartContractParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SmartContractParameter.write(writer, instance.smartContractParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,39 +206,43 @@ public sealed class Parameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Custom = try { - Custom( - CustomParameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Parameter.Custom = + try { + Custom( + CustomParameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + CustomParameter.write(writer, instance.customParameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: Parameter, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: Parameter) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Sumeragi.write(writer, instance as Sumeragi) @@ -237,7 +251,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..106eae71d 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 @@ -20,20 +20,25 @@ public data class ParameterChanged( public val newValue: Parameter, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): ParameterChanged = try { - ParameterChanged( - Parameter.read(reader), - Parameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): ParameterChanged = + try { + ParameterChanged( + Parameter.read(reader), + Parameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: ParameterChanged): Unit = try { - Parameter.write(writer, instance.oldValue) - Parameter.write(writer, instance.newValue) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: ParameterChanged, + ): Unit = + try { + Parameter.write(writer, instance.oldValue) + Parameter.write(writer, instance.newValue) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..613c700df 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 @@ -26,38 +26,40 @@ public data class Parameters( public val custom: Map, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Parameters = try { - Parameters( - SumeragiParameters.read(reader), - BlockParameters.read(reader), - TransactionParameters.read(reader), - SmartContractParameters.read(reader), - SmartContractParameters.read(reader), - reader.readMap( - reader.readCompactInt(), - { CustomParameterId.read(reader) }, - { CustomParameter.read(reader) }, - ), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Parameters = + try { + Parameters( + SumeragiParameters.read(reader), + BlockParameters.read(reader), + TransactionParameters.read(reader), + SmartContractParameters.read(reader), + SmartContractParameters.read(reader), + reader.readMap(reader.readCompactInt(), { CustomParameterId.read(reader) }, { CustomParameter.read(reader) }), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Parameters): Unit = try { - SumeragiParameters.write(writer, instance.sumeragi) - BlockParameters.write(writer, instance.block) - TransactionParameters.write(writer, instance.transaction) - SmartContractParameters.write(writer, instance.executor) - SmartContractParameters.write(writer, instance.smartContract) - writer.writeCompact(instance.custom.size) - instance.custom.toSortedMap( - CustomParameterId.comparator(), - ).forEach { (key, value) -> - CustomParameterId.write(writer, key) - CustomParameter.write(writer, value) + override fun write( + writer: ScaleCodecWriter, + instance: Parameters, + ): Unit = + try { + SumeragiParameters.write(writer, instance.sumeragi) + BlockParameters.write(writer, instance.block) + TransactionParameters.write(writer, instance.transaction) + SmartContractParameters.write(writer, instance.executor) + SmartContractParameters.write(writer, instance.smartContract) + writer.writeCompact(instance.custom.size) + instance.custom + .toSortedMap( + CustomParameterId.comparator(), + ).forEach { (key, value) -> + CustomParameterId.write(writer, key) + CustomParameter.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } 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..a6209ae82 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 @@ -16,21 +16,29 @@ import kotlin.Unit * Generated from 'Peer' regular structure */ 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( - PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Peer = + try { + Peer( + SocketAddr.read(reader), + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Peer): Unit = try { - PeerId.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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..594fd22a4 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 @@ -36,22 +36,24 @@ public sealed class PeerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PeerEvent.Added = try { - Added( - PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PeerEvent.Added = + try { + Added( + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + PeerId.write(writer, instance.peerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,45 @@ public sealed class PeerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PeerEvent.Removed = try { - Removed( - PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PeerEvent.Removed = + try { + Removed( + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + PeerId.write(writer, instance.peerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: PeerEvent) { + 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..31d40335f 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 @@ -21,20 +21,25 @@ public data class PeerEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PeerEventFilter = try { - PeerEventFilter( - reader.readNullable(PeerId) as PeerId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): PeerEventFilter = + try { + PeerEventFilter( + reader.readNullable(PeerId) as PeerId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: PeerEventFilter): Unit = try { - writer.writeNullable(PeerId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: PeerEventFilter, + ): Unit = + try { + writer.writeNullable(PeerId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f0a8850b6 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 @@ -16,24 +16,26 @@ import kotlin.Unit * Generated from 'PeerId' regular structure */ public data class PeerId( - public val address: SocketAddr, 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) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): PeerId = + try { + PeerId( + PublicKey.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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) - } + override fun write( + writer: ScaleCodecWriter, + instance: PeerId, + ): Unit = + try { + PublicKey.write(writer, instance.publicKey) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt new file mode 100644 index 000000000..ed87a4763 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// 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 + +/** + * PeerIdPredicateAtom + * + * Generated from 'PeerIdPredicateAtom' enum + */ +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): PeerIdPredicateAtom = + when (val discriminant = reader.readUByte()) { + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + 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") + } + } + } +} 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..099b71ebc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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..5461549cc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PeerIdProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..b963985b6 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 @@ -18,23 +18,28 @@ import kotlin.Unit */ public data class Permission( public val name: String, - public val payload: String, + public val payload: Json, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Permission = try { - Permission( - reader.readString(), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Permission = + try { + Permission( + reader.readString(), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Permission, + ): Unit = + try { + writer.writeAsList(instance.name.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 54% 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..18314c4db 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,32 @@ 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..69329a69e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..184c373fb --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PermissionProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..f14cb776e 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 @@ -36,22 +36,24 @@ public sealed class PipelineEventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventBox.Transaction = try { - Transaction( - TransactionEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventBox.Transaction = + try { + Transaction( + TransactionEvent.read(reader), + ) + } 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) - } + ): Unit = + try { + TransactionEvent.write(writer, instance.transactionEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,45 @@ public sealed class PipelineEventBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventBox.Block = try { - Block( - BlockEvent.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventBox.Block = + try { + Block( + BlockEvent.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + BlockEvent.write(writer, instance.blockEvent) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: PipelineEventBox) { + 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..e190f77a0 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 @@ -36,22 +36,24 @@ public sealed class PipelineEventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Transaction = try { - Transaction( - TransactionEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Transaction = + try { + Transaction( + TransactionEventFilter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Transaction, - ): Unit = try { - TransactionEventFilter.write(writer, instance.transactionEventFilter) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + TransactionEventFilter.write(writer, instance.transactionEventFilter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,47 @@ public sealed class PipelineEventFilterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Block = try { - Block( - BlockEventFilter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PipelineEventFilterBox.Block = + try { + Block( + BlockEventFilter.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Transaction.read(reader) - 1 -> Block.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: PipelineEventFilterBox) { + 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..67d0afded 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 @@ -34,20 +34,25 @@ public data class PublicKey( override fun hashCode(): Int = algorithm.hashCode() * 31 + payload.contentHashCode() public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): PublicKey = try { - PublicKey( - Algorithm.read(reader), - reader.readByteArray(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): PublicKey = + try { + PublicKey( + Algorithm.read(reader), + reader.readByteArray(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: PublicKey): Unit = try { - Algorithm.write(writer, instance.algorithm) - writer.writeAsList(instance.payload) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: PublicKey, + ): Unit = + try { + Algorithm.write(writer, instance.algorithm) + writer.writeAsList(instance.payload) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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 54% 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..8128a0573 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 */ @@ -28,46 +28,53 @@ public sealed class PublicKeyPredicateBox : ModelEnum { */ public data class Equals( public val publicKey: PublicKey, - ) : PublicKeyPredicateBox() { + ) : 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 { - Equals( - PublicKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.PublicKeyPredicateAtom.Equals = + try { + Equals( + PublicKey.read(reader), + ) + } catch (ex: Exception) { + 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) - } + 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() - ) { - 0 -> Equals.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - 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..7a8bf6f25 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..0739678e6 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/PublicKeyProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..85d24dcc4 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,100 +24,101 @@ 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, + public data class FindDomains( + public val queryWithFilterOfFindDomains: QueryWithFilterOfFindDomains, ) : QueryBox() { 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.QueryBox.FindAllAccounts = try { - FindAllAccounts( - jp.co.soramitsu.iroha2.generated.FindAllAccounts.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.FindAllAccounts, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllAccounts.write(writer, instance.findAllAccounts) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindDomains, + ): Unit = + try { + QueryWithFilterOfFindDomains.write(writer, instance.queryWithFilterOfFindDomains) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAccountById' variant + * 'FindAccounts' variant */ - public data class FindAccountById( - public val findAccountById: jp.co.soramitsu.iroha2.generated.FindAccountById, + public data class FindAccounts( + public val queryWithFilterOfFindAccounts: QueryWithFilterOfFindAccounts, ) : QueryBox() { 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.QueryBox.FindAccountById = try { - FindAccountById( - jp.co.soramitsu.iroha2.generated.FindAccountById.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.FindAccountById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountById.write(writer, instance.findAccountById) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccounts, + ): Unit = + try { + QueryWithFilterOfFindAccounts.write(writer, instance.queryWithFilterOfFindAccounts) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAccountKeyValueByIdAndKey' variant + * 'FindAssets' variant */ - public data class FindAccountKeyValueByIdAndKey( - public val findAccountKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey, + public data class FindAssets( + public val queryWithFilterOfFindAssets: QueryWithFilterOfFindAssets, ) : QueryBox() { 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.QueryBox.FindAccountKeyValueByIdAndKey = try { - FindAccountKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.FindAccountKeyValueByIdAndKey, + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssets, ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountKeyValueByIdAndKey.write( - writer, - instance.findAccountKeyValueByIdAndKey, - ) + QueryWithFilterOfFindAssets.write(writer, instance.queryWithFilterOfFindAssets) } catch (ex: Exception) { throw wrapException(ex) } @@ -125,307 +126,305 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAccountsByDomainId' variant + * 'FindAssetsDefinitions' variant */ - public data class FindAccountsByDomainId( - public val findAccountsByDomainId: jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId, + public data class FindAssetsDefinitions( + public val queryWithFilterOfFindAssetsDefinitions: QueryWithFilterOfFindAssetsDefinitions, ) : QueryBox() { 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.QueryBox.FindAccountsByDomainId = try { - FindAccountsByDomainId( - jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.FindAccountsByDomainId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountsByDomainId.write( - writer, - instance.findAccountsByDomainId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAssetsDefinitions, + ): Unit = + try { + QueryWithFilterOfFindAssetsDefinitions.write(writer, instance.queryWithFilterOfFindAssetsDefinitions) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAccountsWithAsset' variant + * 'FindRoles' variant */ - public data class FindAccountsWithAsset( - public val findAccountsWithAsset: jp.co.soramitsu.iroha2.generated.FindAccountsWithAsset, + public data class FindRoles( + public val queryWithFilterOfFindRoles: QueryWithFilterOfFindRoles, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRoles = + try { + FindRoles( + QueryWithFilterOfFindRoles.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) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRoles, + ): Unit = + try { + QueryWithFilterOfFindRoles.write(writer, instance.queryWithFilterOfFindRoles) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAllAssets' variant + * 'FindRoleIds' variant */ - public data class FindAllAssets( - public val findAllAssets: jp.co.soramitsu.iroha2.generated.FindAllAssets, + public data class FindRoleIds( + public val queryWithFilterOfFindRoleIds: QueryWithFilterOfFindRoleIds, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAllAssets, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAllAssets.write(writer, instance.findAllAssets) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleIds, + ): Unit = + try { + QueryWithFilterOfFindRoleIds.write(writer, instance.queryWithFilterOfFindRoleIds) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAllAssetsDefinitions' variant + * 'FindPermissionsByAccountId' variant */ - public data class FindAllAssetsDefinitions( - public val findAllAssetsDefinitions: jp.co.soramitsu.iroha2.generated.FindAllAssetsDefinitions, + public data class FindPermissionsByAccountId( + public val queryWithFilterOfFindPermissionsByAccountId: QueryWithFilterOfFindPermissionsByAccountId, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindPermissionsByAccountId = + try { + FindPermissionsByAccountId( + QueryWithFilterOfFindPermissionsByAccountId.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) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindPermissionsByAccountId, + ): Unit = + try { + QueryWithFilterOfFindPermissionsByAccountId.write(writer, instance.queryWithFilterOfFindPermissionsByAccountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetById' variant + * 'FindRolesByAccountId' variant */ - public data class FindAssetById( - public val findAssetById: jp.co.soramitsu.iroha2.generated.FindAssetById, + public data class FindRolesByAccountId( + public val queryWithFilterOfFindRolesByAccountId: QueryWithFilterOfFindRolesByAccountId, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetById.write(writer, instance.findAssetById) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId, + ): Unit = + try { + QueryWithFilterOfFindRolesByAccountId.write(writer, instance.queryWithFilterOfFindRolesByAccountId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetDefinitionById' variant + * 'FindAccountsWithAsset' variant */ - public data class FindAssetDefinitionById( - public val findAssetDefinitionById: jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById, + public data class FindAccountsWithAsset( + public val queryWithFilterOfFindAccountsWithAsset: QueryWithFilterOfFindAccountsWithAsset, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetDefinitionById, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetDefinitionById.write( - writer, - instance.findAssetDefinitionById, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindAccountsWithAsset, + ): Unit = + try { + QueryWithFilterOfFindAccountsWithAsset.write(writer, instance.queryWithFilterOfFindAccountsWithAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetsByName' variant + * 'FindPeers' variant */ - public data class FindAssetsByName( - public val findAssetsByName: jp.co.soramitsu.iroha2.generated.FindAssetsByName, + public data class FindPeers( + public val queryWithFilterOfFindPeers: QueryWithFilterOfFindPeers, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetsByName, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByName.write(writer, instance.findAssetsByName) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindPeers, + ): Unit = + try { + QueryWithFilterOfFindPeers.write(writer, instance.queryWithFilterOfFindPeers) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetsByAccountId' variant + * 'FindActiveTriggerIds' variant */ - public data class FindAssetsByAccountId( - public val findAssetsByAccountId: jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId, + public data class FindActiveTriggerIds( + public val queryWithFilterOfFindActiveTriggerIds: QueryWithFilterOfFindActiveTriggerIds, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetsByAccountId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByAccountId.write( - writer, - instance.findAssetsByAccountId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindActiveTriggerIds, + ): Unit = + try { + QueryWithFilterOfFindActiveTriggerIds.write(writer, instance.queryWithFilterOfFindActiveTriggerIds) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetsByAssetDefinitionId' variant + * 'FindTriggers' variant */ - public data class FindAssetsByAssetDefinitionId( - public val findAssetsByAssetDefinitionId: - jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId, + public data class FindTriggers( + public val queryWithFilterOfFindTriggers: QueryWithFilterOfFindTriggers, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetsByAssetDefinitionId, + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggers, ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByAssetDefinitionId.write( - writer, - instance.findAssetsByAssetDefinitionId, - ) + QueryWithFilterOfFindTriggers.write(writer, instance.queryWithFilterOfFindTriggers) } catch (ex: Exception) { throw wrapException(ex) } @@ -433,1080 +432,151 @@ public sealed class QueryBox : ModelEnum { } /** - * 'FindAssetsByDomainId' variant + * 'FindTransactions' variant */ - public data class FindAssetsByDomainId( - public val findAssetsByDomainId: jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId, + public data class FindTransactions( + public val queryWithFilterOfFindTransactions: QueryWithFilterOfFindTransactions, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetsByDomainId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainId.write( - writer, - instance.findAssetsByDomainId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactions, + ): Unit = + try { + QueryWithFilterOfFindTransactions.write(writer, instance.queryWithFilterOfFindTransactions) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetsByDomainIdAndAssetDefinitionId' variant + * 'FindBlocks' variant */ - public data class FindAssetsByDomainIdAndAssetDefinitionId( - public val findAssetsByDomainIdAndAssetDefinitionId: - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId, + public data class FindBlocks( + public val queryWithFilterOfFindBlocks: QueryWithFilterOfFindBlocks, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 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.FindAssetsByDomainIdAndAssetDefinitionId, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAssetsByDomainIdAndAssetDefinitionId.write( - writer, - instance.findAssetsByDomainIdAndAssetDefinitionId, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindBlocks, + ): Unit = + try { + QueryWithFilterOfFindBlocks.write(writer, instance.queryWithFilterOfFindBlocks) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'FindAssetQuantityById' variant + * 'FindBlockHeaders' variant */ - public data class FindAssetQuantityById( - public val findAssetQuantityById: jp.co.soramitsu.iroha2.generated.FindAssetQuantityById, + public data class FindBlockHeaders( + public val queryWithFilterOfFindBlockHeaders: QueryWithFilterOfFindBlockHeaders, ) : QueryBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { + 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 = + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaders = try { - jp.co.soramitsu.iroha2.generated.FindAssetKeyValueByIdAndKey.write( - writer, - instance.findAssetKeyValueByIdAndKey, + FindBlockHeaders( + QueryWithFilterOfFindBlockHeaders.read(reader), ) } 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) - } + instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaders, + ): Unit = + try { + QueryWithFilterOfFindBlockHeaders.write(writer, instance.queryWithFilterOfFindBlockHeaders) + } 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) + public companion object : ScaleReader, ScaleWriter { + 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 -> 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") } } } - - /** - * '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() { - 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.QueryBox.FindAllPeers = try { - FindAllPeers( - jp.co.soramitsu.iroha2.generated.FindAllPeers.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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllBlocks' variant - */ - public data class FindAllBlocks( - public val findAllBlocks: jp.co.soramitsu.iroha2.generated.FindAllBlocks, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 22 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlocks = try { - FindAllBlocks( - jp.co.soramitsu.iroha2.generated.FindAllBlocks.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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllBlockHeaders' variant - */ - public data class FindAllBlockHeaders( - public val findAllBlockHeaders: jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 23 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllBlockHeaders = try { - FindAllBlockHeaders( - jp.co.soramitsu.iroha2.generated.FindAllBlockHeaders.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, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindBlockHeaderByHash' variant - */ - public data class FindBlockHeaderByHash( - public val findBlockHeaderByHash: jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 24 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindBlockHeaderByHash = try { - FindBlockHeaderByHash( - jp.co.soramitsu.iroha2.generated.FindBlockHeaderByHash.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) - } - } - } - - /** - * 'FindAllTransactions' variant - */ - public data class FindAllTransactions( - public val findAllTransactions: jp.co.soramitsu.iroha2.generated.FindAllTransactions, - ) : 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) - } - - 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, - ) - } 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), - ) - } 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 - */ - public data class FindTransactionByHash( - public val findTransactionByHash: jp.co.soramitsu.iroha2.generated.FindTransactionByHash, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 27 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTransactionByHash = try { - FindTransactionByHash( - jp.co.soramitsu.iroha2.generated.FindTransactionByHash.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, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindPermissionsByAccountId' variant - */ - public data class FindPermissionsByAccountId( - public val findPermissionsByAccountId: - jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 28 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindPermissionsByAccountId = try { - FindPermissionsByAccountId( - jp.co.soramitsu.iroha2.generated.FindPermissionsByAccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - 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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindTriggerKeyValueByIdAndKey' variant - */ - public data class FindTriggerKeyValueByIdAndKey( - public val findTriggerKeyValueByIdAndKey: - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 32 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerKeyValueByIdAndKey = try { - FindTriggerKeyValueByIdAndKey( - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggerKeyValueByIdAndKey, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindTriggerKeyValueByIdAndKey.write( - writer, - instance.findTriggerKeyValueByIdAndKey, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindTriggersByAuthorityId' variant - */ - public data class FindTriggersByAuthorityId( - public val findTriggersByAuthorityId: - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 33 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityId = try { - FindTriggersByAuthorityId( - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityId.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) - } - } - } - - /** - * 'FindTriggersByAuthorityDomainId' variant - */ - public data class FindTriggersByAuthorityDomainId( - public val findTriggersByAuthorityDomainId: - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 34 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindTriggersByAuthorityDomainId = try { - FindTriggersByAuthorityDomainId( - jp.co.soramitsu.iroha2.generated.FindTriggersByAuthorityDomainId.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, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllRoles' variant - */ - public data class FindAllRoles( - public val findAllRoles: jp.co.soramitsu.iroha2.generated.FindAllRoles, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 35 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoles = try { - FindAllRoles( - jp.co.soramitsu.iroha2.generated.FindAllRoles.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) - } - } - } - - /** - * 'FindAllRoleIds' variant - */ - public data class FindAllRoleIds( - public val findAllRoleIds: jp.co.soramitsu.iroha2.generated.FindAllRoleIds, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 36 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllRoleIds = try { - FindAllRoleIds( - jp.co.soramitsu.iroha2.generated.FindAllRoleIds.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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindRoleByRoleId' variant - */ - public data class FindRoleByRoleId( - public val findRoleByRoleId: jp.co.soramitsu.iroha2.generated.FindRoleByRoleId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 37 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRoleByRoleId = try { - FindRoleByRoleId( - jp.co.soramitsu.iroha2.generated.FindRoleByRoleId.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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindRolesByAccountId' variant - */ - public data class FindRolesByAccountId( - public val findRolesByAccountId: jp.co.soramitsu.iroha2.generated.FindRolesByAccountId, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 38 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindRolesByAccountId = try { - FindRolesByAccountId( - jp.co.soramitsu.iroha2.generated.FindRolesByAccountId.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, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'FindAllParameters' variant - */ - public data class FindAllParameters( - public val findAllParameters: jp.co.soramitsu.iroha2.generated.FindAllParameters, - ) : QueryBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 39 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryBox.FindAllParameters = try { - FindAllParameters( - jp.co.soramitsu.iroha2.generated.FindAllParameters.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) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - 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 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") } - } - } } 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..4246c4e98 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 @@ -26,19 +26,27 @@ 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 FetchSizeTooBig -> FetchSizeTooBig.equals(this, other) - is InvalidSingularParameters -> InvalidSingularParameters.equals(this, other) - is CapacityLimit -> CapacityLimit.equals(this, other) - else -> super.equals(other) } - - override fun hashCode(): Int = when (this) { - is UnknownCursor -> UnknownCursor.hashCode() - is FetchSizeTooBig -> FetchSizeTooBig.hashCode() - is InvalidSingularParameters -> InvalidSingularParameters.hashCode() - is CapacityLimit -> CapacityLimit.hashCode() - else -> super.hashCode() } + override fun equals(other: Any?): Boolean = + when (this) { + 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) + } + + override fun hashCode(): Int = + when (this) { + 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() + } /** * 'Find' variant @@ -53,22 +61,24 @@ public sealed class QueryExecutionFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Find = try { - Find( - FindError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Find = + try { + Find( + FindError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + FindError.write(writer, instance.findError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -85,59 +95,144 @@ public sealed class QueryExecutionFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Conversion = try { - Conversion( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.Conversion = + try { + Conversion( + reader.readString(), + ) + } catch (ex: Exception) { + 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } /** - * 'UnknownCursor' variant + * 'NotFound' variant */ - public class UnknownCursor : QueryExecutionFail() { + public class NotFound : QueryExecutionFail() { 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.QueryExecutionFail.UnknownCursor = try { - UnknownCursor() - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.UnknownCursor, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.UnknownCursor, + o1: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.NotFound, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".QueryExecutionFail.NotFound".hashCode() + } + } + + /** + * 'CursorMismatch' variant + */ + public class CursorMismatch : QueryExecutionFail() { + 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.QueryExecutionFail.CursorMismatch = + try { + CursorMismatch() + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + 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.CursorMismatch, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } + + override fun hashCode(): Int = ".QueryExecutionFail.CursorMismatch".hashCode() + } + } - override fun hashCode(): Int = ".QueryExecutionFail.UnknownCursor".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,29 +245,32 @@ 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() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.FetchSizeTooBig = + try { + FetchSizeTooBig() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.FetchSizeTooBig, - ): 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.QueryExecutionFail.FetchSizeTooBig, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".QueryExecutionFail.FetchSizeTooBig".hashCode() } @@ -187,29 +285,32 @@ 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, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.InvalidSingularParameters, - ): 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.QueryExecutionFail.InvalidSingularParameters, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".QueryExecutionFail.InvalidSingularParameters".hashCode() } @@ -224,57 +325,67 @@ 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() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CapacityLimit = + try { + CapacityLimit() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.QueryExecutionFail.CapacityLimit, - ): 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.QueryExecutionFail.CapacityLimit, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".QueryExecutionFail.CapacityLimit".hashCode() } } 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 -> 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, ) { - 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") } - - 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..994d9f6fd 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,27 +17,32 @@ 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), - reader.readUint64(), - reader.readNullable(ForwardCursor) as ForwardCursor?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): QueryOutput = + try { + QueryOutput( + QueryOutputBatchBoxTuple.read(reader), + reader.readUint64(), + reader.readNullable(ForwardCursor) as ForwardCursor?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: QueryOutput): Unit = try { - QueryOutputBatchBox.write(writer, instance.batch) - writer.writeUint64(instance.remainingItems) - writer.writeNullable(ForwardCursor, instance.continueCursor) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: QueryOutput, + ): Unit = + try { + QueryOutputBatchBoxTuple.write(writer, instance.batch) + writer.writeUint64(instance.remainingItems) + writer.writeNullable(ForwardCursor, instance.continueCursor) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..744336658 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,6 +24,289 @@ 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 */ @@ -35,27 +318,74 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Domain.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Domain = + try { + Domain( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.Domain, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Domain.write(writer, value) + ): 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) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -70,94 +400,357 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Account.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Account = + try { + Account( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.Account, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Account.write(writer, value) + ): 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() { + 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.QueryOutputBatchBox.Asset = + try { + Asset( + reader.readVec(reader.readCompactInt()) { + 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.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.AssetDefinitionId, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.AssetDefinitionId + .write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'AssetDefinition' variant + */ + public data class AssetDefinition( + public val vec: List, + ) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.AssetDefinition = + try { + AssetDefinition( + reader.readVec(reader.readCompactInt()) { + 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.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) + } + } + } + + /** + * 'Role' variant + */ + public data class Role( + public val vec: List, + ) : QueryOutputBatchBox() { + 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.QueryOutputBatchBox.Role = + try { + Role( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.Role, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.Role + .write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'Asset' variant + * 'Parameter' variant */ - public data class Asset( - public val vec: List, + public data class Parameter( + public val vec: List, ) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 2 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 16 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Asset = try { - Asset( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Asset.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter = + try { + Parameter( + reader.readVec(reader.readCompactInt()) { + jp.co.soramitsu.iroha2.generated.Parameter + .read(reader) + }, + ) + } catch (ex: Exception) { + 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) + 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) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'AssetDefinition' variant + * 'Permission' variant */ - public data class AssetDefinition( - public val vec: List, + public data class Permission( + public val vec: List, ) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 3 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 17 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.AssetDefinition = try { - AssetDefinition( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.AssetDefinition.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.AssetDefinition, + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Permission, ): Unit = try { writer.writeCompact(instance.vec.size) instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.AssetDefinition.write(writer, value) + jp.co.soramitsu.iroha2.generated.Permission + .write(writer, value) } } catch (ex: Exception) { throw wrapException(ex) @@ -166,142 +759,164 @@ public sealed class QueryOutputBatchBox : ModelEnum { } /** - * 'Role' variant + * 'CommittedTransaction' variant */ - public data class Role( - public val vec: List, + public data class CommittedTransaction( + public val vec: List, ) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 4 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 18 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Role = try { - Role( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Role.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.Role, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Role.write(writer, value) + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.CommittedTransaction, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.CommittedTransaction + .write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'Parameter' variant + * 'SignedTransaction' variant */ - public data class Parameter( - public val vec: List, + public data class SignedTransaction( + public val vec: List, ) : QueryOutputBatchBox() { override fun discriminant(): Int = DISCRIMINANT public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 5 + ScaleReader, + ScaleWriter { + public const val DISCRIMINANT: Int = 19 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Parameter = try { - Parameter( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Parameter.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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) + } 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) + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.SignedTransaction, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + jp.co.soramitsu.iroha2.generated.SignedTransaction + .write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'Permission' variant + * 'TransactionHash' variant */ - public data class Permission( - public val vec: List, + public data class TransactionHash( + 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 = 20 - 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 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) + } 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) + 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) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } /** - * 'Transaction' variant + * 'TransactionRejectionReason' variant */ - public data class Transaction( - public val vec: List, + public data class TransactionRejectionReason( + 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 = 21 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Transaction = try { - Transaction( - reader.readVec(reader.readCompactInt()) { TransactionQueryOutput.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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.Transaction, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - TransactionQueryOutput.write(writer, value) - } - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TransactionRejectionReason, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + writer.writeNullable(jp.co.soramitsu.iroha2.generated.TransactionRejectionReason, value) + } + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -309,34 +924,36 @@ public sealed class QueryOutputBatchBox : ModelEnum { * 'Peer' variant */ public data class Peer( - public val vec: List, + 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) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Peer = + try { + Peer( + 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 { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Peer.write(writer, value) + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + PeerId.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -351,27 +968,33 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.RoleId.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.RoleId = + try { + RoleId( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.RoleId, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.RoleId.write(writer, value) + ): 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) - } } } @@ -386,27 +1009,33 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.TriggerId.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.TriggerId = + try { + TriggerId( + reader.readVec(reader.readCompactInt()) { + jp.co.soramitsu.iroha2.generated.TriggerId + .read(reader) + }, + ) + } catch (ex: Exception) { + 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) + ): 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) - } } } @@ -421,27 +1050,74 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.Trigger.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Trigger = + try { + Trigger( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.Trigger, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.Trigger.write(writer, value) + ): 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) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -456,27 +1132,29 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { SignedBlock.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.Block = + try { + Block( + reader.readVec(reader.readCompactInt()) { SignedBlock.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + SignedBlock.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } @@ -491,69 +1169,149 @@ public sealed class QueryOutputBatchBox : ModelEnum { 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( - reader.readVec(reader.readCompactInt()) { jp.co.soramitsu.iroha2.generated.BlockHeader.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryOutputBatchBox.BlockHeader = + try { + BlockHeader( + reader.readVec(reader.readCompactInt()) { + 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.QueryOutputBatchBox.BlockHeader, - ): Unit = try { - writer.writeCompact(instance.vec.size) - instance.vec.forEach { value -> - jp.co.soramitsu.iroha2.generated.BlockHeader.write(writer, value) + ): 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.BlockHeaderHash, + ): Unit = + try { + writer.writeCompact(instance.vec.size) + instance.vec.forEach { value -> + HashOf.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryOutputBatchBox = when ( - val discriminant = - reader.readUByte() + 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, ) { - 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 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..04aa9c229 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryOutputBatchBoxTuple.kt @@ -0,0 +1,47 @@ +// +// 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/QueryParams.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryParams.kt index b5c257627..faa6cb07f 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryParams.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryParams.kt @@ -21,22 +21,27 @@ public data class QueryParams( public val fetchSize: FetchSize, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryParams = try { - QueryParams( - Pagination.read(reader), - Sorting.read(reader), - FetchSize.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): QueryParams = + try { + QueryParams( + Pagination.read(reader), + Sorting.read(reader), + FetchSize.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: QueryParams): Unit = try { - Pagination.write(writer, instance.pagination) - Sorting.write(writer, instance.sorting) - FetchSize.write(writer, instance.fetchSize) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: QueryParams, + ): Unit = + try { + Pagination.write(writer, instance.pagination) + Sorting.write(writer, instance.sorting) + FetchSize.write(writer, instance.fetchSize) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..97e1d2de1 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 @@ -36,22 +36,24 @@ public sealed class QueryRequest : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Singular = try { - Singular( - SingularQueryBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Singular = + try { + Singular( + SingularQueryBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SingularQueryBox.write(writer, instance.singularQueryBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class QueryRequest : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Start = try { - Start( - QueryWithParams.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Start = + try { + Start( + QueryWithParams.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + QueryWithParams.write(writer, instance.queryWithParams) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,42 +104,47 @@ public sealed class QueryRequest : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Continue = try { - Continue( - ForwardCursor.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryRequest.Continue = + try { + Continue( + ForwardCursor.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + ForwardCursor.write(writer, instance.forwardCursor) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: QueryRequest) { + override fun write( + writer: ScaleCodecWriter, + instance: QueryRequest, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..fc6392860 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 @@ -22,20 +22,25 @@ public data class QueryRequestWithAuthority( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryRequestWithAuthority = try { - QueryRequestWithAuthority( - AccountId.read(reader), - QueryRequest.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): QueryRequestWithAuthority = + try { + QueryRequestWithAuthority( + AccountId.read(reader), + QueryRequest.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: QueryRequestWithAuthority): Unit = try { - AccountId.write(writer, instance.authority) - QueryRequest.write(writer, instance.request) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: QueryRequestWithAuthority, + ): Unit = + try { + AccountId.write(writer, instance.authority) + QueryRequest.write(writer, instance.request) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..3d104d4b1 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 @@ -36,22 +36,24 @@ public sealed class QueryResponse : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryResponse.Singular = try { - Singular( - SingularQueryOutputBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryResponse.Singular = + try { + Singular( + SingularQueryOutputBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SingularQueryOutputBox.write(writer, instance.singularQueryOutputBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,45 @@ public sealed class QueryResponse : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryResponse.Iterable = try { - Iterable( - QueryOutput.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.QueryResponse.Iterable = + try { + Iterable( + QueryOutput.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + QueryOutput.write(writer, instance.queryOutput) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: QueryResponse) { + 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..6d6eb8c84 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 @@ -16,21 +16,26 @@ import kotlin.Unit * Generated from 'QuerySignature' regular structure */ public data class QuerySignature( - public val signatureOfOfClientQueryPayload: SignatureOf, + public val signatureOfOfQueryRequestWithAuthority: SignatureOf, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QuerySignature = try { - QuerySignature( - SignatureOf.read(reader) as SignatureOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): QuerySignature = + try { + QuerySignature( + 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) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: QuerySignature, + ): Unit = + try { + 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..6928b5b60 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccounts.kt @@ -0,0 +1,49 @@ +// +// 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..7b4e79ff4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAccountsWithAsset.kt @@ -0,0 +1,49 @@ +// +// 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..d3d61e8b3 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindActiveTriggerIds.kt @@ -0,0 +1,49 @@ +// +// 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..d29227450 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssets.kt @@ -0,0 +1,49 @@ +// +// 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..a26a3a845 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindAssetsDefinitions.kt @@ -0,0 +1,49 @@ +// +// 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..eba0decd0 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlockHeaders.kt @@ -0,0 +1,49 @@ +// +// 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..d6efc4156 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindBlocks.kt @@ -0,0 +1,49 @@ +// +// 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..10c2e9f76 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindDomains.kt @@ -0,0 +1,49 @@ +// +// 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..5b2b7c703 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPeers.kt @@ -0,0 +1,49 @@ +// +// 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..73e850365 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindPermissionsByAccountId.kt @@ -0,0 +1,49 @@ +// +// 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..a0e723fe8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoleIds.kt @@ -0,0 +1,49 @@ +// +// 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..e5ae43452 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRoles.kt @@ -0,0 +1,49 @@ +// +// 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..5634031e7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindRolesByAccountId.kt @@ -0,0 +1,49 @@ +// +// 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..cbc73184a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTransactions.kt @@ -0,0 +1,49 @@ +// +// 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..ed42d5384 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/QueryWithFilterOfFindTriggers.kt @@ -0,0 +1,49 @@ +// +// 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..5499f0af7 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 @@ -20,20 +20,25 @@ public data class QueryWithParams( public val params: QueryParams, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): QueryWithParams = try { - QueryWithParams( - QueryBox.read(reader), - QueryParams.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): QueryWithParams = + try { + QueryWithParams( + QueryBox.read(reader), + QueryParams.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: QueryWithParams): Unit = try { - QueryBox.write(writer, instance.query) - QueryParams.write(writer, instance.params) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: QueryWithParams, + ): Unit = + try { + QueryBox.write(writer, instance.query) + QueryParams.write(writer, instance.params) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..2da22941b 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,40 +20,51 @@ 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 { - override fun read(reader: ScaleCodecReader): RawGenesisTransaction = try { - RawGenesisTransaction( - ChainId.read(reader), - reader.readString(), - reader.readVec(reader.readCompactInt()) { Parameter.read(reader) }, - reader.readVec(reader.readCompactInt()) { InstructionBox.read(reader) }, - reader.readVec(reader.readCompactInt()) { PeerId.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - 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.writeCompact(instance.instructions.size) - instance.instructions.forEach { value -> - InstructionBox.write(writer, value) + override fun read(reader: ScaleCodecReader): RawGenesisTransaction = + try { + RawGenesisTransaction( + ChainId.read(reader), + reader.readString(), + 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) { + throw wrapException(ex) } - writer.writeCompact(instance.topology.size) - instance.topology.forEach { value -> - PeerId.write(writer, value) + + override fun write( + writer: ScaleCodecWriter, + instance: RawGenesisTransaction, + ): Unit = + try { + ChainId.write(writer, instance.chain) + writer.writeAsList(instance.executor.toByteArray(Charsets.UTF_8)) + 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) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } 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..be9b0a1f9 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 @@ -36,22 +36,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Peer = try { - Peer( - RegisterOfPeer.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Peer = + try { + Peer( + RegisterOfPeer.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfPeer.write(writer, instance.registerOfPeer) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Domain = try { - Domain( - RegisterOfDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Domain = + try { + Domain( + RegisterOfDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfDomain.write(writer, instance.registerOfDomain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Account = try { - Account( - RegisterOfAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Account = + try { + Account( + RegisterOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfAccount.write(writer, instance.registerOfAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.AssetDefinition = try { - AssetDefinition( - RegisterOfAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.AssetDefinition = + try { + AssetDefinition( + RegisterOfAssetDefinition.read(reader), + ) + } 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) - } + ): Unit = + try { + RegisterOfAssetDefinition.write(writer, instance.registerOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Asset = try { - Asset( - RegisterOfAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Asset = + try { + Asset( + RegisterOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfAsset.write(writer, instance.registerOfAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Role = try { - Role( - RegisterOfRole.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Role = + try { + Role( + RegisterOfRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfRole.write(writer, instance.registerOfRole) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,40 +240,44 @@ public sealed class RegisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Trigger = try { - Trigger( - RegisterOfTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RegisterBox.Trigger = + try { + Trigger( + RegisterOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RegisterOfTrigger.write(writer, instance.registerOfTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> AssetDefinition.read(reader) + 4 -> Asset.read(reader) + 5 -> Role.read(reader) + 6 -> Trigger.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: RegisterBox, ) { - 0 -> Peer.read(reader) - 1 -> Domain.read(reader) - 2 -> Account.read(reader) - 3 -> AssetDefinition.read(reader) - 4 -> Asset.read(reader) - 5 -> Role.read(reader) - 6 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: RegisterBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Peer.write(writer, instance as Peer) @@ -271,7 +287,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..7da579e06 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - NewAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfAccount = + try { + RegisterOfAccount( + NewAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfAccount): Unit = try { - NewAccount.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfAccount, + ): Unit = + try { + NewAccount.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..03d23c012 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - Asset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfAsset = + try { + RegisterOfAsset( + Asset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfAsset): Unit = try { - Asset.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfAsset, + ): Unit = + try { + Asset.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f6cc4f6ec 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 @@ -17,22 +20,29 @@ import kotlin.Unit */ public data class RegisterOfAssetDefinition( public val `object`: NewAssetDefinition, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RegisterOfAssetDefinition = try { - RegisterOfAssetDefinition( - NewAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfAssetDefinition = + try { + RegisterOfAssetDefinition( + NewAssetDefinition.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfAssetDefinition): Unit = try { - NewAssetDefinition.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfAssetDefinition, + ): Unit = + try { + NewAssetDefinition.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..6095d5abd 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - NewDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfDomain = + try { + RegisterOfDomain( + NewDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfDomain): Unit = try { - NewDomain.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfDomain, + ): Unit = + try { + NewDomain.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..431862fe3 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 @@ -16,21 +19,28 @@ import kotlin.Unit * Generated from 'RegisterOfPeer' regular structure */ public data class RegisterOfPeer( - public val `object`: Peer, -) { + 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), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfPeer = + try { + RegisterOfPeer( + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfPeer): Unit = try { - Peer.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfPeer, + ): Unit = + try { + 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..8cd528f7f 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 @@ -16,21 +19,28 @@ import kotlin.Unit * Generated from 'RegisterOfRole' regular structure */ public data class RegisterOfRole( - public val `object`: Role, -) { + 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), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfRole = + try { + RegisterOfRole( + NewRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfRole): Unit = try { - Role.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfRole, + ): Unit = + try { + 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..f5e4dc702 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - Trigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RegisterOfTrigger = + try { + RegisterOfTrigger( + Trigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RegisterOfTrigger): Unit = try { - Trigger.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RegisterOfTrigger, + ): Unit = + try { + Trigger.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..3bb53dfaf 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 @@ -36,22 +36,24 @@ public sealed class RemoveKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Domain = try { - Domain( - RemoveKeyValueOfDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Domain = + try { + Domain( + RemoveKeyValueOfDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RemoveKeyValueOfDomain.write(writer, instance.removeKeyValueOfDomain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class RemoveKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Account = try { - Account( - RemoveKeyValueOfAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Account = + try { + Account( + RemoveKeyValueOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RemoveKeyValueOfAccount.write(writer, instance.removeKeyValueOfAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class RemoveKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.AssetDefinition = try { - AssetDefinition( - RemoveKeyValueOfAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.AssetDefinition = + try { + AssetDefinition( + RemoveKeyValueOfAssetDefinition.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.AssetDefinition, - ): Unit = try { - RemoveKeyValueOfAssetDefinition.write(writer, instance.removeKeyValueOfAssetDefinition) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + RemoveKeyValueOfAssetDefinition.write(writer, instance.removeKeyValueOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class RemoveKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Asset = try { - Asset( - RemoveKeyValueOfAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Asset = + try { + Asset( + RemoveKeyValueOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RemoveKeyValueOfAsset.write(writer, instance.removeKeyValueOfAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,38 +172,42 @@ public sealed class RemoveKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Trigger = try { - Trigger( - RemoveKeyValueOfTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RemoveKeyValueBox.Trigger = + try { + Trigger( + RemoveKeyValueOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RemoveKeyValueOfTrigger.write(writer, instance.removeKeyValueOfTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueBox, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Domain.write(writer, instance as Domain) @@ -203,7 +215,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..51504b550 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class RemoveKeyValueOfAccount( public val `object`: AccountId, public val key: Name, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAccount = try { - RemoveKeyValueOfAccount( - AccountId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAccount = + try { + RemoveKeyValueOfAccount( + AccountId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfAccount): Unit = try { - AccountId.write(writer, instance.`object`) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueOfAccount, + ): Unit = + try { + AccountId.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/RemoveKeyValueOfAsset.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAsset.kt index 40b180b03..f9d70bf5d 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 @@ -18,22 +21,29 @@ import kotlin.Unit 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( - AssetId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAsset = + try { + RemoveKeyValueOfAsset( + AssetId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfAsset): Unit = try { - AssetId.write(writer, instance.`object`) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueOfAsset, + ): Unit = + try { + AssetId.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/RemoveKeyValueOfAssetDefinition.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfAssetDefinition.kt index 29112f1e2..1f595ca47 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 @@ -18,20 +21,26 @@ import kotlin.Unit public data class RemoveKeyValueOfAssetDefinition( public val `object`: AssetDefinitionId, public val key: Name, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAssetDefinition = try { - RemoveKeyValueOfAssetDefinition( - AssetDefinitionId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RemoveKeyValueOfAssetDefinition = + try { + RemoveKeyValueOfAssetDefinition( + AssetDefinitionId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfAssetDefinition): Unit = + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueOfAssetDefinition, + ): Unit = try { AssetDefinitionId.write(writer, instance.`object`) Name.write(writer, instance.key) 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..df88fdfad 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 @@ -18,22 +21,31 @@ import kotlin.Unit public data class RemoveKeyValueOfDomain( public val `object`: DomainId, public val key: Name, -) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RemoveKeyValueOfDomain = try { - RemoveKeyValueOfDomain( - DomainId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfDomain): Unit = try { - DomainId.write(writer, instance.`object`) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): RemoveKeyValueOfDomain = + try { + RemoveKeyValueOfDomain( + DomainId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueOfDomain, + ): Unit = + try { + DomainId.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/RemoveKeyValueOfTrigger.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RemoveKeyValueOfTrigger.kt index a56c4aef6..ac9a022d2 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class RemoveKeyValueOfTrigger( public val `object`: TriggerId, public val key: Name, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RemoveKeyValueOfTrigger = try { - RemoveKeyValueOfTrigger( - TriggerId.read(reader), - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RemoveKeyValueOfTrigger = + try { + RemoveKeyValueOfTrigger( + TriggerId.read(reader), + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RemoveKeyValueOfTrigger): Unit = try { - TriggerId.write(writer, instance.`object`) - Name.write(writer, instance.key) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RemoveKeyValueOfTrigger, + ): Unit = + try { + TriggerId.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/Repeats.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/Repeats.kt index 3e24b8c18..9c453e1c4 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 @@ -26,13 +26,17 @@ public sealed class Repeats : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Indefinitely -> Indefinitely.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is Indefinitely -> Indefinitely.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is Indefinitely -> Indefinitely.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is Indefinitely -> Indefinitely.hashCode() + else -> super.hashCode() + } /** * 'Indefinitely' variant @@ -45,24 +49,30 @@ public sealed class Repeats : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely = try { - Indefinitely() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely = + try { + Indefinitely() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.Repeats.Indefinitely, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".Repeats.Indefinitely".hashCode() } @@ -81,40 +91,45 @@ public sealed class Repeats : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Repeats.Exactly = try { - Exactly( - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.Repeats.Exactly = + try { + Exactly( + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + writer.writeUint32(instance.u32) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: Repeats) { + 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..b7f414db4 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 @@ -20,20 +20,25 @@ public data class RepetitionError( public val id: IdBox, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RepetitionError = try { - RepetitionError( - InstructionType.read(reader), - IdBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RepetitionError = + try { + RepetitionError( + InstructionType.read(reader), + IdBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RepetitionError): Unit = try { - InstructionType.write(writer, instance.instruction) - IdBox.write(writer, instance.id) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RepetitionError, + ): Unit = + try { + InstructionType.write(writer, instance.instruction) + IdBox.write(writer, instance.id) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..9484358cf 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 @@ -36,22 +36,24 @@ public sealed class RevokeBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.Permission = try { - Permission( - RevokeOfPermissionAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.Permission = + try { + Permission( + RevokeOfPermissionAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RevokeOfPermissionAndAccount.write(writer, instance.revokeOfPermissionAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -80,11 +82,12 @@ public sealed class RevokeBox : ModelEnum { 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) - } + ): Unit = + try { + RevokeOfRoleIdAndAccount.write(writer, instance.revokeOfRoleIdAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,42 +104,47 @@ public sealed class RevokeBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.RolePermission = try { - RolePermission( - RevokeOfPermissionAndRole.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RevokeBox.RolePermission = + try { + RolePermission( + RevokeOfPermissionAndRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RevokeOfPermissionAndRole.write(writer, instance.revokeOfPermissionAndRole) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: RevokeBox) { + override fun write( + writer: ScaleCodecWriter, + instance: RevokeBox, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..6ce4f77ec 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class RevokeOfPermissionAndAccount( public val `object`: Permission, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RevokeOfPermissionAndAccount = try { - RevokeOfPermissionAndAccount( - Permission.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RevokeOfPermissionAndAccount = + try { + RevokeOfPermissionAndAccount( + Permission.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RevokeOfPermissionAndAccount): Unit = try { - Permission.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RevokeOfPermissionAndAccount, + ): Unit = + try { + Permission.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..167d8536e 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class RevokeOfPermissionAndRole( public val `object`: Permission, public val destination: RoleId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RevokeOfPermissionAndRole = try { - RevokeOfPermissionAndRole( - Permission.read(reader), - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RevokeOfPermissionAndRole = + try { + RevokeOfPermissionAndRole( + Permission.read(reader), + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RevokeOfPermissionAndRole): Unit = try { - Permission.write(writer, instance.`object`) - RoleId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RevokeOfPermissionAndRole, + ): Unit = + try { + Permission.write(writer, instance.`object`) + RoleId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..6ccad1349 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 @@ -18,24 +21,31 @@ import kotlin.Unit public data class RevokeOfRoleIdAndAccount( public val `object`: RoleId, public val destination: AccountId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RevokeOfRoleIdAndAccount = try { - RevokeOfRoleIdAndAccount( - RoleId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RevokeOfRoleIdAndAccount = + try { + RevokeOfRoleIdAndAccount( + RoleId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RevokeOfRoleIdAndAccount): Unit = try { - RoleId.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RevokeOfRoleIdAndAccount, + ): Unit = + try { + RoleId.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..a947189ed 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 @@ -22,25 +22,31 @@ public data class Role( public val permissions: List, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Role = try { - Role( - RoleId.read(reader), - reader.readVec(reader.readCompactInt()) { Permission.read(reader) }, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Role = + try { + Role( + RoleId.read(reader), + reader.readVec(reader.readCompactInt()) { Permission.read(reader) }, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Role): Unit = try { - RoleId.write(writer, instance.id) - writer.writeCompact(instance.permissions.size) - instance.permissions.sortedWith( - Permission.comparator(), - ).forEach { value -> - Permission.write(writer, value) + override fun write( + writer: ScaleCodecWriter, + instance: Role, + ): Unit = + try { + RoleId.write(writer, instance.id) + writer.writeCompact(instance.permissions.size) + instance.permissions + .sortedWith( + Permission.comparator(), + ).forEach { value -> + Permission.write(writer, value) + } + } catch (ex: Exception) { + throw wrapException(ex) } - } catch (ex: Exception) { - throw wrapException(ex) - } } } 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..444e4a69f 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 @@ -36,22 +36,24 @@ public sealed class RoleEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.Created = try { - Created( - Role.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.Created = + try { + Created( + Role.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Role.write(writer, instance.role) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class RoleEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.Deleted = try { - Deleted( - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.Deleted = + try { + Deleted( + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RoleId.write(writer, instance.roleId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class RoleEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionAdded = try { - PermissionAdded( - RolePermissionChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionAdded = + try { + PermissionAdded( + RolePermissionChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + RolePermissionChanged.write(writer, instance.rolePermissionChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,44 +138,49 @@ public sealed class RoleEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionRemoved = try { - PermissionRemoved( - RolePermissionChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.RoleEvent.PermissionRemoved = + try { + PermissionRemoved( + RolePermissionChanged.read(reader), + ) + } 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) - } + ): 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() - ) { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: RoleEvent) { + override fun write( + writer: ScaleCodecWriter, + instance: RoleEvent, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) 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..0fb0e6910 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 @@ -21,20 +21,25 @@ public data class RoleEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RoleEventFilter = try { - RoleEventFilter( - reader.readNullable(RoleId) as RoleId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RoleEventFilter = + try { + RoleEventFilter( + reader.readNullable(RoleId) as RoleId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RoleEventFilter): Unit = try { - writer.writeNullable(RoleId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RoleEventFilter, + ): Unit = + try { + writer.writeNullable(RoleId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..e8e2564a2 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 @@ -19,18 +19,23 @@ public data class RoleId( public val name: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RoleId = try { - RoleId( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RoleId = + try { + RoleId( + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RoleId): Unit = try { - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RoleId, + ): 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/RoleIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateAtom.kt new file mode 100644 index 000000000..b5ea3f555 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateAtom.kt @@ -0,0 +1,78 @@ +// +// 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/RoleIdPredicateBox.kt deleted file mode 100644 index b135134c4..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdPredicateBox.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 - -/** - * RoleIdPredicateBox - * - * Generated from 'RoleIdPredicateBox' enum - */ -public sealed class RoleIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val roleId: RoleId, - ) : RoleIdPredicateBox() { - 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.RoleIdPredicateBox.Equals = try { - Equals( - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Equals, - ): Unit = try { - RoleId.write(writer, instance.roleId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Name' variant - */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : RoleIdPredicateBox() { - 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.RoleIdPredicateBox.Name = try { - Name( - StringPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.RoleIdPredicateBox.Name, - ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) - } 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) - 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: RoleIdPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 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/RoleIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..3a834b4fc --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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 + +/** + * RoleIdProjectionOfPredicateMarker + * + * Generated from 'RoleIdProjectionOfPredicateMarker' enum + */ +public sealed class RoleIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val roleIdPredicateAtom: RoleIdPredicateAtom, + ) : RoleIdProjectionOfPredicateMarker() { + 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.RoleIdProjectionOfPredicateMarker.Atom = + try { + Atom( + RoleIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Atom, + ): Unit = + try { + RoleIdPredicateAtom.write(writer, instance.roleIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Name' variant + */ + public data class Name( + public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker, + ) : RoleIdProjectionOfPredicateMarker() { + 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.RoleIdProjectionOfPredicateMarker.Name = + try { + Name( + NameProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.RoleIdProjectionOfPredicateMarker.Name, + ): Unit = + try { + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: RoleIdProjectionOfPredicateMarker, + ) { + 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/RoleIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..4fb80f3b8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleIdProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..731d1f81b 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 @@ -20,20 +20,25 @@ public data class RolePermissionChanged( public val permission: Permission, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): RolePermissionChanged = try { - RolePermissionChanged( - RoleId.read(reader), - Permission.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): RolePermissionChanged = + try { + RolePermissionChanged( + RoleId.read(reader), + Permission.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: RolePermissionChanged): Unit = try { - RoleId.write(writer, instance.role) - Permission.write(writer, instance.permission) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: RolePermissionChanged, + ): Unit = + try { + RoleId.write(writer, instance.role) + Permission.write(writer, instance.permission) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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/RolePredicateAtom.kt similarity index 51% 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/RolePredicateAtom.kt index b6746406a..5d5050e1e 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/RolePredicateAtom.kt @@ -11,27 +11,30 @@ import jp.co.soramitsu.iroha2.codec.ScaleWriter import kotlin.Int /** - * AssetValuePredicateBox + * RolePredicateAtom * - * Generated from 'AssetValuePredicateBox' enum + * Generated from 'RolePredicateAtom' enum */ -public sealed class AssetValuePredicateBox : ModelEnum { +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): 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): RolePredicateAtom = + 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: RolePredicateAtom, + ) { 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/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..7742c93b5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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..f55f53e75 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/RoleProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..b38a5ad91 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 @@ -21,20 +21,25 @@ public data class Schedule( public val periodMs: BigInteger? = null, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Schedule = try { - Schedule( - reader.readUint64(), - reader.readNullable(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Schedule = + try { + Schedule( + reader.readUint64(), + reader.readNullable(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Schedule): Unit = try { - writer.writeUint64(instance.startMs) - writer.writeNullable(instance.periodMs) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Schedule, + ): Unit = + try { + writer.writeUint64(instance.startMs) + writer.writeNullable(instance.periodMs) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..e26604694 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAccount.kt @@ -0,0 +1,47 @@ +// +// 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..b11a667f5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAsset.kt @@ -0,0 +1,45 @@ +// +// 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..f168b11bf --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfAssetDefinition.kt @@ -0,0 +1,47 @@ +// +// 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..435eb170a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfBlockHeader.kt @@ -0,0 +1,47 @@ +// +// 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..d86f1d233 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfCommittedTransaction.kt @@ -0,0 +1,47 @@ +// +// 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..7342b5237 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfDomain.kt @@ -0,0 +1,45 @@ +// +// 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..c107edb95 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPeerId.kt @@ -0,0 +1,45 @@ +// +// 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..646aec579 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfPermission.kt @@ -0,0 +1,47 @@ +// +// 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..332a76777 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRole.kt @@ -0,0 +1,45 @@ +// +// 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..ce3f0f5c8 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfRoleId.kt @@ -0,0 +1,45 @@ +// +// 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..517f06f56 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfSignedBlock.kt @@ -0,0 +1,47 @@ +// +// 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..d49da503a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTrigger.kt @@ -0,0 +1,47 @@ +// +// 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..ac31b4219 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SelectorTupleOfTriggerId.kt @@ -0,0 +1,47 @@ +// +// 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..c8c4609fa 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 @@ -36,22 +36,24 @@ public sealed class SetKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Domain = try { - Domain( - SetKeyValueOfDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Domain = + try { + Domain( + SetKeyValueOfDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SetKeyValueOfDomain.write(writer, instance.setKeyValueOfDomain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class SetKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Account = try { - Account( - SetKeyValueOfAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Account = + try { + Account( + SetKeyValueOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SetKeyValueOfAccount.write(writer, instance.setKeyValueOfAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class SetKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.AssetDefinition = try { - AssetDefinition( - SetKeyValueOfAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.AssetDefinition = + try { + AssetDefinition( + SetKeyValueOfAssetDefinition.read(reader), + ) + } 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) - } + ): Unit = + try { + SetKeyValueOfAssetDefinition.write(writer, instance.setKeyValueOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class SetKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Asset = try { - Asset( - SetKeyValueOfAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Asset = + try { + Asset( + SetKeyValueOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SetKeyValueOfAsset.write(writer, instance.setKeyValueOfAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,38 +172,42 @@ public sealed class SetKeyValueBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Trigger = try { - Trigger( - SetKeyValueOfTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SetKeyValueBox.Trigger = + try { + Trigger( + SetKeyValueOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SetKeyValueOfTrigger.write(writer, instance.setKeyValueOfTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueBox, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: SetKeyValueBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Domain.write(writer, instance as Domain) @@ -203,7 +215,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..e32223741 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,25 +21,32 @@ 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetKeyValueOfAccount = + try { + SetKeyValueOfAccount( + AccountId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueOfAccount, + ): Unit = + try { + AccountId.write(writer, instance.`object`) + Name.write(writer, instance.key) + 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..1e18b21e9 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,25 +21,32 @@ 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetKeyValueOfAsset = + try { + SetKeyValueOfAsset( + AssetId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueOfAsset, + ): Unit = + try { + AssetId.write(writer, instance.`object`) + Name.write(writer, instance.key) + 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..37d4af12e 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,27 +21,34 @@ 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 { - override fun read(reader: ScaleCodecReader): SetKeyValueOfAssetDefinition = try { - SetKeyValueOfAssetDefinition( - AssetDefinitionId.read(reader), - Name.read(reader), - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetKeyValueOfAssetDefinition = + try { + SetKeyValueOfAssetDefinition( + AssetDefinitionId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueOfAssetDefinition, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.`object`) + Name.write(writer, instance.key) + 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..69f7b811b 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,25 +21,32 @@ 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetKeyValueOfDomain = + try { + SetKeyValueOfDomain( + DomainId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueOfDomain, + ): Unit = + try { + DomainId.write(writer, instance.`object`) + Name.write(writer, instance.key) + 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..e3c07a479 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,25 +21,32 @@ 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(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetKeyValueOfTrigger = + try { + SetKeyValueOfTrigger( + TriggerId.read(reader), + Name.read(reader), + Json.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetKeyValueOfTrigger, + ): Unit = + try { + TriggerId.write(writer, instance.`object`) + Name.write(writer, instance.key) + 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..927e3d08d 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ public data class SetParameter( public val parameter: Parameter, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SetParameter = try { - SetParameter( - Parameter.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SetParameter = + try { + SetParameter( + Parameter.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SetParameter): Unit = try { - Parameter.write(writer, instance.parameter) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SetParameter, + ): Unit = + try { + Parameter.write(writer, instance.parameter) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..bce52915f 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 @@ -32,18 +32,23 @@ public data class Signature( override fun hashCode(): Int = payload.contentHashCode() public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Signature = try { - Signature( - reader.readByteArray(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Signature = + try { + Signature( + reader.readByteArray(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Signature): Unit = try { - writer.writeAsList(instance.payload) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Signature, + ): Unit = + try { + writer.writeAsList(instance.payload) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..125230803 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 @@ -20,18 +20,23 @@ public data class SignatureOf( public val signature: Signature, ) { public companion object : ScaleReader>, ScaleWriter> { - override fun read(reader: ScaleCodecReader): SignatureOf = try { - SignatureOf( - Signature.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SignatureOf = + try { + SignatureOf( + Signature.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SignatureOf): Unit = try { - Signature.write(writer, instance.signature) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SignatureOf, + ): Unit = + try { + Signature.write(writer, instance.signature) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..cabaae0ce 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 @@ -48,27 +48,31 @@ public sealed class SignedBlock : ModelEnum { 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) - } + ): Unit = + try { + SignedBlockV1.write(writer, instance.signedBlockV1) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SignedBlock) { + 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..0dcd217b5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateAtom.kt @@ -0,0 +1,42 @@ +// +// 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/SignedBlockPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateBox.kt deleted file mode 100644 index 57b480932..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockPredicateBox.kt +++ /dev/null @@ -1,75 +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 - -/** - * SignedBlockPredicateBox - * - * Generated from 'SignedBlockPredicateBox' enum - */ -public sealed class SignedBlockPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Header' variant - */ - public data class Header( - public val blockHeaderPredicateBox: BlockHeaderPredicateBox, - ) : SignedBlockPredicateBox() { - 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.SignedBlockPredicateBox.Header = try { - Header( - BlockHeaderPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SignedBlockPredicateBox.Header, - ): Unit = try { - BlockHeaderPredicateBox.write(writer, instance.blockHeaderPredicateBox) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - 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") } - - override fun write(writer: ScaleCodecWriter, instance: SignedBlockPredicateBox) { - 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") } - } - } -} 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..bd7a73f55 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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..aa19fe59a --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedBlockProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..98caad323 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,25 +21,37 @@ 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), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + 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) + } - override fun write(writer: ScaleCodecWriter, instance: SignedBlockV1): Unit = try { - writer.writeCompact(instance.signatures.size) - instance.signatures.forEach { value -> - BlockSignature.write(writer, value) + override fun write( + writer: ScaleCodecWriter, + instance: SignedBlockV1, + ): Unit = + try { + writer.writeCompact(instance.signatures.size) + instance.signatures.forEach { value -> + 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) } - BlockPayload.write(writer, instance.payload) - } 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..a65267acb 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 @@ -48,27 +48,31 @@ public sealed class SignedQuery : ModelEnum { 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) - } + ): Unit = + try { + SignedQueryV1.write(writer, instance.signedQueryV1) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SignedQuery) { + 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..417a912b1 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 @@ -17,23 +17,28 @@ import kotlin.Unit */ public data class SignedQueryV1( public val signature: QuerySignature, - public val payload: ClientQueryPayload, + public val payload: QueryRequestWithAuthority, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedQueryV1 = try { - SignedQueryV1( - QuerySignature.read(reader), - ClientQueryPayload.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SignedQueryV1 = + try { + SignedQueryV1( + QuerySignature.read(reader), + QueryRequestWithAuthority.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SignedQueryV1): Unit = try { - QuerySignature.write(writer, instance.signature) - ClientQueryPayload.write(writer, instance.payload) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SignedQueryV1, + ): Unit = + try { + QuerySignature.write(writer, instance.signature) + 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..68ab1b5ea 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 @@ -36,38 +36,43 @@ public sealed class SignedTransaction : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedTransaction.V1 = try { - V1( - SignedTransactionV1.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SignedTransaction.V1 = + try { + V1( + SignedTransactionV1.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SignedTransactionV1.write(writer, instance.signedTransactionV1) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SignedTransaction) { + 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..d32fbef90 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionPredicateAtom.kt @@ -0,0 +1,42 @@ +// +// 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..150420ffe --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfPredicateMarker.kt @@ -0,0 +1,158 @@ +// +// 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..318625f2e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SignedTransactionProjectionOfSelectorMarker.kt @@ -0,0 +1,174 @@ +// +// 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..60e4578ae 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 @@ -20,20 +20,25 @@ public data class SignedTransactionV1( public val payload: TransactionPayload, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SignedTransactionV1 = try { - SignedTransactionV1( - TransactionSignature.read(reader), - TransactionPayload.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SignedTransactionV1 = + try { + SignedTransactionV1( + TransactionSignature.read(reader), + TransactionPayload.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SignedTransactionV1): Unit = try { - TransactionSignature.write(writer, instance.signature) - TransactionPayload.write(writer, instance.payload) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SignedTransactionV1, + ): Unit = + try { + TransactionSignature.write(writer, instance.signature) + TransactionPayload.write(writer, instance.payload) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..bfa5f3e5e 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 @@ -24,71 +24,35 @@ public sealed class SingularQueryBox : ModelEnum { public abstract fun discriminant(): Int /** - * 'FindAssetQuantityById' variant + * 'FindExecutorDataModel' variant */ - public data class FindAssetQuantityById( - public val findAssetQuantityById: jp.co.soramitsu.iroha2.generated.FindAssetQuantityById, + public data class FindExecutorDataModel( + public val findExecutorDataModel: jp.co.soramitsu.iroha2.generated.FindExecutorDataModel, ) : SingularQueryBox() { 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.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 = + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindExecutorDataModel = try { - jp.co.soramitsu.iroha2.generated.FindAssetQuantityById.write( - writer, - instance.findAssetQuantityById, + FindExecutorDataModel( + jp.co.soramitsu.iroha2.generated.FindExecutorDataModel + .read(reader), ) } catch (ex: Exception) { throw wrapException(ex) } - } - } - - /** - * 'FindExecutorDataModel' variant - */ - 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 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.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.SingularQueryBox.FindExecutorDataModel, ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindExecutorDataModel.write( - writer, - instance.findExecutorDataModel, - ) + jp.co.soramitsu.iroha2.generated.FindExecutorDataModel + .write(writer, instance.findExecutorDataModel) } catch (ex: Exception) { throw wrapException(ex) } @@ -106,230 +70,49 @@ public sealed class SingularQueryBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 2 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters = try { - FindParameters( - jp.co.soramitsu.iroha2.generated.FindParameters.read(reader), - ) - } catch (ex: Exception) { - 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) - } + public const val DISCRIMINANT: Int = 1 - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindDomainMetadata, - ): Unit = + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters = try { - jp.co.soramitsu.iroha2.generated.FindDomainMetadata.write( - writer, - instance.findDomainMetadata, + FindParameters( + jp.co.soramitsu.iroha2.generated.FindParameters + .read(reader), ) } 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, + instance: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindParameters, ): Unit = try { - jp.co.soramitsu.iroha2.generated.FindAccountMetadata.write( - writer, - instance.findAccountMetadata, - ) + jp.co.soramitsu.iroha2.generated.FindParameters + .write(writer, instance.findParameters) } 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) + public companion object : ScaleReader, ScaleWriter { + 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: jp.co.soramitsu.iroha2.generated.SingularQueryBox.FindTriggerMetadata, - ): Unit = - try { - jp.co.soramitsu.iroha2.generated.FindTriggerMetadata.write( - writer, - instance.findTriggerMetadata, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SingularQueryBox = when ( - val discriminant = - reader.readUByte() + override fun write( + writer: ScaleCodecWriter, + instance: SingularQueryBox, ) { - 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 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..cc2117e78 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,38 +23,6 @@ public sealed class SingularQueryOutputBox : ModelEnum { */ public abstract fun discriminant(): Int - /** - * 'Numeric' variant - */ - public data class Numeric( - public val numeric: jp.co.soramitsu.iroha2.generated.Numeric, - ) : SingularQueryOutputBox() { - override fun discriminant(): Int = DISCRIMINANT - - public companion object : - ScaleReader, - ScaleWriter { - public const val DISCRIMINANT: Int = 0 - - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Numeric = try { - Numeric( - jp.co.soramitsu.iroha2.generated.Numeric.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Numeric, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Numeric.write(writer, instance.numeric) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - /** * 'ExecutorDataModel' variant */ @@ -67,88 +34,28 @@ public sealed class SingularQueryOutputBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 1 + public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.ExecutorDataModel = try { - ExecutorDataModel( - jp.co.soramitsu.iroha2.generated.ExecutorDataModel.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.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.SingularQueryOutputBox.ExecutorDataModel, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.ExecutorDataModel.write(writer, instance.executorDataModel) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * '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) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.ExecutorDataModel + .write(writer, instance.executorDataModel) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -163,116 +70,51 @@ public sealed class SingularQueryOutputBox : ModelEnum { public companion object : ScaleReader, ScaleWriter { - public const val DISCRIMINANT: Int = 4 + public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.Parameters = try { - Parameters( - jp.co.soramitsu.iroha2.generated.Parameters.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SingularQueryOutputBox.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.SingularQueryOutputBox.Parameters, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.Parameters.write(writer, instance.parameters) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.Parameters + .write(writer, instance.parameters) + } catch (ex: Exception) { + throw wrapException(ex) + } } } - /** - * '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) + 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") } - 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() + override fun write( + writer: ScaleCodecWriter, + instance: SingularQueryOutputBox, ) { - 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..dd4d1f722 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 @@ -36,22 +36,24 @@ public sealed class SmartContractParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SmartContractParameter.Fuel = try { - Fuel( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SmartContractParameter.Fuel = + try { + Fuel( + NonZeroOfu64.read(reader), + ) + } 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) - } + ): Unit = + try { + NonZeroOfu64.write(writer, instance.nonZeroOfu64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,47 @@ public sealed class SmartContractParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SmartContractParameter.Memory = try { - Memory( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SmartContractParameter.Memory = + try { + Memory( + NonZeroOfu64.read(reader), + ) + } 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) - } + ): 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() - ) { - 0 -> Fuel.read(reader) - 1 -> Memory.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SmartContractParameter) { + 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..e84f5973a 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 @@ -22,20 +22,25 @@ public data class SmartContractParameters( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SmartContractParameters = try { - SmartContractParameters( - NonZeroOfu64.read(reader), - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SmartContractParameters = + try { + SmartContractParameters( + NonZeroOfu64.read(reader), + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SmartContractParameters): Unit = try { - NonZeroOfu64.write(writer, instance.fuel) - NonZeroOfu64.write(writer, instance.memory) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SmartContractParameters, + ): Unit = + try { + NonZeroOfu64.write(writer, instance.fuel) + NonZeroOfu64.write(writer, instance.memory) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..8818835a1 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 @@ -36,22 +36,24 @@ public sealed class SocketAddr : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv4 = try { - Ipv4( - SocketAddrV4.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv4 = + try { + Ipv4( + SocketAddrV4.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SocketAddrV4.write(writer, instance.socketAddrV4) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class SocketAddr : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv6 = try { - Ipv6( - SocketAddrV6.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Ipv6 = + try { + Ipv6( + SocketAddrV6.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SocketAddrV6.write(writer, instance.socketAddrV6) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,42 +104,47 @@ public sealed class SocketAddr : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Host = try { - Host( - SocketAddrHost.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SocketAddr.Host = + try { + Host( + SocketAddrHost.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + SocketAddrHost.write(writer, instance.socketAddrHost) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SocketAddr) { + override fun write( + writer: ScaleCodecWriter, + instance: SocketAddr, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..359c909fd 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 @@ -22,20 +22,25 @@ public data class SocketAddrHost( public val port: Int, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SocketAddrHost = try { - SocketAddrHost( - reader.readString(), - reader.readUint16(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SocketAddrHost = + try { + SocketAddrHost( + reader.readString(), + reader.readUint16(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SocketAddrHost): Unit = try { - writer.writeAsList(instance.host.toByteArray(Charsets.UTF_8)) - writer.writeUint16(instance.port) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SocketAddrHost, + ): Unit = + try { + writer.writeAsList(instance.host.toByteArray(Charsets.UTF_8)) + writer.writeUint16(instance.port) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..8c4aa1eb4 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 @@ -21,20 +21,25 @@ public data class SocketAddrV4( public val port: Int, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SocketAddrV4 = try { - SocketAddrV4( - Ipv4Addr.read(reader), - reader.readUint16(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SocketAddrV4 = + try { + SocketAddrV4( + Ipv4Addr.read(reader), + reader.readUint16(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SocketAddrV4): Unit = try { - Ipv4Addr.write(writer, instance.ip) - writer.writeUint16(instance.port) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SocketAddrV4, + ): Unit = + try { + Ipv4Addr.write(writer, instance.ip) + writer.writeUint16(instance.port) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..a3888fab4 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 @@ -21,20 +21,25 @@ public data class SocketAddrV6( public val port: Int, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SocketAddrV6 = try { - SocketAddrV6( - Ipv6Addr.read(reader), - reader.readUint16(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SocketAddrV6 = + try { + SocketAddrV6( + Ipv6Addr.read(reader), + reader.readUint16(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SocketAddrV6): Unit = try { - Ipv6Addr.write(writer, instance.ip) - writer.writeUint16(instance.port) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SocketAddrV6, + ): Unit = + try { + Ipv6Addr.write(writer, instance.ip) + writer.writeUint16(instance.port) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..c792af65e 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 @@ -19,18 +19,23 @@ public data class Sorting( public val sortByMetadataKey: Name? = null, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Sorting = try { - Sorting( - reader.readNullable(Name) as Name?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Sorting = + try { + Sorting( + reader.readNullable(Name) as Name?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Sorting): Unit = try { - writer.writeNullable(Name, instance.sortByMetadataKey) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Sorting, + ): Unit = + try { + writer.writeNullable(Name, instance.sortByMetadataKey) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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 52% 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..e827fe75a 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 */ @@ -29,30 +29,32 @@ public sealed class StringPredicateBox : ModelEnum { */ public data class Equals( public val string: String, - ) : StringPredicateBox() { + ) : 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 { - Equals( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Equals = + try { + Equals( + reader.readString(), + ) + } catch (ex: Exception) { + 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) - } + instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Equals, + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -61,30 +63,32 @@ public sealed class StringPredicateBox : ModelEnum { */ public data class Contains( public val string: String, - ) : StringPredicateBox() { + ) : 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 { - Contains( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Contains = + try { + Contains( + reader.readString(), + ) + } catch (ex: Exception) { + 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) - } + instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.Contains, + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -93,30 +97,32 @@ public sealed class StringPredicateBox : ModelEnum { */ public data class StartsWith( public val string: String, - ) : StringPredicateBox() { + ) : 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 { - StartsWith( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.StartsWith = + try { + StartsWith( + reader.readString(), + ) + } catch (ex: Exception) { + 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) - } + instance: jp.co.soramitsu.iroha2.generated.StringPredicateAtom.StartsWith, + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -125,52 +131,57 @@ public sealed class StringPredicateBox : ModelEnum { */ public data class EndsWith( public val string: String, - ) : StringPredicateBox() { + ) : 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 { - EndsWith( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.StringPredicateAtom.EndsWith = + try { + EndsWith( + reader.readString(), + ) + } catch (ex: Exception) { + 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) - } + 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() - ) { - 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") } + 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") + } - 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..53d7aa2c8 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 @@ -37,22 +37,24 @@ public sealed class SumeragiParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.BlockTimeMs = try { - BlockTimeMs( - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.BlockTimeMs = + try { + BlockTimeMs( + reader.readUint64(), + ) + } 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) - } + ): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -69,22 +71,24 @@ public sealed class SumeragiParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.CommitTimeMs = try { - CommitTimeMs( - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.CommitTimeMs = + try { + CommitTimeMs( + reader.readUint64(), + ) + } 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) - } + ): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -101,42 +105,47 @@ public sealed class SumeragiParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.MaxClockDriftMs = try { - MaxClockDriftMs( - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.SumeragiParameter.MaxClockDriftMs = + try { + MaxClockDriftMs( + reader.readUint64(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.SumeragiParameter.MaxClockDriftMs, - ): Unit = try { - writer.writeUint64(instance.u64) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + writer.writeUint64(instance.u64) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: SumeragiParameter) { + override fun write( + writer: ScaleCodecWriter, + instance: SumeragiParameter, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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/SumeragiParameters.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameters.kt index 3ef3f285f..546f225b9 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameters.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/SumeragiParameters.kt @@ -22,22 +22,27 @@ public data class SumeragiParameters( public val maxClockDriftMs: BigInteger, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): SumeragiParameters = try { - SumeragiParameters( - reader.readUint64(), - reader.readUint64(), - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): SumeragiParameters = + try { + SumeragiParameters( + reader.readUint64(), + reader.readUint64(), + reader.readUint64(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: SumeragiParameters): Unit = try { - writer.writeUint64(instance.blockTimeMs) - writer.writeUint64(instance.commitTimeMs) - writer.writeUint64(instance.maxClockDriftMs) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: SumeragiParameters, + ): Unit = + try { + writer.writeUint64(instance.blockTimeMs) + writer.writeUint64(instance.commitTimeMs) + writer.writeUint64(instance.maxClockDriftMs) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..ac4010ecc 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 @@ -16,24 +16,26 @@ import kotlin.Unit * Generated from 'TimeEvent' regular structure */ public data class TimeEvent( - public val prevInterval: TimeInterval? = null, 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) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TimeEvent = + try { + TimeEvent( + TimeInterval.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - 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) - } + override fun write( + writer: ScaleCodecWriter, + instance: TimeEvent, + ): Unit = + try { + 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..bb5df0482 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 @@ -19,18 +19,23 @@ public data class TimeEventFilter( public val executionTime: ExecutionTime, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TimeEventFilter = try { - TimeEventFilter( - ExecutionTime.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TimeEventFilter = + try { + TimeEventFilter( + ExecutionTime.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TimeEventFilter): Unit = try { - ExecutionTime.write(writer, instance.executionTime) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TimeEventFilter, + ): Unit = + try { + ExecutionTime.write(writer, instance.executionTime) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..33abf74f8 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 @@ -21,20 +21,25 @@ public data class TimeInterval( public val lengthMs: BigInteger, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TimeInterval = try { - TimeInterval( - reader.readUint64(), - reader.readUint64(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TimeInterval = + try { + TimeInterval( + reader.readUint64(), + reader.readUint64(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TimeInterval): Unit = try { - writer.writeUint64(instance.sinceMs) - writer.writeUint64(instance.lengthMs) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TimeInterval, + ): Unit = + try { + writer.writeUint64(instance.sinceMs) + writer.writeUint64(instance.lengthMs) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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 54% 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..4a379aeff 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,44 +15,49 @@ 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 */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is IsSome -> IsSome.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is IsSome -> IsSome.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is IsSome -> IsSome.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is IsSome -> IsSome.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 { - IsSome() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome = + try { + IsSome() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateBox.IsSome, + instance: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome, ): Unit = try { } catch (ex: Exception) { @@ -60,32 +65,36 @@ public sealed class TransactionErrorPredicateBox : ModelEnum { } public fun equals( - o1: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateBox.IsSome, + o1: jp.co.soramitsu.iroha2.generated.TransactionErrorPredicateAtom.IsSome, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): 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() - ) { - 0 -> IsSome.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - 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..25a87f33d --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..d6950d433 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionErrorProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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/TransactionEvent.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEvent.kt index 7983c2327..524f30ae0 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEvent.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionEvent.kt @@ -21,22 +21,27 @@ public data class TransactionEvent( public val status: TransactionStatus, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionEvent = try { - TransactionEvent( - HashOf.read(reader) as HashOf, - reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, - TransactionStatus.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransactionEvent = + try { + TransactionEvent( + HashOf.read(reader) as HashOf, + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + TransactionStatus.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionEvent): Unit = try { - HashOf.write(writer, instance.hash) - writer.writeNullable(NonZeroOfu64, instance.blockHeight) - TransactionStatus.write(writer, instance.status) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionEvent, + ): Unit = + try { + HashOf.write(writer, instance.hash) + writer.writeNullable(NonZeroOfu64, instance.blockHeight) + TransactionStatus.write(writer, instance.status) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..6c5a087e7 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,23 +20,30 @@ public data class TransactionEventFilter( public val blockHeight: NonZeroOfu64? = null, public val status: TransactionStatus? = null, ) { - public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionEventFilter = try { - TransactionEventFilter( - reader.readNullable(HashOf) as HashOf?, - reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, - reader.readNullable(TransactionStatus) as TransactionStatus?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + public companion object : + ScaleReader, + ScaleWriter { + override fun read(reader: ScaleCodecReader): TransactionEventFilter = + try { + TransactionEventFilter( + reader.readNullable(HashOf) as HashOf?, + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + reader.readNullable(TransactionStatus) as TransactionStatus?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionEventFilter): Unit = try { - writer.writeNullable(HashOf, instance.hash) - writer.writeNullable(NonZeroOfu64, instance.blockHeight) - writer.writeNullable(TransactionStatus, instance.status) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionEventFilter, + ): Unit = + try { + writer.writeNullable(HashOf, instance.hash) + writer.writeNullable(NonZeroOfu64, instance.blockHeight) + writer.writeNullable(TransactionStatus, instance.status) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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 54% 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..e83c2eb80 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 */ @@ -28,48 +28,53 @@ public sealed class TransactionHashPredicateBox : ModelEnum { */ public data class Equals( public val hashOf: HashOf, - ) : TransactionHashPredicateBox() { + ) : 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 { - Equals( - HashOf.read(reader) as HashOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionHashPredicateAtom.Equals = + try { + Equals( + HashOf.read(reader) as HashOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TransactionHashPredicateBox.Equals, - ): Unit = try { - HashOf.write(writer, instance.hashOf) - } catch (ex: Exception) { - throw wrapException(ex) - } + instance: jp.co.soramitsu.iroha2.generated.TransactionHashPredicateAtom.Equals, + ): Unit = + try { + HashOf.write(writer, instance.hashOf) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : - ScaleReader, - ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionHashPredicateBox = when ( - val discriminant = - reader.readUByte() - ) { - 0 -> Equals.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - 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..17c8f274e --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfPredicateMarker.kt @@ -0,0 +1,80 @@ +// +// 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..734059614 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionHashProjectionOfSelectorMarker.kt @@ -0,0 +1,100 @@ +// +// 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..f37ccded8 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 @@ -20,18 +20,23 @@ public data class TransactionLimitError( public val reason: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionLimitError = try { - TransactionLimitError( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransactionLimitError = + try { + TransactionLimitError( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionLimitError): Unit = try { - writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionLimitError, + ): Unit = + try { + writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..52bea2bd2 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 @@ -36,13 +36,14 @@ public sealed class TransactionParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionParameter.MaxInstructions = try { - MaxInstructions( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionParameter.MaxInstructions = + try { + MaxInstructions( + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -69,13 +70,14 @@ public sealed class TransactionParameter : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionParameter.SmartContractSize = try { - SmartContractSize( - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionParameter.SmartContractSize = + try { + SmartContractSize( + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -90,20 +92,23 @@ public sealed class TransactionParameter : ModelEnum { } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TransactionParameter) { + 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..16f8d2e5c 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 @@ -20,20 +20,25 @@ public data class TransactionParameters( public val smartContractSize: NonZeroOfu64, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionParameters = try { - TransactionParameters( - NonZeroOfu64.read(reader), - NonZeroOfu64.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransactionParameters = + try { + TransactionParameters( + NonZeroOfu64.read(reader), + NonZeroOfu64.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionParameters): Unit = try { - NonZeroOfu64.write(writer, instance.maxInstructions) - NonZeroOfu64.write(writer, instance.smartContractSize) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionParameters, + ): Unit = + try { + NonZeroOfu64.write(writer, instance.maxInstructions) + NonZeroOfu64.write(writer, instance.smartContractSize) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionPayload.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionPayload.kt index 5ec04fa3a..a4f53c540 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionPayload.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TransactionPayload.kt @@ -26,30 +26,35 @@ public data class TransactionPayload( public val metadata: Metadata, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionPayload = try { - TransactionPayload( - ChainId.read(reader), - AccountId.read(reader), - reader.readUint64(), - Executable.read(reader), - reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, - reader.readNullable(NonZeroOfu32) as NonZeroOfu32?, - Metadata.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransactionPayload = + try { + TransactionPayload( + ChainId.read(reader), + AccountId.read(reader), + reader.readUint64(), + Executable.read(reader), + reader.readNullable(NonZeroOfu64) as NonZeroOfu64?, + reader.readNullable(NonZeroOfu32) as NonZeroOfu32?, + Metadata.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionPayload): Unit = try { - ChainId.write(writer, instance.chain) - AccountId.write(writer, instance.authority) - writer.writeUint64(instance.creationTimeMs) - Executable.write(writer, instance.instructions) - writer.writeNullable(NonZeroOfu64, instance.timeToLiveMs) - writer.writeNullable(NonZeroOfu32, instance.nonce) - Metadata.write(writer, instance.metadata) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionPayload, + ): Unit = + try { + ChainId.write(writer, instance.chain) + AccountId.write(writer, instance.authority) + writer.writeUint64(instance.creationTimeMs) + Executable.write(writer, instance.instructions) + writer.writeNullable(NonZeroOfu64, instance.timeToLiveMs) + writer.writeNullable(NonZeroOfu32, instance.nonce) + Metadata.write(writer, instance.metadata) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..64bdab406 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 @@ -36,22 +36,24 @@ 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, instance: jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.AccountDoesNotExist, - ): Unit = try { - FindError.write(writer, instance.findError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + FindError.write(writer, instance.findError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,13 +70,14 @@ public sealed class TransactionRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.LimitCheck = try { - LimitCheck( - TransactionLimitError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.LimitCheck = + try { + LimitCheck( + TransactionLimitError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -101,13 +104,14 @@ public sealed class TransactionRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.Validation = try { - Validation( - ValidationFail.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.Validation = + try { + Validation( + ValidationFail.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -134,22 +138,24 @@ 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, instance: jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.InstructionExecution, - ): Unit = try { - InstructionExecutionFail.write(writer, instance.instructionExecutionFail) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + InstructionExecutionFail.write(writer, instance.instructionExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -166,40 +172,44 @@ public sealed class TransactionRejectionReason : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.WasmExecution = try { - WasmExecution( - WasmExecutionFail.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.WasmExecution = + try { + WasmExecution( + WasmExecutionFail.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionRejectionReason.WasmExecution, - ): Unit = try { - WasmExecutionFail.write(writer, instance.wasmExecutionFail) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + WasmExecutionFail.write(writer, instance.wasmExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: TransactionRejectionReason, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: TransactionRejectionReason) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> AccountDoesNotExist.write(writer, instance as AccountDoesNotExist) @@ -207,7 +217,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..abb092780 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 @@ -19,18 +19,23 @@ public data class TransactionSignature( public val signatureOfOfTransactionPayload: SignatureOf, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TransactionSignature = try { - TransactionSignature( - SignatureOf.read(reader) as SignatureOf, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransactionSignature = + try { + TransactionSignature( + SignatureOf.read(reader) as SignatureOf, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransactionSignature): Unit = try { - SignatureOf.write(writer, instance.signatureOfOfTransactionPayload) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransactionSignature, + ): Unit = + try { + SignatureOf.write(writer, instance.signatureOfOfTransactionPayload) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..0c821f2b7 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 @@ -25,17 +25,21 @@ public sealed class TransactionStatus : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Queued -> Queued.equals(this, other) - is Expired -> Expired.equals(this, other) - is Approved -> Approved.equals(this, 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() } + override fun equals(other: Any?): Boolean = + when (this) { + is Queued -> Queued.equals(this, other) + is Expired -> Expired.equals(this, other) + is Approved -> Approved.equals(this, 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() + } /** * 'Queued' variant @@ -48,24 +52,30 @@ public sealed class TransactionStatus : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued = try { - Queued() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued = + try { + Queued() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.TransactionStatus.Queued, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TransactionStatus.Queued".hashCode() } @@ -82,24 +92,30 @@ public sealed class TransactionStatus : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired = try { - Expired() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired = + try { + Expired() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired, - ): Unit = try { - } catch (ex: Exception) { - throw wrapException(ex) - } - - public fun equals(o1: jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } + + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.TransactionStatus.Expired, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TransactionStatus.Expired".hashCode() } @@ -116,24 +132,30 @@ public sealed class TransactionStatus : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Approved = try { - Approved() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Approved = + try { + Approved() + } 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 - else -> o2::class == o1::class - } + ): 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 + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TransactionStatus.Approved".hashCode() } @@ -152,44 +174,49 @@ public sealed class TransactionStatus : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Rejected = try { - Rejected( - TransactionRejectionReason.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransactionStatus.Rejected = + try { + Rejected( + TransactionRejectionReason.read(reader), + ) + } 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) - } + ): 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() - ) { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TransactionStatus) { + override fun write( + writer: ScaleCodecWriter, + instance: TransactionStatus, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Queued.write(writer, instance as Queued) 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..a608c4110 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 @@ -36,25 +36,24 @@ public sealed class TransferBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.Domain = try { - Domain( - TransferOfAccountAndDomainIdAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.Domain = + try { + Domain( + TransferOfAccountAndDomainIdAndAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TransferOfAccountAndDomainIdAndAccount.write(writer, instance.transferOfAccountAndDomainIdAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -62,8 +61,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 @@ -72,25 +70,24 @@ public sealed class TransferBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.AssetDefinition = try { - AssetDefinition( - TransferOfAccountAndAssetDefinitionIdAndAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.AssetDefinition = + try { + AssetDefinition( + TransferOfAccountAndAssetDefinitionIdAndAccount.read(reader), + ) + } 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) - } + ): Unit = + try { + TransferOfAccountAndAssetDefinitionIdAndAccount.write(writer, instance.transferOfAccountAndAssetDefinitionIdAndAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -107,42 +104,47 @@ public sealed class TransferBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.Asset = try { - Asset( - AssetTransferBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TransferBox.Asset = + try { + Asset( + AssetTransferBox.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + AssetTransferBox.write(writer, instance.assetTransferBox) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TransferBox) { + override fun write( + writer: ScaleCodecWriter, + instance: TransferBox, + ) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 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..478b00073 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,7 +22,9 @@ 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 { @@ -37,12 +42,13 @@ public data class TransferOfAccountAndAssetDefinitionIdAndAccount( override fun write( writer: ScaleCodecWriter, instance: TransferOfAccountAndAssetDefinitionIdAndAccount, - ): Unit = try { - AccountId.write(writer, instance.source) - AssetDefinitionId.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + AccountId.write(writer, instance.source) + AssetDefinitionId.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..56ecc3806 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,26 +22,33 @@ 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 { - override fun read(reader: ScaleCodecReader): TransferOfAccountAndDomainIdAndAccount = try { - TransferOfAccountAndDomainIdAndAccount( - AccountId.read(reader), - DomainId.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransferOfAccountAndDomainIdAndAccount = + try { + TransferOfAccountAndDomainIdAndAccount( + AccountId.read(reader), + DomainId.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransferOfAccountAndDomainIdAndAccount): Unit = try { - AccountId.write(writer, instance.source) - DomainId.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransferOfAccountAndDomainIdAndAccount, + ): Unit = + try { + AccountId.write(writer, instance.source) + DomainId.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..028a069cc 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,26 +22,33 @@ 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 { - override fun read(reader: ScaleCodecReader): TransferOfAssetAndMetadataAndAccount = try { - TransferOfAssetAndMetadataAndAccount( - AssetId.read(reader), - Metadata.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransferOfAssetAndMetadataAndAccount = + try { + TransferOfAssetAndMetadataAndAccount( + AssetId.read(reader), + Metadata.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransferOfAssetAndMetadataAndAccount): Unit = try { - AssetId.write(writer, instance.source) - Metadata.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransferOfAssetAndMetadataAndAccount, + ): Unit = + try { + AssetId.write(writer, instance.source) + Metadata.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b19aeb791 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,26 +22,33 @@ 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 { - override fun read(reader: ScaleCodecReader): TransferOfAssetAndNumericAndAccount = try { - TransferOfAssetAndNumericAndAccount( - AssetId.read(reader), - Numeric.read(reader), - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TransferOfAssetAndNumericAndAccount = + try { + TransferOfAssetAndNumericAndAccount( + AssetId.read(reader), + Numeric.read(reader), + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TransferOfAssetAndNumericAndAccount): Unit = try { - AssetId.write(writer, instance.source) - Numeric.write(writer, instance.`object`) - AccountId.write(writer, instance.destination) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TransferOfAssetAndNumericAndAccount, + ): Unit = + try { + AssetId.write(writer, instance.source) + Numeric.write(writer, instance.`object`) + AccountId.write(writer, instance.destination) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..07e26884f 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 @@ -20,20 +20,25 @@ public data class Trigger( public val action: Action, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): Trigger = try { - Trigger( - TriggerId.read(reader), - Action.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Trigger = + try { + Trigger( + TriggerId.read(reader), + Action.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Trigger): Unit = try { - TriggerId.write(writer, instance.id) - Action.write(writer, instance.action) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Trigger, + ): Unit = + try { + TriggerId.write(writer, instance.id) + Action.write(writer, instance.action) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b86a3620a 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 @@ -20,20 +20,25 @@ public data class TriggerCompletedEvent( public val outcome: TriggerCompletedOutcome, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerCompletedEvent = try { - TriggerCompletedEvent( - TriggerId.read(reader), - TriggerCompletedOutcome.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TriggerCompletedEvent = + try { + TriggerCompletedEvent( + TriggerId.read(reader), + TriggerCompletedOutcome.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedEvent): Unit = try { - TriggerId.write(writer, instance.triggerId) - TriggerCompletedOutcome.write(writer, instance.outcome) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TriggerCompletedEvent, + ): Unit = + try { + TriggerId.write(writer, instance.triggerId) + TriggerCompletedOutcome.write(writer, instance.outcome) + } catch (ex: Exception) { + throw wrapException(ex) + } } } diff --git a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEventFilter.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEventFilter.kt index e6d935711..82ef08c88 100644 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEventFilter.kt +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerCompletedEventFilter.kt @@ -22,20 +22,25 @@ public data class TriggerCompletedEventFilter( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerCompletedEventFilter = try { - TriggerCompletedEventFilter( - reader.readNullable(TriggerId) as TriggerId?, - reader.readNullable(TriggerCompletedOutcomeType) as TriggerCompletedOutcomeType?, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TriggerCompletedEventFilter = + try { + TriggerCompletedEventFilter( + reader.readNullable(TriggerId) as TriggerId?, + reader.readNullable(TriggerCompletedOutcomeType) as TriggerCompletedOutcomeType?, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedEventFilter): Unit = try { - writer.writeNullable(TriggerId, instance.triggerId) - writer.writeNullable(TriggerCompletedOutcomeType, instance.outcomeType) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TriggerCompletedEventFilter, + ): Unit = + try { + writer.writeNullable(TriggerId, instance.triggerId) + writer.writeNullable(TriggerCompletedOutcomeType, instance.outcomeType) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f7bc160ac 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 @@ -26,13 +26,17 @@ public sealed class TriggerCompletedOutcome : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Success -> Success.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is Success -> Success.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is Success -> Success.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is Success -> Success.hashCode() + else -> super.hashCode() + } /** * 'Success' variant @@ -45,27 +49,30 @@ public sealed class TriggerCompletedOutcome : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success = try { - Success() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success = + try { + Success() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Success, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TriggerCompletedOutcome.Success".hashCode() } @@ -84,42 +91,47 @@ public sealed class TriggerCompletedOutcome : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Failure = try { - Failure( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcome.Failure = + try { + Failure( + reader.readString(), + ) + } 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) - } + ): 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() - ) { - 0 -> Success.read(reader) - 1 -> Failure.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedOutcome) { + 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..c673a02e0 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 @@ -25,15 +25,19 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is Success -> Success.equals(this, other) - is Failure -> Failure.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is Success -> Success.equals(this, other) + is Failure -> Failure.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is Success -> Success.hashCode() - is Failure -> Failure.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is Success -> Success.hashCode() + is Failure -> Failure.hashCode() + else -> super.hashCode() + } /** * 'Success' variant @@ -46,11 +50,12 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success = try { - Success() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success = + try { + Success() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -64,10 +69,11 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { public fun equals( o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Success, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TriggerCompletedOutcomeType.Success".hashCode() } @@ -84,11 +90,12 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure = try { - Failure() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure = + try { + Failure() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, @@ -102,10 +109,11 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { public fun equals( o1: jp.co.soramitsu.iroha2.generated.TriggerCompletedOutcomeType.Failure, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".TriggerCompletedOutcomeType.Failure".hashCode() } @@ -114,20 +122,23 @@ public sealed class TriggerCompletedOutcomeType : ModelEnum { public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TriggerCompletedOutcomeType) { + 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..22aca3df7 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 @@ -36,22 +36,24 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Created = try { - Created( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Created = + try { + Created( + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerId.write(writer, instance.triggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Deleted = try { - Deleted( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Deleted = + try { + Deleted( + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerId.write(writer, instance.triggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Extended = try { - Extended( - TriggerNumberOfExecutionsChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Extended = + try { + Extended( + TriggerNumberOfExecutionsChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerNumberOfExecutionsChanged.write(writer, instance.triggerNumberOfExecutionsChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Shortened = try { - Shortened( - TriggerNumberOfExecutionsChanged.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.Shortened = + try { + Shortened( + TriggerNumberOfExecutionsChanged.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + TriggerNumberOfExecutionsChanged.write(writer, instance.triggerNumberOfExecutionsChanged) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted = try { - MetadataInserted( - MetadataChangedOfTriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted = + try { + MetadataInserted( + MetadataChangedOfTriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataInserted, - ): Unit = try { - MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,39 +206,43 @@ public sealed class TriggerEvent : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved = try { - MetadataRemoved( - MetadataChangedOfTriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved = + try { + MetadataRemoved( + MetadataChangedOfTriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TriggerEvent.MetadataRemoved, - ): Unit = try { - MetadataChangedOfTriggerId.write(writer, instance.metadataChangedOfTriggerId) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: TriggerEvent, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: TriggerEvent) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Created.write(writer, instance as Created) @@ -237,7 +251,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..e8cb5586e 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 @@ -21,20 +21,25 @@ public data class TriggerEventFilter( public val eventSet: Long, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerEventFilter = try { - TriggerEventFilter( - reader.readNullable(TriggerId) as TriggerId?, - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TriggerEventFilter = + try { + TriggerEventFilter( + reader.readNullable(TriggerId) as TriggerId?, + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TriggerEventFilter): Unit = try { - writer.writeNullable(TriggerId, instance.idMatcher) - writer.writeUint32(instance.eventSet) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TriggerEventFilter, + ): Unit = + try { + writer.writeNullable(TriggerId, instance.idMatcher) + writer.writeUint32(instance.eventSet) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..6b307087c 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 @@ -19,18 +19,23 @@ public data class TriggerId( public val name: Name, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerId = try { - TriggerId( - Name.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TriggerId = + try { + TriggerId( + Name.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TriggerId): Unit = try { - Name.write(writer, instance.name) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: TriggerId, + ): 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/TriggerIdPredicateAtom.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateAtom.kt new file mode 100644 index 000000000..875e697f5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateAtom.kt @@ -0,0 +1,80 @@ +// +// 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 + +/** + * TriggerIdPredicateAtom + * + * Generated from 'TriggerIdPredicateAtom' enum + */ +public sealed class TriggerIdPredicateAtom : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Equals' variant + */ + public data class Equals( + public val triggerId: TriggerId, + ) : TriggerIdPredicateAtom() { + 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.TriggerIdPredicateAtom.Equals = + try { + Equals( + TriggerId.read(reader), + ) + } 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): 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: TriggerIdPredicateAtom, + ) { + 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/TriggerIdPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateBox.kt deleted file mode 100644 index 103be10a3..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdPredicateBox.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 - -/** - * TriggerIdPredicateBox - * - * Generated from 'TriggerIdPredicateBox' enum - */ -public sealed class TriggerIdPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Equals' variant - */ - public data class Equals( - public val triggerId: TriggerId, - ) : TriggerIdPredicateBox() { - 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.TriggerIdPredicateBox.Equals = try { - Equals( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Equals, - ): Unit = try { - TriggerId.write(writer, instance.triggerId) - } catch (ex: Exception) { - throw wrapException(ex) - } - } - } - - /** - * 'Name' variant - */ - public data class Name( - public val stringPredicateBox: StringPredicateBox, - ) : TriggerIdPredicateBox() { - 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.TriggerIdPredicateBox.Name = try { - Name( - StringPredicateBox.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } - - override fun write( - writer: ScaleCodecWriter, - instance: jp.co.soramitsu.iroha2.generated.TriggerIdPredicateBox.Name, - ): Unit = try { - StringPredicateBox.write(writer, instance.stringPredicateBox) - } 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) - 1 -> Name.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: TriggerIdPredicateBox) { - writer.directWrite(instance.discriminant()) - when (val discriminant = instance.discriminant()) { - 0 -> Equals.write(writer, instance as Equals) - 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/TriggerIdProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..dcac2d74c --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfPredicateMarker.kt @@ -0,0 +1,116 @@ +// +// 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 + +/** + * TriggerIdProjectionOfPredicateMarker + * + * Generated from 'TriggerIdProjectionOfPredicateMarker' enum + */ +public sealed class TriggerIdProjectionOfPredicateMarker : ModelEnum { + /** + * @return Discriminator of variant in enum + */ + public abstract fun discriminant(): Int + + /** + * 'Atom' variant + */ + public data class Atom( + public val triggerIdPredicateAtom: TriggerIdPredicateAtom, + ) : TriggerIdProjectionOfPredicateMarker() { + 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.TriggerIdProjectionOfPredicateMarker.Atom = + try { + Atom( + TriggerIdPredicateAtom.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Atom, + ): Unit = + try { + TriggerIdPredicateAtom.write(writer, instance.triggerIdPredicateAtom) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + /** + * 'Name' variant + */ + public data class Name( + public val nameProjectionOfPredicateMarker: NameProjectionOfPredicateMarker, + ) : TriggerIdProjectionOfPredicateMarker() { + 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.TriggerIdProjectionOfPredicateMarker.Name = + try { + Name( + NameProjectionOfPredicateMarker.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } + + override fun write( + writer: ScaleCodecWriter, + instance: jp.co.soramitsu.iroha2.generated.TriggerIdProjectionOfPredicateMarker.Name, + ): Unit = + try { + NameProjectionOfPredicateMarker.write(writer, instance.nameProjectionOfPredicateMarker) + } catch (ex: Exception) { + throw wrapException(ex) + } + } + } + + 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: TriggerIdProjectionOfPredicateMarker, + ) { + 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/TriggerIdProjectionOfSelectorMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfSelectorMarker.kt new file mode 100644 index 000000000..bcda79ac4 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerIdProjectionOfSelectorMarker.kt @@ -0,0 +1,136 @@ +// +// 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..6ea75f66b 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 @@ -23,16 +23,20 @@ public data class TriggerNumberOfExecutionsChanged( public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): TriggerNumberOfExecutionsChanged = try { - TriggerNumberOfExecutionsChanged( - TriggerId.read(reader), - reader.readUint32(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): TriggerNumberOfExecutionsChanged = + try { + TriggerNumberOfExecutionsChanged( + TriggerId.read(reader), + reader.readUint32(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: TriggerNumberOfExecutionsChanged): Unit = + override fun write( + writer: ScaleCodecWriter, + instance: TriggerNumberOfExecutionsChanged, + ): Unit = try { TriggerId.write(writer, instance.trigger) writer.writeUint32(instance.`by`) 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..4b8dc061f --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateAtom.kt @@ -0,0 +1,40 @@ +// +// 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/TriggerPredicateBox.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateBox.kt deleted file mode 100644 index 018dfee8b..000000000 --- a/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerPredicateBox.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 - -/** - * TriggerPredicateBox - * - * Generated from 'TriggerPredicateBox' enum - */ -public sealed class TriggerPredicateBox : ModelEnum { - /** - * @return Discriminator of variant in enum - */ - public abstract fun discriminant(): Int - - /** - * 'Id' variant - */ - public data class Id( - public val triggerIdPredicateBox: TriggerIdPredicateBox, - ) : TriggerPredicateBox() { - 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.TriggerPredicateBox.Id = try { - Id( - TriggerIdPredicateBox.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) - } - } - } - - 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") } - - override fun write(writer: ScaleCodecWriter, instance: TriggerPredicateBox) { - 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/TriggerProjectionOfPredicateMarker.kt b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt new file mode 100644 index 000000000..f68e390f5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfPredicateMarker.kt @@ -0,0 +1,152 @@ +// +// 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..3daf69ae1 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/generated/TriggerProjectionOfSelectorMarker.kt @@ -0,0 +1,172 @@ +// +// 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..66891e32e 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 @@ -36,22 +36,24 @@ public sealed class TypeError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TypeError.AssetType = try { - AssetType( - Mismatch.read(reader) as Mismatch, - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TypeError.AssetType = + try { + AssetType( + Mismatch.read(reader) as Mismatch, + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + Mismatch.write(writer, instance.mismatch) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,40 +70,47 @@ public sealed class TypeError : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TypeError.NumericAssetTypeExpected = try { - NumericAssetTypeExpected( - jp.co.soramitsu.iroha2.generated.AssetType.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.TypeError.NumericAssetTypeExpected = + try { + NumericAssetTypeExpected( + jp.co.soramitsu.iroha2.generated.AssetType + .read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.TypeError.NumericAssetTypeExpected, - ): Unit = try { - jp.co.soramitsu.iroha2.generated.AssetType.write(writer, instance.assetType) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + jp.co.soramitsu.iroha2.generated.AssetType + .write(writer, instance.assetType) + } catch (ex: Exception) { + throw wrapException(ex) + } } } public companion object : ScaleReader, ScaleWriter { - 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") } + 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") + } - override fun write(writer: ScaleCodecWriter, instance: TypeError) { + 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..f872d5718 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 @@ -36,22 +36,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Peer = try { - Peer( - UnregisterOfPeer.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Peer = + try { + Peer( + UnregisterOfPeer.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfPeer.write(writer, instance.unregisterOfPeer) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -68,22 +70,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Domain = try { - Domain( - UnregisterOfDomain.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Domain = + try { + Domain( + UnregisterOfDomain.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfDomain.write(writer, instance.unregisterOfDomain) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -100,22 +104,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Account = try { - Account( - UnregisterOfAccount.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Account = + try { + Account( + UnregisterOfAccount.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfAccount.write(writer, instance.unregisterOfAccount) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -132,22 +138,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.AssetDefinition = try { - AssetDefinition( - UnregisterOfAssetDefinition.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.AssetDefinition = + try { + AssetDefinition( + UnregisterOfAssetDefinition.read(reader), + ) + } 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) - } + ): Unit = + try { + UnregisterOfAssetDefinition.write(writer, instance.unregisterOfAssetDefinition) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -164,22 +172,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Asset = try { - Asset( - UnregisterOfAsset.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Asset = + try { + Asset( + UnregisterOfAsset.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfAsset.write(writer, instance.unregisterOfAsset) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -196,22 +206,24 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 5 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Role = try { - Role( - UnregisterOfRole.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Role = + try { + Role( + UnregisterOfRole.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfRole.write(writer, instance.unregisterOfRole) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -228,40 +240,44 @@ public sealed class UnregisterBox : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 6 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Trigger = try { - Trigger( - UnregisterOfTrigger.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.UnregisterBox.Trigger = + try { + Trigger( + UnregisterOfTrigger.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } 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) - } + ): Unit = + try { + UnregisterOfTrigger.write(writer, instance.unregisterOfTrigger) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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) + 3 -> AssetDefinition.read(reader) + 4 -> Asset.read(reader) + 5 -> Role.read(reader) + 6 -> Trigger.read(reader) + else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") + } + + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterBox, ) { - 0 -> Peer.read(reader) - 1 -> Domain.read(reader) - 2 -> Account.read(reader) - 3 -> AssetDefinition.read(reader) - 4 -> Asset.read(reader) - 5 -> Role.read(reader) - 6 -> Trigger.read(reader) - else -> throw RuntimeException("Unresolved discriminant of the enum variant: $discriminant") } - - override fun write(writer: ScaleCodecWriter, instance: UnregisterBox) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> Peer.write(writer, instance as Peer) @@ -271,7 +287,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..40d80429c 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - AccountId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfAccount = + try { + UnregisterOfAccount( + AccountId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfAccount): Unit = try { - AccountId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfAccount, + ): Unit = + try { + AccountId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..f9a3baefb 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - AssetId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfAsset = + try { + UnregisterOfAsset( + AssetId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfAsset): Unit = try { - AssetId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfAsset, + ): Unit = + try { + AssetId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b12c4b9ac 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 @@ -17,22 +20,29 @@ import kotlin.Unit */ public data class UnregisterOfAssetDefinition( public val `object`: AssetDefinitionId, -) { +) : Instruction { + override fun asInstructionBox(): InstructionBox = asInstructionBoxExt() + public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): UnregisterOfAssetDefinition = try { - UnregisterOfAssetDefinition( - AssetDefinitionId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfAssetDefinition = + try { + UnregisterOfAssetDefinition( + AssetDefinitionId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfAssetDefinition): Unit = try { - AssetDefinitionId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfAssetDefinition, + ): Unit = + try { + AssetDefinitionId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..3bdec70a1 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - DomainId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfDomain = + try { + UnregisterOfDomain( + DomainId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfDomain): Unit = try { - DomainId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfDomain, + ): Unit = + try { + DomainId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..78df8a367 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - PeerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfPeer = + try { + UnregisterOfPeer( + PeerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfPeer): Unit = try { - PeerId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfPeer, + ): Unit = + try { + PeerId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..b680da72b 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - RoleId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfRole = + try { + UnregisterOfRole( + RoleId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfRole): Unit = try { - RoleId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfRole, + ): Unit = + try { + RoleId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..ab0453266 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - TriggerId.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): UnregisterOfTrigger = + try { + UnregisterOfTrigger( + TriggerId.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: UnregisterOfTrigger): Unit = try { - TriggerId.write(writer, instance.`object`) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: UnregisterOfTrigger, + ): Unit = + try { + TriggerId.write(writer, instance.`object`) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..d934a6f4e 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 @@ -17,20 +20,27 @@ import kotlin.Unit */ 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( - Executor.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): Upgrade = + try { + Upgrade( + Executor.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: Upgrade): Unit = try { - Executor.write(writer, instance.executor) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: Upgrade, + ): Unit = + try { + Executor.write(writer, instance.executor) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..9a0cc7e12 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 @@ -26,15 +26,19 @@ public sealed class ValidationFail : ModelEnum { */ public abstract fun discriminant(): Int - override fun equals(other: Any?): Boolean = when (this) { - is TooComplex -> TooComplex.equals(this, other) - is InternalError -> InternalError.equals(this, other) - else -> super.equals(other) } + override fun equals(other: Any?): Boolean = + when (this) { + is TooComplex -> TooComplex.equals(this, other) + is InternalError -> InternalError.equals(this, other) + else -> super.equals(other) + } - override fun hashCode(): Int = when (this) { - is TooComplex -> TooComplex.hashCode() - is InternalError -> InternalError.hashCode() - else -> super.hashCode() } + override fun hashCode(): Int = + when (this) { + is TooComplex -> TooComplex.hashCode() + is InternalError -> InternalError.hashCode() + else -> super.hashCode() + } /** * 'NotPermitted' variant @@ -49,22 +53,24 @@ public sealed class ValidationFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 0 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.NotPermitted = try { - NotPermitted( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.NotPermitted = + try { + NotPermitted( + reader.readString(), + ) + } 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) - } + ): Unit = + try { + writer.writeAsList(instance.string.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -81,22 +87,24 @@ public sealed class ValidationFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 1 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.InstructionFailed = try { - InstructionFailed( - InstructionExecutionError.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.InstructionFailed = + try { + InstructionFailed( + InstructionExecutionError.read(reader), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.InstructionFailed, - ): Unit = try { - InstructionExecutionError.write(writer, instance.instructionExecutionError) - } catch (ex: Exception) { - throw wrapException(ex) - } + ): Unit = + try { + InstructionExecutionError.write(writer, instance.instructionExecutionError) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -113,22 +121,24 @@ public sealed class ValidationFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 2 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.QueryFailed = try { - QueryFailed( - QueryExecutionFail.read(reader), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.QueryFailed = + try { + QueryFailed( + QueryExecutionFail.read(reader), + ) + } 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) - } + ): Unit = + try { + QueryExecutionFail.write(writer, instance.queryExecutionFail) + } catch (ex: Exception) { + throw wrapException(ex) + } } } @@ -143,24 +153,30 @@ public sealed class ValidationFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 3 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex = try { - TooComplex() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex = + try { + TooComplex() + } catch (ex: Exception) { + throw wrapException(ex) + } override fun write( writer: ScaleCodecWriter, instance: jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex, - ): 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.ValidationFail.TooComplex, o2: Any?): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + public fun equals( + o1: jp.co.soramitsu.iroha2.generated.ValidationFail.TooComplex, + o2: Any?, + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".ValidationFail.TooComplex".hashCode() } @@ -177,45 +193,50 @@ public sealed class ValidationFail : ModelEnum { ScaleWriter { public const val DISCRIMINANT: Int = 4 - override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError = try { - InternalError() - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError = + try { + InternalError() + } 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) - } + ): Unit = + try { + } catch (ex: Exception) { + throw wrapException(ex) + } public fun equals( o1: jp.co.soramitsu.iroha2.generated.ValidationFail.InternalError, o2: Any?, - ): Boolean = when (o2) { - null -> false - else -> o2::class == o1::class - } + ): Boolean = + when (o2) { + null -> false + else -> o2::class == o1::class + } override fun hashCode(): Int = ".ValidationFail.InternalError".hashCode() } } 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") + } + + override fun write( + writer: ScaleCodecWriter, + instance: ValidationFail, ) { - 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") } - - override fun write(writer: ScaleCodecWriter, instance: ValidationFail) { writer.directWrite(instance.discriminant()) when (val discriminant = instance.discriminant()) { 0 -> NotPermitted.write(writer, instance as NotPermitted) @@ -223,7 +244,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..1af4b4c76 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 @@ -20,18 +20,23 @@ public data class WasmExecutionFail( public val reason: String, ) { public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): WasmExecutionFail = try { - WasmExecutionFail( - reader.readString(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): WasmExecutionFail = + try { + WasmExecutionFail( + reader.readString(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: WasmExecutionFail): Unit = try { - writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: WasmExecutionFail, + ): Unit = + try { + writer.writeAsList(instance.reason.toByteArray(Charsets.UTF_8)) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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..95da2fcd4 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 @@ -32,18 +32,23 @@ public data class WasmSmartContract( override fun hashCode(): Int = vecOfU8.contentHashCode() public companion object : ScaleReader, ScaleWriter { - override fun read(reader: ScaleCodecReader): WasmSmartContract = try { - WasmSmartContract( - reader.readByteArray(), - ) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun read(reader: ScaleCodecReader): WasmSmartContract = + try { + WasmSmartContract( + reader.readByteArray(), + ) + } catch (ex: Exception) { + throw wrapException(ex) + } - override fun write(writer: ScaleCodecWriter, instance: WasmSmartContract): Unit = try { - writer.writeAsList(instance.vecOfU8) - } catch (ex: Exception) { - throw wrapException(ex) - } + override fun write( + writer: ScaleCodecWriter, + instance: WasmSmartContract, + ): Unit = + try { + writer.writeAsList(instance.vecOfU8) + } catch (ex: Exception) { + throw wrapException(ex) + } } } 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 76% 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..1af07191c 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 @@ -36,13 +32,13 @@ import java.math.BigInteger */ @Suppress("unused") object Filters { - /** * Create a data filter */ - fun data(entityFilter: DataEventFilter) = EventFilterBox.Data( - entityFilter, - ) + fun data(entityFilter: DataEventFilter) = + EventFilterBox.Data( + entityFilter, + ) /** * Create a [time based event filter][TimeEventFilter] @@ -85,7 +81,6 @@ object Filters { * and either return all matching events or additionally apply another filter to them. */ object EntityFilters { - /** * Match events associated with asset definition and apply another filter referenced by * its [id][OriginFilterOfAssetDefinitionEvent] or [event type][AssetDefinitionEventFilter] @@ -168,7 +163,6 @@ object EntityFilters { * Timed filters */ object EventFilters { - /** * Create a filter with a timed execution */ @@ -182,53 +176,3 @@ object EventFilters { */ 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..a497cf9c7 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/Instructions.kt @@ -0,0 +1,509 @@ +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..bcf70f6c5 --- /dev/null +++ b/modules/model/src/main/kotlin/jp/co/soramitsu/iroha2/transaction/TransactionBuilder.kt @@ -0,0 +1,67 @@ +@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..432820f80 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,17 @@ 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..bc5002a0e 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 @@ -26,55 +27,82 @@ import kotlin.io.path.readBytes */ open class IrohaContainer : GenericContainer { - constructor(config: IrohaConfig.() -> Unit = {}) : this(IrohaConfig().apply(config)) constructor(config: IrohaConfig) : super(config.getFullImageName()) { - val publicKey = config.keyPair.public.bytes().toHex() - val privateKey = config.keyPair.private.bytes().toHex() - val containerName = when (config.submitGenesis) { - true -> "MAIN_${config.alias}_${randomUUID().toString().split("-").last()}" - false -> config.alias - } + val publicKey = + config.keyPair.public + .bytes() + .toHex() + val privateKey = + config.keyPair.private + .bytes() + .toHex() + val containerName = + when (config.submitGenesis) { + true -> "MAIN_${config.alias}_${randomUUID().toString().split("-").last()}" + false -> config.alias + } - val genesisPublicKey = config.genesisKeyPair.public.bytes().toHex() - val genesisPrivateKey = config.genesisKeyPair.private.bytes().toHex() + 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("PUBLIC_KEY", "ed0120$publicKey") + this + .withNetwork(config.networkToJoin) + .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) } } + }.also { container -> config.envs.forEach { (k, v) -> container.withEnv(k, v) } } .withExposedPorts(p2pPort, apiPort) .withNetworkAliases(config.alias) .withLogConsumer(config.logConsumer) .withCopyToContainer( forHostPath(configDirLocation), "/$DEFAULT_CONFIG_DIR", - ) - .withCopyToContainer( + ).withCopyToContainer( forHostPath(configDirLocation), "/app/.cache/wasmtime", - ) - .also { + ).also { config.genesis?.writeToFile(genesisFileLocation) config.genesisPath?.also { path -> Files.copy(Path(path).toAbsolutePath(), genesisFileLocation) } @@ -87,8 +115,7 @@ open class IrohaContainer : GenericContainer { executorFileLocation.toFile().writeBytes(content) } } - } - .also { container -> + }.also { container -> if (config.submitGenesis) { container.withCopyFileToContainer( MountableFile.forClasspathResource("start.sh"), @@ -96,8 +123,7 @@ open class IrohaContainer : GenericContainer { ) container.withCommand("sh", "$configDirLocation/start.sh") } - } - .withImagePullPolicy(config.pullPolicy) + }.withImagePullPolicy(config.pullPolicy) .also { container -> if (config.waitStrategy) { container.waitingFor( @@ -124,9 +150,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 +171,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 +185,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..437dcc0ae 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,17 +44,19 @@ 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()) private val yaml = Yaml() - override fun beforeEach(context: ExtensionContext) = runBlocking { - // init container and client if annotation was passed on test method - val testId = context.testId() - resources[testId] = initIfRequested(context) - } + override fun beforeEach(context: ExtensionContext) = + runBlocking { + // init container and client if annotation was passed on test method + val testId = context.testId() + resources[testId] = initIfRequested(context) + } override fun interceptTestMethod( invocation: InvocationInterceptor.Invocation, @@ -71,22 +73,27 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { } } - private suspend fun initIfRequested( - extensionContext: ExtensionContext, - ): List = coroutineScope { - val withIroha = extensionContext.element.get() - .annotations.filterIsInstance() - .firstOrNull() - val withIrohaManual = extensionContext.element.get() - .annotations.filterIsInstance() - .firstOrNull() - - return@coroutineScope when { - withIroha != null -> withIroha.init(extensionContext) - withIrohaManual != null -> withIrohaManual.init(extensionContext).let { emptyList() } - else -> emptyList() + private suspend fun initIfRequested(extensionContext: ExtensionContext): List = + coroutineScope { + val withIroha = + extensionContext.element + .get() + .annotations + .filterIsInstance() + .firstOrNull() + val withIrohaManual = + extensionContext.element + .get() + .annotations + .filterIsInstance() + .firstOrNull() + + return@coroutineScope when { + withIroha != null -> withIroha.init(extensionContext) + withIrohaManual != null -> withIrohaManual.init(extensionContext).let { emptyList() } + else -> emptyList() + } } - } private suspend fun WithIroha.init(extensionContext: ExtensionContext): List { val testInstance = extensionContext.testInstance.get().cast>() @@ -97,12 +104,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 +112,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) } } @@ -142,48 +146,51 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { val testInstance = extensionContext.testInstance.get() 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() - } ?: throw IrohaSdkException("Iroha URLs required") + val urls = + when (this.dockerComposeFile.isEmpty()) { + 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? { - fun String?.convertUrl() = this - ?.replace("${IrohaContainer.NETWORK_ALIAS}[0-9]*".toRegex(), "localhost") - ?.let { "http://$it" } - ?: throw IllegalArgumentException("Invalid docker-compose file") - - val all = runCatching { - yaml.load>(this.inputStream())["services"] - ?.cast>()?.values?.toList() - ?.map { it?.cast>()?.get("environment") } - ?.cast>>() ?: return null - }.onFailure { return null }.getOrThrow() + private fun File.readDockerComposeData(): List? { + fun String?.convertUrl() = + this + ?.replace("${IrohaContainer.NETWORK_ALIAS}[0-9]*".toRegex(), "localhost") + ?.let { "http://$it" } + ?: throw IllegalArgumentException("Invalid docker-compose file") + + val all = + runCatching { + yaml + .load>(this.inputStream())["services"] + ?.cast>() + ?.values + ?.toList() + ?.map { it?.cast>()?.get("environment") } + ?.cast>>() ?: return null + }.onFailure { return null }.getOrThrow() return all.map { - IrohaUrls( - it["TORII_API_URL"].convertUrl(), - it["TORII_P2P_ADDR"].convertUrl(), - ) + it["TORII_API_URL"].convertUrl() } } @@ -198,8 +205,8 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { .also { check(it.size <= 1) { """ - "Found more than one property with type `${V::class.qualifiedName}` - in test class `${testClassInstance::class::qualifiedName}`" + "Found more than one property with type `${V::class.qualifiedName}` + in test class `${testClassInstance::class::qualifiedName}`" """.trimIndent() } }.firstOrNull() @@ -210,80 +217,92 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { private suspend fun createContainers( withIroha: WithIroha, testInstance: IrohaTest<*>, - ): List = coroutineScope { - val keyPairs = mutableListOf() - val portsList = mutableListOf>() - - repeat(withIroha.amount) { n -> - keyPairs.add(generateKeyPair()) - portsList.add(listOf(DEFAULT_P2P_PORT + n, DEFAULT_API_PORT + n)) - } - val peerIds = keyPairs.mapIndexed { i: Int, kp: KeyPair -> - val p2pPort = portsList[i][IrohaConfig.P2P_PORT_IDX] - kp.toPeerId(IrohaContainer.NETWORK_ALIAS + p2pPort, p2pPort) - } - 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 { - this.networkToJoin = testInstance.network - when { - withIroha.source.isNotEmpty() -> genesisPath = withIroha.source - else -> genesis = withIroha.sources.map { genesisInstance(it) }.toSingle() - } - this.alias = IrohaContainer.NETWORK_ALIAS + p2pPort - this.keyPair = keyPairs[n] - this.trustedPeers = peerIds - this.ports = portsList[n] - this.imageName = testInstance.imageName - this.imageTag = testInstance.imageTag - this.envs = withIroha.configs.associate { config -> - config.split(IROHA_CONFIG_DELIMITER).let { - it.first() to it.last() + ): List = + coroutineScope { + val keyPairs = mutableListOf() + val portsList = mutableListOf>() + + repeat(withIroha.amount) { n -> + keyPairs.add(generateKeyPair()) + portsList.add(listOf(DEFAULT_P2P_PORT + n, DEFAULT_API_PORT + n)) + } + val peerIds = + keyPairs.mapIndexed { i: Int, kp: KeyPair -> + val p2pPort = portsList[i][IrohaConfig.P2P_PORT_IDX] + 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 = + IrohaContainer { + this.networkToJoin = testInstance.network + when { + withIroha.source.isNotEmpty() -> genesisPath = withIroha.source + else -> genesis = withIroha.sources.map { genesisInstance(it) }.toSingle() + } + this.alias = IrohaContainer.NETWORK_ALIAS + p2pPort + this.keyPair = keyPairs[n] + this.trustedPeers = peerIds + this.ports = portsList[n] + this.imageName = testInstance.imageName + this.imageTag = testInstance.imageTag + this.envs = + withIroha.configs.associate { config -> + config.split(IROHA_CONFIG_DELIMITER).let { + it.first() to it.last() + } + } + // only first peer should have --submit-genesis in peer start command + this.submitGenesis = n == 0 + if (withIroha.executorSource.isNotEmpty()) { + this.executorPath = withIroha.executorSource + } } + withContext(Dispatchers.IO) { + container.start() } - // only first peer should have --submit-genesis in peer start command - this.submitGenesis = n == 0 - if (withIroha.executorSource.isNotEmpty()) { - this.executorPath = withIroha.executorSource - } - } - withContext(Dispatchers.IO) { - container.start() - } - containers.add(container) - }.let { deferredSet.add(it) } - } + containers.add(container) + }.let { deferredSet.add(it) } + } - withContext(Dispatchers.IO) { - deferredSet.forEach { it.await() } - } + withContext(Dispatchers.IO) { + deferredSet.forEach { it.await() } + } - containers - } + containers + } - private fun KeyPair.toPeerId(host: String, port: Int) = PeerId( - SocketAddr.Host(SocketAddrHost(host, port)), - this.public.toIrohaPublicKey(), - ) + private fun KeyPair.toPeerId() = + PeerId( + this.public.toIrohaPublicKey(), + ) private fun ExtensionContext.testId() = "${this.testClass.get().name}_${this.testMethod.get().name}" - private fun genesisInstance(clazz: KClass): Genesis = clazz.createInstance().let { genesis -> - val tx = genesis.transaction.copy( - chain = ChainId("00000000-0000-0000-0000-000000000000"), - ) - val transactionField = findField(clazz.java, "transaction") - transactionField.isAccessible = true - transactionField.set(genesis, tx) - - return genesis - } + private fun genesisInstance(clazz: KClass): Genesis = + clazz.createInstance().let { genesis -> + val tx = + genesis.transaction.copy( + ChainId("00000000-0000-0000-0000-000000000000"), + ) + val transactionField = findField(clazz.java, "transaction") + transactionField.isAccessible = true + transactionField.set(genesis, tx) + + return genesis + } - private fun findField(clazz: Class<*>, fieldName: String): Field { - return try { + private fun findField( + clazz: Class<*>, + fieldName: String, + ): Field = + try { clazz.getDeclaredField(fieldName) } catch (e: NoSuchFieldException) { when (clazz.superclass == null) { @@ -291,5 +310,4 @@ class IrohaRunnerExtension : InvocationInterceptor, BeforeEachCallback { 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..d2b5691a2 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,11 +27,42 @@ 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", - "CCF31D85E3B32A4BEA59987CE0C78E3B8E2DB93881468AB2435FE45D5C9DCD53", -) +val ALICE_KEYPAIR = + keyPairFromHex( + "CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03", + "CCF31D85E3B32A4BEA59987CE0C78E3B8E2DB93881468AB2435FE45D5C9DCD53", + ) @JvmField val ALICE_PUBLIC_KEY = ALICE_KEYPAIR.public.toIrohaPublicKey() @@ -33,10 +71,11 @@ val ALICE_PUBLIC_KEY = ALICE_KEYPAIR.public.toIrohaPublicKey() val ALICE_ACCOUNT_ID = AccountId(domain = DEFAULT_DOMAIN_ID, signatory = ALICE_PUBLIC_KEY) @JvmField -val BOB_KEYPAIR = keyPairFromHex( - "04FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016", - "AF3F96DEEF44348FEB516C057558972CEC4C75C4DB9C5B3AAC843668854BF828", -) +val BOB_KEYPAIR = + keyPairFromHex( + "04FF5B81046DDCCF19E2E451C45DFB6F53759D4EB30FA2EFA807284D1CC33016", + "AF3F96DEEF44348FEB516C057558972CEC4C75C4DB9C5B3AAC843668854BF828", + ) @JvmField val BOB_PUBLIC_KEY = BOB_KEYPAIR.public.toIrohaPublicKey() 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": [] }