Sync special dash transactions

BitcoinCore/Classes/Models/DataObjects.swift

@@ -23,7 +23,7 @@ public struct BlockHeader {
 
 }
 
-public struct FullTransaction {
+open class FullTransaction {
 
     public let header: Transaction
     public let inputs: [Input]
@@ -35,15 +35,21 @@ public struct FullTransaction {
         self.inputs = inputs
         self.outputs = outputs
 
-        let hash = Kit.sha256sha256(TransactionSerializer.serialize(transaction: self, withoutWitness: true))
-        self.header.dataHash = hash
+        if header.dataHash.isEmpty { //todo: check logic. It avoid double check if some special transactions make tx with already hash
+            let hash = Kit.sha256sha256(TransactionSerializer.serialize(transaction: self, withoutWitness: true))
+            set(hash: hash)
+        }
+    }
+
+    public func set(hash: Data) {
+        header.dataHash = hash
         metaData.transactionHash = hash
 
-        for input in self.inputs {
-            input.transactionHash = self.header.dataHash
+        for input in inputs {
+            input.transactionHash = header.dataHash
         }
-        for output in self.outputs {
-            output.transactionHash = self.header.dataHash
+        for output in outputs {
+            output.transactionHash = header.dataHash
         }
     }
 

BitcoinCore/Classes/Network/Helpers/ByteStream.swift

@@ -32,6 +32,10 @@ public class ByteStream {
     }
 
     public func read(_ type: VarInt.Type) -> VarInt {
+        guard data.count > offset else {
+            return VarInt(0)
+        }
+
         let len = data[offset..<(offset + 1)].to(type: UInt8.self)
         let length: UInt64
         switch len {

BitcoinCore/Classes/Network/Messages/TransactionMessage.swift

@@ -1,11 +1,16 @@
 import UIExtensions
 
-struct TransactionMessage: IMessage {
+public struct TransactionMessage: IMessage {
     let transaction: FullTransaction
     let size: Int
 
-    var description: String {
-        return "\(transaction.header.dataHash.reversedHex)"
+    public init(transaction: FullTransaction, size: Int) {
+        self.transaction = transaction
+        self.size = size
+    }
+
+    public var description: String {
+        "\(transaction.header.dataHash.reversedHex)"
     }
 
 }

DashKit/Classes/Core/Kit.swift

@@ -98,6 +98,7 @@ public class Kit: AbstractKit {
                 .add(messageParser: TransactionLockVoteMessageParser())
                 .add(messageParser: MasternodeListDiffMessageParser(masternodeParser: masternodeParser, quorumParser: quorumParser))
                 .add(messageParser: ISLockParser(hasher: doubleShaHasher))
+                .add(messageParser: TransactionMessageParser(hasher: doubleShaHasher))
 
         bitcoinCore.add(messageSerializer: GetMasternodeListDiffMessageSerializer())
 

DashKit/Classes/Models/SpecialTransaction.swift

@@ -0,0 +1,11 @@
+import Foundation
+import BitcoinCore
+
+class SpecialTransaction: FullTransaction {
+    let extraPayload: Data
+
+    init(transaction: FullTransaction, extraPayload: Data) {
+        self.extraPayload = extraPayload
+        super.init(header: transaction.header, inputs: transaction.inputs, outputs: transaction.outputs)
+    }
+}

DashKit/Classes/Network/Messages/TransactionMessageParser.swift

@@ -0,0 +1,40 @@
+import Foundation
+import BitcoinCore
+import OpenSslKit
+
+class TransactionMessageParser: IMessageParser {
+    let id: String = "tx"
+
+    let hasher: IDashHasher
+
+    init(hasher: IDashHasher) {
+        self.hasher = hasher
+    }
+
+    private func parseSpecialTxData(input: ByteStream, transaction: FullTransaction) -> SpecialTransaction {
+        let payloadSize = input.read(VarInt.self)
+        let payload = input.read(Data.self, count: Int(payloadSize.underlyingValue))
+
+        var output = TransactionSerializer.serialize(transaction: transaction)
+        output += payloadSize.data
+        output += payload
+
+        let hash = hasher.hash(data: output)
+        transaction.set(hash: hash)
+
+        return SpecialTransaction(transaction: transaction, extraPayload: payload)
+    }
+
+    func parse(data: Data) -> IMessage {
+        let byteStream = ByteStream(data)
+        var transaction = TransactionSerializer.deserialize(byteStream: byteStream)
+
+        let version = Data(from: transaction.header.version)
+        let isSpecialTransaction = (Int(version[0]) + Int(version[1])) > 0
+        if isSpecialTransaction {
+            transaction = parseSpecialTxData(input: byteStream, transaction: transaction)
+        }
+
+        return TransactionMessage(transaction: transaction, size: data.count)
+    }
+}