transactionHash.requestTransactionReceipt() returns type depends on callAdapter

Author: tempofeng

etherspace-java/src/main/java/cc/etherspace/EtherSpace.kt

@@ -4,10 +4,8 @@ import cc.etherspace.calladapter.CallAdapter
 import cc.etherspace.calladapter.PassThroughCallAdaptor
 import cc.etherspace.web3j.Web3jAdapter
 import com.google.common.reflect.TypeToken
-import kotlinx.coroutines.experimental.runBlocking
 import okhttp3.OkHttpClient
 import java.io.IOException
-import java.lang.Thread.sleep
 import java.lang.reflect.AnnotatedElement
 import java.lang.reflect.Method
 import java.lang.reflect.Proxy
@@ -59,7 +57,8 @@ class EtherSpace(val web3: Web3,
                         if (functionName.isNotBlank()) functionName else method.name,
                         params,
                         actualReturnType,
-                        options)
+                        options,
+                        callAdapter)
             }
 
             throw IllegalArgumentException("There is no Send/Call annotation on this method")
@@ -78,7 +77,8 @@ class EtherSpace(val web3: Web3,
                                           functionName: String,
                                           args: List<Any>,
                                           returnType: Type,
-                                          options: Options): Any {
+                                          options: Options,
+                                          callAdapter: CallAdapter<Any, Any>): Any {
         val cd = options.credentials ?: credentials
         ?: throw IllegalArgumentException("Credentials not set")
         val np = options.nonceProvider ?: nonceProvider
@@ -95,12 +95,10 @@ class EtherSpace(val web3: Web3,
         return when {
             returnTypeToken.isSubtypeOf(String::class.java) -> transactionHash
             returnTypeToken.isSubtypeOf(TransactionReceipt::class.java) -> {
-                runBlocking {
-                    TransactionHash(web3, transactionHash).requestTransactionReceipt()
-                }
+                TransactionHash(web3, transactionHash, callAdapter).requestTransactionReceiptBlocking()
             }
             returnTypeToken.isSubtypeOf(TransactionHash::class.java) -> {
-                TransactionHash(web3, transactionHash)
+                TransactionHash(web3, transactionHash, callAdapter)
             }
             else -> throw IllegalArgumentException("Unknown return type:${returnType.typeName}")
         }

etherspace-java/src/main/java/cc/etherspace/TransactionHash.kt

@@ -1,18 +1,26 @@
 package cc.etherspace
 
-import kotlinx.coroutines.experimental.delay
+import cc.etherspace.calladapter.CallAdapter
 import java.io.IOException
 
 data class TransactionHash(private val web3: Web3,
-                           val hash: String) {
-    suspend fun requestTransactionReceipt(): TransactionReceipt {
+                           val hash: String,
+                           private val callAdapter: CallAdapter<Any, Any>) {
+    @Suppress("UNCHECKED_CAST")
+    fun <T> requestTransactionReceipt(): T {
+        return callAdapter.adapt {
+            return@adapt requestTransactionReceiptBlocking()
+        } as T
+    }
+
+    internal fun requestTransactionReceiptBlocking(): TransactionReceipt {
         for (i in 1..EtherSpace.GET_TRANSACTION_RECEIPT_POLLING_ATTEMPTS) {
             val transactionReceipt = web3.eth.getTransactionReceipt(hash)
             if (transactionReceipt != null) {
                 if (!transactionReceipt.success) throw TransactionFailedException(transactionReceipt)
                 return transactionReceipt
             }
-            delay(EtherSpace.GET_TRANSACTION_RECEIPT_POLLING_INTERVAL_IN_MS)
+            Thread.sleep(EtherSpace.GET_TRANSACTION_RECEIPT_POLLING_INTERVAL_IN_MS)
         }
         throw IOException("transactionTimeout:transactionHash=$this")
     }

etherspace-java/src/test/java/cc/etherspace/calladapter/CoroutineGreeter.kt

@@ -13,6 +13,10 @@ interface CoroutineGreeter {
     @Send
     fun newGreeting(greeting: String, options: Options): Deferred<TransactionReceipt>
 
+    @Throws(IOException::class)
+    @Send(functionName = "newGreeting")
+    fun newGreeting_transactionHash(greeting: String): Deferred<TransactionHash>
+
     @Throws(IOException::class)
     @Call
     fun greet(): Deferred<String>

etherspace-java/src/test/java/cc/etherspace/calladapter/CoroutineGreeterTest.kt

@@ -1,6 +1,7 @@
 package cc.etherspace.calladapter
 
 import cc.etherspace.*
+import kotlinx.coroutines.experimental.Deferred
 import kotlinx.coroutines.experimental.runBlocking
 import org.amshove.kluent.`should be equal to`
 import org.amshove.kluent.`should be greater than`
@@ -44,6 +45,20 @@ class CoroutineGreeterTest {
         }
     }
 
+    @Test
+    fun newGreeting_transactionHash() {
+        runBlocking {
+            val hash = greeter.newGreeting_transactionHash("Hello World").await()
+            hash.hash.length.`should be equal to`(66)
+            val receipt = hash.requestTransactionReceipt<Deferred<TransactionReceipt>>().await()
+            receipt.blockHash.length.`should be equal to`(66)
+            receipt.transactionHash.length.`should be equal to`(66)
+            receipt.from!!.`should be equal to`(Tests.TEST_WALLET_ADDRESS)
+            receipt.to!!.`should be equal to`(Tests.TEST_CONTRACT_ADDRESS)
+            receipt.logs.size.`should be greater than`(0)
+        }
+    }
+
     @Test(expected = IOException::class)
     fun newGreeting_options() {
         runBlocking {