Add demo of transfer between users

Author: Tougee

samples/src/main/java/jvmMain/kotlin/Sample.kt

@@ -7,6 +7,7 @@ import net.i2p.crypto.eddsa.EdDSAPrivateKey
 import net.i2p.crypto.eddsa.EdDSAPublicKey
 import one.mixin.bot.HttpClient
 import one.mixin.bot.SessionToken
+import one.mixin.bot.api.SnapshotService
 import one.mixin.bot.encryptPin
 import one.mixin.bot.extension.base64Decode
 import one.mixin.bot.extension.base64Encode
@@ -15,6 +16,7 @@ import one.mixin.bot.util.decryASEKey
 import one.mixin.bot.util.generateEd25519KeyPair
 import one.mixin.bot.util.getEdDSAPrivateKeyFromString
 import one.mixin.bot.vo.*
+import retrofit2.http.Query
 import java.util.Random
 import java.util.UUID
 
@@ -100,7 +102,7 @@ fun main() = runBlocking {
     return@runBlocking
 }
 
-private suspend fun createUser(client: HttpClient, sessionSecret: String): User? {
+internal suspend fun createUser(client: HttpClient, sessionSecret: String): User? {
     val response = client.userService.createUsers(
         AccountRequest(
             Random().nextInt(10).toString() + "User",
@@ -110,7 +112,7 @@ private suspend fun createUser(client: HttpClient, sessionSecret: String): User?
     return response.data
 }
 
-private suspend fun createPin(client: HttpClient, userAesKey: String) {
+internal suspend fun createPin(client: HttpClient, userAesKey: String) {
     val response = client.userService.createPin(
         PinRequest(encryptPin(userAesKey, DEFAULT_PIN))
     )
@@ -121,25 +123,28 @@ private suspend fun createPin(client: HttpClient, userAesKey: String) {
     }
 }
 
-private suspend fun transferToUser(
+internal suspend fun transferToUser(
     client: HttpClient,
     userId: String,
     aseKey: String,
     pin: String
-) {
+): Snapshot? {
     val response = client.snapshotService.transfer(
         TransferRequest(
             CNB_ID,
             userId,
             DEFAULT_AMOUNT,
-            encryptPin(aseKey, pin, System.nanoTime())
+            encryptPin(aseKey, pin)
         )
     )
+    var snapshot: Snapshot? = null
     if (response.isSuccess()) {
+        snapshot = response.data
         println("Transfer success: ${response.data?.snapshotId}")
     } else {
         println("Transfer failure ${response.error}")
     }
+    return snapshot
 }
 
 private suspend fun getAsset(client: HttpClient) {
@@ -274,7 +279,7 @@ private suspend fun transactions(
     }
 }
 
-private suspend fun networkSnapshot(
+internal suspend fun networkSnapshot(
     client: HttpClient,
     snapshotId: String
 ) {
@@ -286,16 +291,22 @@ private suspend fun networkSnapshot(
     }
 }
 
-private suspend fun networkSnapshots(
+internal suspend fun networkSnapshots(
     client: HttpClient,
-    assetId: String
-) {
-    val snapshotResponse = client.snapshotService.networkSnapshots(assetId)
+    assetId: String,
+    offset: String? = null,
+    limit: Int = SnapshotService.LIMIT,
+    order: String? = null
+): List<NetworkSnapshot>? {
+    val snapshotResponse = client.snapshotService.networkSnapshots(assetId, offset, limit, order)
+    var networkSnapshots: List<NetworkSnapshot>? = null
     if (snapshotResponse.isSuccess()) {
+        networkSnapshots = snapshotResponse.data
         println("Network snapshots success: ${snapshotResponse.data?.size}")
     } else {
         println("Network snapshot failure: ${snapshotResponse.error?.description}")
     }
+    return networkSnapshots
 }
 
 private suspend fun readGhostKey(client: HttpClient) {

samples/src/main/java/jvmMain/kotlin/UserTransferDemo.kt

@@ -0,0 +1,93 @@
+package jvmMain.kotlin
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import net.i2p.crypto.eddsa.EdDSAPrivateKey
+import net.i2p.crypto.eddsa.EdDSAPublicKey
+import one.mixin.bot.HttpClient
+import one.mixin.bot.SessionToken
+import one.mixin.bot.extension.base64Decode
+import one.mixin.bot.extension.base64Encode
+import one.mixin.bot.util.calculateAgreement
+import one.mixin.bot.util.decryASEKey
+import one.mixin.bot.util.generateEd25519KeyPair
+import one.mixin.bot.util.getEdDSAPrivateKeyFromString
+
+fun main() = runBlocking {
+    val key = getEdDSAPrivateKeyFromString(Config.privateKey)
+    val pinToken = decryASEKey(Config.pinTokenPem, key) ?: return@runBlocking
+    val client =
+        HttpClient.Builder().useCNServer().configEdDSA(Config.userId, Config.sessionId, key).build()
+
+    // create alice keys
+    val aliceSessionKey = generateEd25519KeyPair()
+    val alicePublicKey = aliceSessionKey.public as EdDSAPublicKey
+    val aliceSessionSecret = alicePublicKey.abyte.base64Encode()
+
+    // create alice
+    val alice = createUser(client, aliceSessionSecret)
+    alice ?: return@runBlocking
+    val aliceToken = SessionToken.EdDSA(
+        alice.userId, alice.sessionId,
+        (aliceSessionKey.private as EdDSAPrivateKey).seed.base64Encode()
+    )
+    client.setUserToken(aliceToken)
+    // decrypt pin token
+    val alicePrivateKey = aliceSessionKey.private as EdDSAPrivateKey
+    val aliceAesKey = calculateAgreement(alice.pinToken.base64Decode(), alicePrivateKey).base64Encode()
+    // create alice's pin
+    createPin(client, aliceAesKey)
+
+    // use bot's token
+    client.setUserToken(null)
+    // create bob keys
+    val bobSessionKey = generateEd25519KeyPair()
+    val bobPublicKey = bobSessionKey.public as EdDSAPublicKey
+    val bobSessionSecret = bobPublicKey.abyte.base64Encode()
+
+    // create bob
+    val bob = createUser(client, bobSessionSecret)
+    bob ?: return@runBlocking
+    val bobToken = SessionToken.EdDSA(
+        bob.userId, bob.sessionId,
+        (bobSessionKey.private as EdDSAPrivateKey).seed.base64Encode()
+    )
+    client.setUserToken(bobToken)
+    // decrypt pin token
+    val bobPrivateKey = bobSessionKey.private as EdDSAPrivateKey
+    val bobAesKey = calculateAgreement(bob.pinToken.base64Decode(), bobPrivateKey).base64Encode()
+    // create bob's pin
+    createPin(client, bobAesKey)
+
+    // use bot's token
+    client.setUserToken(null)
+    // bot transfer to alice
+    val snapshotBot2Alice = transferToUser(client, alice.userId, pinToken, Config.pin)
+
+    delay(4000)
+
+    // use alice's token
+    client.setUserToken(aliceToken)
+    if (snapshotBot2Alice != null) {
+        // alice check transfer
+        networkSnapshot(client, snapshotBot2Alice.snapshotId)
+
+        val aliceNetworkSnapshots = networkSnapshots(client, CNB_ID, limit = 5)
+        assert(aliceNetworkSnapshots?.find { it.snapshotId == snapshotBot2Alice.snapshotId } != null)
+    }
+
+    // alice transfer to bob
+    val snapshotAlice2Bob = transferToUser(client, bob.userId, aliceAesKey, DEFAULT_PIN)
+
+    delay(4000)
+
+    // use bob's token
+    client.setUserToken(bobToken)
+    if (snapshotAlice2Bob != null) {
+        networkSnapshot(client, snapshotAlice2Bob.snapshotId)
+
+        val bobNetworkSnapshots = networkSnapshots(client, CNB_ID, limit = 5)
+        assert(bobNetworkSnapshots?.find { it.snapshotId == snapshotAlice2Bob.snapshotId } != null)
+    }
+
+}