react-native-zcash 0.3.5 → 0.4.1

package/ios/ZCashLightClientKit/Entity/TransactionEntity.swift

@@ -1,105 +1,230 @@
 //
-//  File.swift
+//  TransactionEntity.swift
 //  ZcashLightClientKit
 //
 //  Created by Francisco Gindre on 11/14/19.
 //
 
 import Foundation
-/**
-convenience representation of all transaction types
-*/
-public protocol TransactionEntity {
-    /**
-    Internal transaction id
-    */
-    var id: Int? { get set }
-
-    /**
-    Blockchain transaction id
-    */
-    var transactionId: Data { get set }
-
-    /**
-    String representing the date  of creation
-     
-    format is yyyy-MM-dd'T'HH:MM:ss.SSSSSSSSSZ
-    - Example:  2019-12-04T17:49:10.636624000Z
-    */
-    var created: String? { get set }
-    var transactionIndex: Int? { get set }
-    var expiryHeight: BlockHeight? { get set }
-    var minedHeight: BlockHeight? { get set }
-    var raw: Data? { get set }
+import SQLite
+
+public enum ZcashTransaction {
+    public struct Overview {
+        /// Represents the transaction state based on current height of the chain,
+        /// mined height and expiry height of a transaction.
+        public enum State {
+            /// transaction has a `minedHeight` that's greater or equal than
+            /// `ZcashSDK.defaultStaleTolerance` confirmations.
+            case confirmed
+            /// transaction has no `minedHeight` but current known height is less than
+            /// `expiryHeight`.
+            case pending
+            /// transaction has no
+            case expired
+
+            init(
+                currentHeight: BlockHeight,
+                minedHeight: BlockHeight?,
+                expiredUnmined: Bool
+            ) {
+                guard !expiredUnmined else {
+                    self = .expired
+                    return
+                }
+
+                if let minedHeight, (currentHeight - minedHeight) >= ZcashSDK.defaultStaleTolerance {
+                    self = .confirmed
+                } else if let minedHeight, (currentHeight - minedHeight) < ZcashSDK.defaultStaleTolerance {
+                    self = .pending
+                } else if minedHeight == nil {
+                    self = .pending
+                } else {
+                    self = .expired
+                }
+            }
+        }
+
+        public let accountId: Int
+        public let blockTime: TimeInterval?
+        public let expiryHeight: BlockHeight?
+        public let fee: Zatoshi?
+        public let id: Int
+        public let index: Int?
+        public var isSentTransaction: Bool { value < Zatoshi(0) }
+        public let hasChange: Bool
+        public let memoCount: Int
+        public let minedHeight: BlockHeight?
+        public let raw: Data?
+        public let rawID: Data
+        public let receivedNoteCount: Int
+        public let sentNoteCount: Int
+        public let value: Zatoshi
+        public let isExpiredUmined: Bool
+    }
+
+    public struct Output {
+        public enum Pool {
+            case transaparent
+            case sapling
+            case other(Int)
+            init(rawValue: Int) {
+                switch rawValue {
+                case 0:
+                    self = .transaparent
+                case 2:
+                    self = .sapling
+                default:
+                    self = .other(rawValue)
+                }
+            }
+        }
+
+        public let idTx: Int
+        public let pool: Pool
+        public let index: Int
+        public let fromAccount: Int?
+        public let recipient: TransactionRecipient
+        public let value: Zatoshi
+        public let isChange: Bool
+        public let memo: Memo?
+    }
+
+    /// Used when fetching blocks from the lightwalletd
+    struct Fetched {
+        public let rawID: Data
+        public let minedHeight: BlockHeight
+        public let raw: Data
+    }
 }
 
-/**
-Hashable extension default implementation
-*/
-public extension TransactionEntity {
-    func hash(into hasher: inout Hasher) {
-        hasher.combine(id)
-        hasher.combine(transactionId)
-        hasher.combine(expiryHeight)
-        hasher.combine(minedHeight)
-        hasher.combine(raw)
+extension ZcashTransaction.Output {
+    enum Column {
+        static let idTx = Expression<Int>("id_tx")
+        static let pool = Expression<Int>("output_pool")
+        static let index = Expression<Int>("output_index")
+        static let toAccount = Expression<Int?>("to_account")
+        static let fromAccount = Expression<Int?>("from_account")
+        static let toAddress = Expression<String?>("to_address")
+        static let value = Expression<Int64>("value")
+        static let isChange = Expression<Bool>("is_change")
+        static let memo = Expression<Blob?>("memo")
+    }
+
+    init(row: Row) throws {
+        do {
+            idTx = try row.get(Column.idTx)
+            pool = .init(rawValue: try row.get(Column.pool))
+            index = try row.get(Column.index)
+            fromAccount = try row.get(Column.fromAccount)
+            value = Zatoshi(try row.get(Column.value))
+            isChange = try row.get(Column.isChange)
+            
+            if
+                let outputRecipient = try row.get(Column.toAddress),
+                let metadata = DerivationTool.getAddressMetadata(outputRecipient)
+            {
+                recipient = TransactionRecipient.address(try Recipient(outputRecipient, network: metadata.networkType))
+            } else if let toAccount = try row.get(Column.toAccount) {
+                recipient = .internalAccount(UInt32(toAccount))
+            } else {
+                throw ZcashError.zcashTransactionOutputInconsistentRecipient
+            }
+
+            if let memoData = try row.get(Column.memo) {
+                memo = try Memo(bytes: memoData.bytes)
+            } else {
+                memo = nil
+            }
+        } catch {
+            throw ZcashError.zcashTransactionOutputInit(error)
+        }
+    }
+}
+
+extension ZcashTransaction.Overview {
+    enum Column {
+        static let accountId = Expression<Int>("account_id")
+        static let id = Expression<Int>("id_tx")
+        static let minedHeight = Expression<BlockHeight?>("mined_height")
+        static let index = Expression<Int?>("tx_index")
+        static let rawID = Expression<Blob>("txid")
+        static let expiryHeight = Expression<BlockHeight?>("expiry_height")
+        static let raw = Expression<Blob?>("raw")
+        static let value = Expression<Int64>("account_balance_delta")
+        static let fee = Expression<Int64?>("fee_paid")
+        static let hasChange = Expression<Bool>("has_change")
+        static let sentNoteCount = Expression<Int>("sent_note_count")
+        static let receivedNoteCount = Expression<Int>("received_note_count")
+        static let memoCount = Expression<Int>("memo_count")
+        static let blockTime = Expression<Int64?>("block_time")
+        static let expiredUnmined = Expression<Bool>("expired_unmined")
     }
-    
-    static func == (lhs: Self, rhs: Self) -> Bool {
-        guard
-            lhs.id == rhs.id,
-            lhs.transactionId == rhs.transactionId,
-            lhs.created == rhs.created,
-            lhs.expiryHeight == rhs.expiryHeight,
-            lhs.minedHeight == rhs.minedHeight,
-            ((lhs.raw != nil && rhs.raw != nil) || (lhs.raw == nil && rhs.raw == nil))
-        else { return false }
-        
-        if let lhsRaw = lhs.raw, let rhsRaw = rhs.raw {
-            return lhsRaw == rhsRaw
+
+    init(row: Row) throws {
+        do {
+            self.accountId = try row.get(Column.accountId)
+            self.expiryHeight = try row.get(Column.expiryHeight)
+            self.id = try row.get(Column.id)
+            self.index = try row.get(Column.index)
+            self.hasChange = try row.get(Column.hasChange)
+            self.memoCount = try row.get(Column.memoCount)
+            self.minedHeight = try row.get(Column.minedHeight)
+            self.rawID = Data(blob: try row.get(Column.rawID))
+            self.receivedNoteCount = try row.get(Column.receivedNoteCount)
+            self.sentNoteCount = try row.get(Column.sentNoteCount)
+            self.value = Zatoshi(try row.get(Column.value))
+            self.isExpiredUmined = try row.get(Column.expiredUnmined)
+            
+            if let blockTime = try row.get(Column.blockTime) {
+                self.blockTime = TimeInterval(blockTime)
+            } else {
+                self.blockTime = nil
+            }
+
+            if let fee = try row.get(Column.fee) {
+                self.fee = Zatoshi(fee)
+            } else {
+                self.fee = nil
+            }
+
+            if let raw = try row.get(Column.raw) {
+                self.raw = Data(blob: raw)
+            } else {
+                self.raw = nil
+            }
+        } catch {
+            throw ZcashError.zcashTransactionOverviewInit(error)
         }
-        
-        return true
     }
-    
+
     func anchor(network: ZcashNetwork) -> BlockHeight? {
-        if let minedHeight = self.minedHeight, minedHeight != -1 {
+        guard let minedHeight = self.minedHeight else { return nil }
+        if minedHeight != -1 {
             return max(minedHeight - ZcashSDK.defaultStaleTolerance, network.constants.saplingActivationHeight)
         }
-        
-        if let expiryHeight = self.expiryHeight, expiryHeight != -1 {
+
+        guard let expiryHeight = self.expiryHeight else { return nil }
+        if expiryHeight != -1 {
             return max(expiryHeight - ZcashSDK.expiryOffset - ZcashSDK.defaultStaleTolerance, network.constants.saplingActivationHeight)
         }
-        
+
         return nil
     }
 }
 
-/**
-Abstract representation of all transaction types
-*/
-public protocol AbstractTransaction {
-    /**
-    internal id for this transaction
-    */
-    var id: Int? { get set }
-
-    /**
-    value in zatoshi
-    */
-    var value: Int { get set }
-
-    /**
-    data containing the memo if any
-    */
-    var memo: Data? { get set }
-}
+/// extension to handle pending states
+public extension ZcashTransaction.Overview {
+    func getState(for currentHeight: BlockHeight) -> State {
+        State(
+            currentHeight: currentHeight,
+            minedHeight: minedHeight,
+            expiredUnmined: self.isExpiredUmined
+        )
+    }
 
-/**
-Capabilites of a signed transaction
-*/
-public protocol SignedTransactionEntity {
-    var raw: Data? { get set }
+    func isPending(currentHeight: BlockHeight) -> Bool {
+        getState(for: currentHeight) == .pending
+    }
 }
 
 /**
@@ -108,54 +233,3 @@ Capabilities of an entity that can be uniquely identified by a raw transaction i
 public protocol RawIdentifiable {
     var rawTransactionId: Data? { get set }
 }
-
-/**
-Attributes that a Mined transaction must have
-*/
-public protocol MinedTransactionEntity: AbstractTransaction, RawIdentifiable {
-    /**
-    height on which this transaction was mined at. Convention is that -1 is retuned when it has not been mined yet
-    */
-    var minedHeight: Int { get set }
-    
-    /**
-    internal note id that is involved on this transaction
-    */
-    var noteId: Int { get set }
-
-    /**
-    block time in in reference since 1970
-    */
-    var blockTimeInSeconds: TimeInterval { get set }
-
-    /**
-    internal index for this transaction
-    */
-    var transactionIndex: Int { get set }
-}
-
-public protocol ConfirmedTransactionEntity: MinedTransactionEntity, SignedTransactionEntity {
-    /**
-    recipient address if available
-    */
-    var toAddress: String? { get set }
-
-    /**
-    expiration height for this transaction
-    */
-    var expiryHeight: BlockHeight? { get set }
-}
-
-public extension ConfirmedTransactionEntity {
-    var isOutbound: Bool {
-        self.toAddress != nil
-    }
-    
-    var isInbound: Bool {
-        self.toAddress == nil
-    }
-    
-    var blockTimeInMilliseconds: Double {
-        self.blockTimeInSeconds * 1000
-    }
-}

package/ios/ZCashLightClientKit/Entity/UnspentTransactionOutputEntity.swift

@@ -8,10 +8,11 @@
 import Foundation
 
 public protocol UnspentTransactionOutputEntity {
-    var address: String { get set }
-    var txid: Data { get set }
-    var index: Int { get set }
-    var script: Data { get set }
-    var valueZat: Int { get set }
-    var height: Int { get set }
+    // TODO: [#714] Remove address field?, https://github.com/zcash/ZcashLightClientKit/issues/714
+    var address: String { get }
+    var txid: Data { get }
+    var index: Int { get }
+    var script: Data { get }
+    var valueZat: Int { get }
+    var height: Int { get }
 }

package/ios/ZCashLightClientKit/Entity/ZcashCompactBlock.swift

@@ -0,0 +1,96 @@
+//
+//  ZcashCompactBlock.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+public typealias BlockHeight = Int
+public typealias CompactBlockRange = ClosedRange<BlockHeight>
+
+extension BlockHeight {
+    static func empty() -> BlockHeight {
+        BlockHeight(-1)
+    }
+}
+
+/**
+A Zcash compact block to store on cache DB
+*/
+public struct ZcashCompactBlock {
+    struct Meta {
+        let hash: Data
+        let time: UInt32
+        let saplingOutputs: UInt32
+        let orchardOutputs: UInt32
+    }
+
+    public let height: BlockHeight
+    public let data: Data
+
+    let meta: Meta
+}
+
+extension ZcashCompactBlock: Encodable {
+    enum CodingKeys: CodingKey {
+        case height
+        case data
+        case meta
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        do {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            try container.encode(data, forKey: .data)
+            try container.encode(height, forKey: .height)
+        } catch {
+            throw ZcashError.compactBlockEncode(error)
+        }
+    }
+}
+
+extension ZcashCompactBlock {
+    init(compactBlock: CompactBlock) {
+        self.height = Int(compactBlock.height)
+        self.data = (try? compactBlock.serializedData()) ?? Data()
+        let outputs = compactBlock.outputCount
+        self.meta = Meta(
+            hash: compactBlock.hash,
+            time: compactBlock.time,
+            saplingOutputs: outputs.0,
+            orchardOutputs: outputs.1
+        )
+    }
+}
+
+extension CompactBlock {
+    /// O(n) sum of all CompactTx sapling outputs and Orchard Actions
+    /// - Returns: a tuple (SaplingOutputs, OrchardActions)
+    var outputCount: (UInt32, UInt32) {
+        vtx.compactMap { compactTx -> (UInt32, UInt32) in
+            (UInt32(compactTx.outputs.count), UInt32(compactTx.actions.count))
+        }
+        .reduce((0, 0)) { partialResult, txOutputActionPair in
+            (partialResult.0 + txOutputActionPair.0, partialResult.1 + txOutputActionPair.1)
+        }
+    }
+}
+extension ZcashCompactBlock: Equatable {
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        if lhs.height != rhs.height {
+            return false
+        }
+        
+        return lhs.data == rhs.data
+    }
+}
+
+extension ZcashCompactBlock: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(height)
+        hasher.combine(data)
+    }
+}

package/ios/ZCashLightClientKit/Error/Sourcery/ZcashError.stencil

@@ -0,0 +1,40 @@
+/*
+!!!!! To edit this file go to ZcashErrorCodeDefinition first and udate/add codes. Then run generateErrorCode.sh script to regenerate this file.
+
+By design each error should be used only at one place in the app. Thanks to that it is possible to identify exact line in the code from which the
+error originates. And it can help with debugging.
+*/
+
+import Foundation
+
+{% for type in types.enums where type.name == "ZcashErrorDefinition" %}
+public enum ZcashError: Equatable, Error {
+    {% for case in type.cases %}
+    {% for docLine in case.documentation %}
+    /// {{ docLine }}
+    {% endfor %}
+    /// {{ case.annotations["code"] }}
+    case {{ case.name }}{% if case.associatedValues.count > 0 %}({% for value in case.associatedValues %}_ {{ value.externalName }}: {{ value.typeName }}{% if not forloop.last%}, {% endif %}{% endfor %}){% endif %}
+    {% endfor %}
+
+    public var message: String {
+        switch self {
+        {% for case in type.cases %}
+        case .{{ case.name }}: return "{{ case.documentation[0] }}"
+        {% endfor %}
+        }
+    }
+
+    public var code: ZcashErrorCode {
+        switch self {
+            {% for case in type.cases %}
+        case .{{ case.name }}: return .{{ case.name}}
+            {% endfor %}
+        }
+    }
+
+    public static func == (lhs: ZcashError, rhs: ZcashError) -> Bool {
+        return lhs.code == rhs.code
+    }
+}
+{% endfor %}

package/ios/ZCashLightClientKit/Error/Sourcery/ZcashErrorCode.stencil

@@ -0,0 +1,15 @@
+/*
+!!!!! To edit this file go to ZcashErrorCodeDefinition first and udate/add codes. Then run generateErrorCode.sh script to regenerate this file.
+
+By design each error code should be used only at one place in the app. Thanks to that it is possible to identify exact line in the code from which the
+error originates. And it can help with debugging.
+*/
+
+{% for type in types.enums where type.name == "ZcashErrorDefinition" %}
+public enum ZcashErrorCode: String {
+    {% for case in type.cases %}
+    /// {{ case.documentation[0] }}
+    case {{ case.name }} = "{{ case.annotations["code"] }}"
+    {% endfor %}
+}
+{% endfor %}

package/ios/ZCashLightClientKit/Error/Sourcery/generateErrorCode.sh

@@ -0,0 +1,34 @@
+#!/bin/zsh
+
+scriptDir=${0:a:h}
+cd "${scriptDir}"
+
+sourcery_version=2.0.2
+
+if which sourcery >/dev/null; then
+    if [[ $(sourcery --version) != $sourcery_version ]]; then
+        echo "warning: Compatible sourcer version not installed. Install sourcer $sourcery_version. Currently installed version is $(sourcer --version)"
+        exit 1
+    fi
+
+    sourcery \
+        --disableCache \
+        --parseDocumentation \
+        --verbose \
+        --sources ./ \
+        --sources ../ \
+        --templates ZcashErrorCode.stencil \
+        --output ../ZcashErrorCode.swift
+
+    sourcery \
+        --disableCache \
+        --parseDocumentation \
+        --verbose \
+        --sources ./ \
+        --sources ../ \
+        --templates ZcashError.stencil \
+        --output ../ZcashError.swift
+
+else
+    echo "warning: sourcery not installed"
+fi