Implement sending transaction using Blockchair API

bitcoincore/src/main/kotlin/io/horizontalsystems/bitcoincore/BitcoinCore.kt

@@ -1,5 +1,6 @@
 package io.horizontalsystems.bitcoincore
 
+import io.horizontalsystems.bitcoincore.apisync.blockchair.BlockchairApi
 import io.horizontalsystems.bitcoincore.blocks.IPeerSyncListener
 import io.horizontalsystems.bitcoincore.core.DataProvider
 import io.horizontalsystems.bitcoincore.core.IConnectionManager
@@ -519,4 +520,9 @@ class BitcoinCore(
         object ReadOnlyCore : CoreError()
     }
 
+    sealed class SendType {
+        object P2P: SendType()
+        class API(val blockchairApi: BlockchairApi): SendType()
+    }
+
 }

bitcoincore/src/main/kotlin/io/horizontalsystems/bitcoincore/BitcoinCoreBuilder.kt

@@ -86,6 +86,7 @@ import io.horizontalsystems.bitcoincore.network.peer.PeerGroup
 import io.horizontalsystems.bitcoincore.network.peer.PeerManager
 import io.horizontalsystems.bitcoincore.rbf.ReplacementTransactionBuilder
 import io.horizontalsystems.bitcoincore.serializers.BlockHeaderParser
+import io.horizontalsystems.bitcoincore.serializers.TransactionSerializer
 import io.horizontalsystems.bitcoincore.transactions.BlockTransactionProcessor
 import io.horizontalsystems.bitcoincore.transactions.PendingTransactionProcessor
 import io.horizontalsystems.bitcoincore.transactions.SendTransactionsOnPeersSynced
@@ -143,6 +144,7 @@ class BitcoinCoreBuilder {
     private var peerSize = 10
     private val plugins = mutableListOf<IPlugin>()
     private var handleAddrMessage = true
+    private var sendType: BitcoinCore.SendType = BitcoinCore.SendType.P2P
 
     fun setContext(context: Context): BitcoinCoreBuilder {
         this.context = context
@@ -184,6 +186,11 @@ class BitcoinCoreBuilder {
         return this
     }
 
+    fun setSendType(sendType: BitcoinCore.SendType): BitcoinCoreBuilder {
+        this.sendType = sendType
+        return this
+    }
+
     fun setPeerSize(peerSize: Int): BitcoinCoreBuilder {
         if (peerSize < TransactionSender.minConnectedPeerSize) {
             throw Error("Peer size cannot be less than ${TransactionSender.minConnectedPeerSize}")
@@ -480,7 +487,9 @@ class BitcoinCoreBuilder {
                 peerManager,
                 initialDownload,
                 storage,
-                transactionSendTimer
+                transactionSendTimer,
+                sendType,
+                TransactionSerializer
             )
 
             dustCalculator = dustCalculatorInstance

bitcoincore/src/main/kotlin/io/horizontalsystems/bitcoincore/apisync/blockchair/BlockchairApi.kt

@@ -1,5 +1,7 @@
 package io.horizontalsystems.bitcoincore.apisync.blockchair
 
+import com.eclipsesource.json.Json
+import com.eclipsesource.json.JsonObject
 import io.horizontalsystems.bitcoincore.apisync.model.AddressItem
 import io.horizontalsystems.bitcoincore.apisync.model.BlockHeaderItem
 import io.horizontalsystems.bitcoincore.apisync.model.TransactionItem
@@ -76,6 +78,17 @@ class BlockchairApi(
         return BlockHeaderItem(hash.hexToByteArray(), height, timestamp!!)
     }
 
+    fun broadcastTransaction(rawTransactionHex: String) {
+        val apiManager = ApiManager("https://api.blockchair.com")
+        val url = "$chainId/push/transaction"
+
+        val body = JsonObject().apply {
+            this["data"] = Json.value(rawTransactionHex)
+        }.toString()
+
+        apiManager.post(url, body)
+    }
+
     private fun fetchTransactions(
         addresses: List<String>,
         stopHeight: Int? = null,
@@ -125,7 +138,7 @@ class BlockchairApi(
 
     private fun dateStringToTimestamp(date: String): Long? {
         return try {
-            dateFormat.parse(date)?.time?.let {  it / 1000 }
+            dateFormat.parse(date)?.time?.let { it / 1000 }
         } catch (e: ParseException) {
             null
         }

bitcoincore/src/main/kotlin/io/horizontalsystems/bitcoincore/managers/ApiManager.kt

@@ -2,8 +2,10 @@ package io.horizontalsystems.bitcoincore.managers
 
 import com.eclipsesource.json.Json
 import com.eclipsesource.json.JsonValue
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.BufferedOutputStream
 import java.io.BufferedWriter
 import java.io.IOException
@@ -30,6 +32,7 @@ class ApiManager(private val host: String) {
                         connectTimeout = 5000
                         readTimeout = 60000
                         setRequestProperty("Accept", "application/json")
+                        setRequestProperty("content-type", "application/json")
                     }.getInputStream()
         } catch (exception: IOException) {
             throw ApiManagerException.Other("${exception.javaClass.simpleName}: $host")
@@ -46,6 +49,7 @@ class ApiManager(private val host: String) {
             val url = URL(path)
             val urlConnection = url.openConnection() as HttpURLConnection
             urlConnection.requestMethod = "POST"
+            urlConnection.setRequestProperty("Content-Type", "application/json")
             val out = BufferedOutputStream(urlConnection.outputStream)
             val writer = BufferedWriter(OutputStreamWriter(out, "UTF-8"))
             writer.write(data)
@@ -95,6 +99,7 @@ class ApiManager(private val host: String) {
             throw ApiManagerException.Other("${e.javaClass.simpleName}: $host, ${e.localizedMessage}")
         }
     }
+
 }
 
 sealed class ApiManagerException : Exception() {

bitcoincore/src/main/kotlin/io/horizontalsystems/bitcoincore/transactions/TransactionSender.kt

@@ -1,26 +1,31 @@
 package io.horizontalsystems.bitcoincore.transactions
 
-import io.horizontalsystems.bitcoincore.blocks.InitialBlockDownload
+import io.horizontalsystems.bitcoincore.BitcoinCore
+import io.horizontalsystems.bitcoincore.apisync.blockchair.BlockchairApi
 import io.horizontalsystems.bitcoincore.core.IInitialDownload
 import io.horizontalsystems.bitcoincore.core.IStorage
+import io.horizontalsystems.bitcoincore.extensions.toHexString
 import io.horizontalsystems.bitcoincore.models.SentTransaction
 import io.horizontalsystems.bitcoincore.network.peer.IPeerTaskHandler
 import io.horizontalsystems.bitcoincore.network.peer.Peer
 import io.horizontalsystems.bitcoincore.network.peer.PeerGroup
 import io.horizontalsystems.bitcoincore.network.peer.PeerManager
 import io.horizontalsystems.bitcoincore.network.peer.task.PeerTask
 import io.horizontalsystems.bitcoincore.network.peer.task.SendTransactionTask
+import io.horizontalsystems.bitcoincore.serializers.TransactionSerializer
 import io.horizontalsystems.bitcoincore.storage.FullTransaction
 
 class TransactionSender(
-        private val transactionSyncer: TransactionSyncer,
-        private val peerManager: PeerManager,
-        private val initialBlockDownload: IInitialDownload,
-        private val storage: IStorage,
-        private val timer: TransactionSendTimer,
-        private val maxRetriesCount: Int = 3,
-        private val retriesPeriod: Int = 60)
-    : IPeerTaskHandler, TransactionSendTimer.Listener {
+    private val transactionSyncer: TransactionSyncer,
+    private val peerManager: PeerManager,
+    private val initialBlockDownload: IInitialDownload,
+    private val storage: IStorage,
+    private val timer: TransactionSendTimer,
+    private val sendType: BitcoinCore.SendType,
+    private val transactionSerializer: TransactionSerializer,
+    private val maxRetriesCount: Int = 3,
+    private val retriesPeriod: Int = 60
+) : IPeerTaskHandler, TransactionSendTimer.Listener {
 
     fun sendPendingTransactions() {
         try {
@@ -68,13 +73,13 @@ class TransactionSender(
         }
 
         val freeSyncedPeer = initialBlockDownload.syncedPeers
-                .sortedBy { it.ready } // not ready first
-                .firstOrNull()
-                ?: return emptyList()
+            .sortedBy { it.ready } // not ready first
+            .firstOrNull()
+            ?: return emptyList()
 
         val readyPeers = peerManager.readyPears()
-                .filter { it != freeSyncedPeer }
-                .sortedBy { it.synced } // not synced first
+            .filter { it != freeSyncedPeer }
+            .sortedBy { it.synced } // not synced first
 
         if (readyPeers.size == 1) {
             return readyPeers
@@ -84,6 +89,31 @@ class TransactionSender(
     }
 
     private fun send(transactions: List<FullTransaction>) {
+        when (sendType) {
+            BitcoinCore.SendType.P2P -> {
+                sendViaP2P(transactions)
+            }
+
+            is BitcoinCore.SendType.API -> {
+                sendViaAPI(transactions, sendType.blockchairApi)
+            }
+        }
+    }
+
+    private fun sendViaAPI(transactions: List<FullTransaction>, blockchairApi: BlockchairApi) {
+        transactions.forEach { transaction ->
+            try {
+                val hex = transactionSerializer.serialize(transaction).toHexString()
+                blockchairApi.broadcastTransaction(hex)
+
+                transactionSyncer.handleRelayed(listOf(transaction))
+            } catch (error: Throwable) {
+                transactionSyncer.handleInvalid(transaction)
+            }
+        }
+    }
+
+    private fun sendViaP2P(transactions: List<FullTransaction>) {
         val peers = getPeersToSend()
         if (peers.isEmpty()) {
             return
@@ -139,6 +169,7 @@ class TransactionSender(
                 transactionSendSuccess(task.transaction)
                 true
             }
+
             else -> false
         }
     }

litecoinkit/src/main/kotlin/io/horizontalsystems/litecoinkit/LitecoinKit.kt

@@ -30,7 +30,6 @@ import io.horizontalsystems.bitcoincore.storage.Storage
 import io.horizontalsystems.bitcoincore.transactions.scripts.ScriptType
 import io.horizontalsystems.bitcoincore.utils.AddressConverterChain
 import io.horizontalsystems.bitcoincore.utils.Base58AddressConverter
-import io.horizontalsystems.bitcoincore.utils.CashAddressConverter
 import io.horizontalsystems.bitcoincore.utils.PaymentAddressParser
 import io.horizontalsystems.bitcoincore.utils.SegwitAddressConverter
 import io.horizontalsystems.hdwalletkit.HDExtendedKey
@@ -167,7 +166,8 @@ class LitecoinKit : AbstractKit {
         val storage = Storage(database)
         val checkpoint = Checkpoint.resolveCheckpoint(syncMode, network, storage)
         val apiSyncStateManager = ApiSyncStateManager(storage, network.syncableFromApi && syncMode !is SyncMode.Full)
-        val apiTransactionProvider = apiTransactionProvider(networkType, syncMode, apiSyncStateManager)
+        val blockchairApi = BlockchairApi(network.blockchairChainId)
+        val apiTransactionProvider = apiTransactionProvider(networkType, syncMode, apiSyncStateManager, blockchairApi)
         val paymentAddressParser = PaymentAddressParser("litecoin", removeScheme = true)
         val blockValidatorSet = blockValidatorSet(storage, networkType)
 
@@ -183,6 +183,7 @@ class LitecoinKit : AbstractKit {
             .setPaymentAddressParser(paymentAddressParser)
             .setPeerSize(peerSize)
             .setSyncMode(syncMode)
+            .setSendType(BitcoinCore.SendType.API(blockchairApi))
             .setConfirmationThreshold(confirmationsThreshold)
             .setStorage(storage)
             .setApiTransactionProvider(apiTransactionProvider)
@@ -260,13 +261,13 @@ class LitecoinKit : AbstractKit {
     private fun apiTransactionProvider(
         networkType: NetworkType,
         syncMode: SyncMode,
-        apiSyncStateManager: ApiSyncStateManager
+        apiSyncStateManager: ApiSyncStateManager,
+        blockchairApi: BlockchairApi
     ) = when (networkType) {
         NetworkType.MainNet -> {
             val bCoinApiProvider = BCoinApi("https://ltc.blocksdecoded.com/api")
 
             if (syncMode is SyncMode.Blockchair) {
-                val blockchairApi = BlockchairApi(network.blockchairChainId)
                 val blockchairBlockHashFetcher = BlockchairBlockHashFetcher(blockchairApi)
                 val blockchairProvider = BlockchairTransactionProvider(blockchairApi, blockchairBlockHashFetcher)