[doc]: add kotlin tutorial example

Signed-off-by: Marin Veršić <[email protected]>

examples/tutorial/build.gradle.kts

@@ -0,0 +1,12 @@
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.6.0")
+
+    implementation("net.i2p.crypto:eddsa:0.3.0")
+    implementation("org.bouncycastle:bcprov-jdk15on:1.65")
+    implementation("com.github.multiformats:java-multihash:1.3.0")
+
+    implementation(project(":model"))
+    implementation(project(":block"))
+    api(project(":admin-client"))
+}

examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Main.kt

@@ -0,0 +1,63 @@
+package jp.co.soramitsu.iroha2
+
+import jp.co.soramitsu.iroha2.generated.AccountId
+import jp.co.soramitsu.iroha2.generated.AssetValue
+import jp.co.soramitsu.iroha2.generated.AssetValueType
+import kotlinx.coroutines.runBlocking
+import java.net.URL
+
+fun main(args: Array<String>): Unit = runBlocking {
+    val peerUrl = "http://127.0.0.1:8080"
+    val telemetryUrl = "http://127.0.0.1:8180"
+    val admin = AccountId("bob".asName(), "wonderland".asDomainId())
+    val adminKeyPair = keyPairFromHex(
+        "7233bfc89dcbd68c19fde6ce6158225298ec1131b6a130d1aeb454c1ab5183c0",
+        "9ac47abf59b356e0bd7dcbbbb4dec080e302156a48ca907e47cb6aea1d32719e",
+    )
+
+    val client = AdminIroha2Client(URL(peerUrl), URL(peerUrl), URL(telemetryUrl), log = true)
+    val query = Query(client, admin, adminKeyPair)
+    query.findAllDomains()
+        .also { println("ALL DOMAINS: ${it.map { d -> d.id.asString() }}") }
+
+    val sendTransaction = SendTransaction(client, admin, adminKeyPair)
+
+    val domain = "looking_glass_${System.currentTimeMillis()}"
+    sendTransaction.registerDomain(domain).also { println("DOMAIN $domain CREATED") }
+
+    val madHatter = "madHatter_${System.currentTimeMillis()}$ACCOUNT_ID_DELIMITER$domain"
+    val madHatterKeyPair = generateKeyPair()
+    sendTransaction.registerAccount(madHatter, listOf(madHatterKeyPair.public.toIrohaPublicKey()))
+        .also { println("ACCOUNT $madHatter CREATED") }
+
+    query.findAllAccounts()
+        .also { println("ALL ACCOUNTS: ${it.map { a -> a.id.asString() }}") }
+
+    val assetDefinition = "asset_time_${System.currentTimeMillis()}$ASSET_ID_DELIMITER$domain"
+    sendTransaction.registerAssetDefinition(assetDefinition, AssetValueType.Quantity())
+        .also { println("ASSET DEFINITION $assetDefinition CREATED") }
+
+    val madHatterAsset = "$assetDefinition$ASSET_ID_DELIMITER$madHatter"
+    sendTransaction.registerAsset(madHatterAsset, AssetValue.Quantity(100))
+        .also { println("ASSET $madHatterAsset CREATED") }
+
+    val whiteRabbit = "whiteRabbit_${System.currentTimeMillis()}$ACCOUNT_ID_DELIMITER$domain"
+    val whiteRabbitKeyPair = generateKeyPair()
+    sendTransaction.registerAccount(whiteRabbit, listOf(whiteRabbitKeyPair.public.toIrohaPublicKey()))
+        .also { println("ACCOUNT $whiteRabbit CREATED") }
+
+    val whiteRabbitAsset = "$assetDefinition$ASSET_ID_DELIMITER$whiteRabbit"
+    sendTransaction.registerAsset(whiteRabbitAsset, AssetValue.Quantity(0))
+        .also { println("ASSET $whiteRabbitAsset CREATED") }
+
+    sendTransaction.transferAsset(madHatterAsset, 10, whiteRabbit, madHatter.asAccountId(), madHatterKeyPair)
+        .also { println("$madHatter TRANSFERRED FROM $madHatterAsset TO $whiteRabbitAsset: 10") }
+    query.getAccountAmount(madHatter, madHatterAsset).also { println("$madHatterAsset BALANCE: $it") }
+    query.getAccountAmount(whiteRabbit, whiteRabbitAsset).also { println("$whiteRabbitAsset BALANCE: $it") }
+
+    sendTransaction.burnAssets(madHatterAsset, 10, madHatter.asAccountId(), madHatterKeyPair)
+        .also { println("$madHatterAsset WAS BURN") }
+
+    query.getAccountAmount(madHatter, madHatterAsset)
+        .also { println("$madHatterAsset BALANCE: $it AFTER ASSETS BURNING") }
+}

examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/Query.kt

@@ -0,0 +1,46 @@
+package jp.co.soramitsu.iroha2
+
+import jp.co.soramitsu.iroha2.generated.AccountId
+import jp.co.soramitsu.iroha2.generated.AssetValue
+import jp.co.soramitsu.iroha2.generated.GenericPredicateBox
+import jp.co.soramitsu.iroha2.generated.ValuePredicate
+import jp.co.soramitsu.iroha2.query.QueryBuilder
+import java.security.KeyPair
+
+open class Query(
+    private val client: AdminIroha2Client,
+    private val admin: AccountId,
+    private val keyPair: KeyPair,
+) {
+
+    suspend fun findAllDomains(queryFilter: GenericPredicateBox<ValuePredicate>? = null) = QueryBuilder
+        .findAllDomains(queryFilter)
+        .account(admin)
+        .buildSigned(keyPair)
+        .let { client.sendQuery(it) }
+
+    suspend fun findAllAccounts(queryFilter: GenericPredicateBox<ValuePredicate>? = null) = QueryBuilder
+        .findAllAccounts(queryFilter)
+        .account(admin)
+        .buildSigned(keyPair)
+        .let {
+            client.sendQuery(it)
+        }
+
+    suspend fun findAllAssets(queryFilter: GenericPredicateBox<ValuePredicate>? = null) = QueryBuilder
+        .findAllAssets(queryFilter)
+        .account(admin)
+        .buildSigned(keyPair)
+        .let { client.sendQuery(it) }
+
+    suspend fun getAccountAmount(accountId: String, assetId: String): Long {
+        return QueryBuilder.findAccountById(accountId.asAccountId())
+            .account(admin)
+            .buildSigned(keyPair)
+            .let { query ->
+                client.sendQuery(query).assets[assetId.asAssetId()]?.value
+            }.let { value ->
+                value?.cast<AssetValue.Quantity>()?.u32
+            } ?: throw RuntimeException("NOT FOUND")
+    }
+}

examples/tutorial/src/main/kotlin/jp/co/soramitsu/iroha2/SendTransaction.kt

@@ -0,0 +1,114 @@
+package jp.co.soramitsu.iroha2
+
+import jp.co.soramitsu.iroha2.generated.AccountId
+import jp.co.soramitsu.iroha2.generated.AssetValue
+import jp.co.soramitsu.iroha2.generated.AssetValueType
+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.generated.PublicKey
+import jp.co.soramitsu.iroha2.generated.Value
+import kotlinx.coroutines.withTimeout
+import java.security.KeyPair
+
+class SendTransaction(
+    private val client: AdminIroha2Client,
+    private val admin: AccountId,
+    private val keyPair: KeyPair,
+    private val timeout: Long = 10000,
+) {
+
+    suspend fun registerDomain(
+        id: String,
+        metadata: Map<Name, Value> = mapOf(),
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.registerDomain(id.asDomainId(), metadata)
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+
+    suspend fun registerAccount(
+        id: String,
+        signatories: List<PublicKey>,
+        metadata: Map<Name, Value> = mapOf(),
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.registerAccount(id.asAccountId(), signatories, Metadata(metadata))
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+
+    suspend fun registerAssetDefinition(
+        id: String,
+        type: AssetValueType = AssetValueType.Store(),
+        metadata: Map<Name, Value> = mapOf(),
+        mintable: Mintable = Mintable.Infinitely(),
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.registerAssetDefinition(id.asAssetDefinitionId(), type, Metadata(metadata), mintable)
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+
+    suspend fun registerAsset(
+        id: String,
+        value: AssetValue,
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.registerAsset(id.asAssetId(), value)
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+
+    suspend fun transferAsset(
+        from: String,
+        value: Int,
+        to: String,
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.transferAsset(from.asAssetId(), value, to.asAccountId())
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+
+    suspend fun burnAssets(
+        assetId: String,
+        value: Int,
+        admin: AccountId = this.admin,
+        keyPair: KeyPair = this.keyPair,
+    ) {
+        client.sendTransaction {
+            account(admin)
+            this.burnAsset(assetId.asAssetId(), value)
+            buildSigned(keyPair)
+        }.also {
+            withTimeout(timeout) { it.await() }
+        }
+    }
+}