react-native-zcash 0.3.5 → 0.4.0

package/ios/ZCashLightClientKit/Model/WalletTypes.swift

@@ -1,108 +1,281 @@
 //
 //  WalletTypes.swift
-//  Pods
+//
 //
 //  Created by Francisco Gindre on 4/6/21.
 //
 
-/**
-Represents the wallet's birthday which can be thought of as a checkpoint at the earliest moment in history where
-transactions related to this wallet could exist. Ideally, this would correspond to the latest block height at the
-time the wallet key was created. Worst case, the height of Sapling activation could be used (280000).
- 
-Knowing a wallet's birthday can significantly reduce the amount of data that it needs to download because none of
-the data before that height needs to be scanned for transactions. However, we do need the Sapling tree data in
-order to construct valid transactions from that point forward. This birthday contains that tree data, allowing us
-to avoid downloading all the compact blocks required in order to generate it.
- 
-New wallets can ignore any blocks created before their birthday.
- 
-- Parameters:
-    - height: the height at the time the wallet was born
-    -  hash: the block hash corresponding to the given height
-    -  time: the time the wallet was born, in seconds
-    -  tree: the sapling tree corresponding to the given height. This takes around 15 minutes of processing to
-generate from scratch because all blocks since activation need to be considered. So when it is calculated in
-advance it can save the user a lot of time.
-*/
-public struct WalletBirthday: Equatable {
-    public private(set) var height: BlockHeight = -1
-    public private(set) var hash: String = ""
-    public private(set) var time: UInt32 = 0
-    public private(set) var tree: String = ""
+/// Something that can be encoded as a String
+public protocol StringEncoded {
+    var stringEncoded: String { get }
+}
+
+public struct UnifiedSpendingKey: Equatable, Undescribable {
+    let network: NetworkType
+    let bytes: [UInt8]
+    public let account: UInt32
+}
+
+/// Sapling Extended Spending Key
+public struct SaplingExtendedSpendingKey: Equatable, StringEncoded, Undescribable {
+    let encoding: String
+
+    public var stringEncoded: String {
+        encoding
+    }
+
+    /// Initializes a new Sapling Extended Full Viewing Key from the provided string encoding
+    /// - Parameters:
+    ///  - parameter encoding: String encoding of ExtSK
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `spendingKeyInvalidInput`when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        guard DerivationTool(networkType: network).isValidSaplingExtendedSpendingKey(encoding) else {
+            throw ZcashError.spendingKeyInvalidInput
+        }
+        self.encoding = encoding
+    }
+}
+
+/// A Transparent Account Private Key
+public struct TransparentAccountPrivKey: Equatable, Undescribable {
+    let encoding: String
+}
+
+/// A ZIP 316 Unified Full Viewing Key.
+public struct UnifiedFullViewingKey: Equatable, StringEncoded, Undescribable {
+    let encoding: String
+    public let account: UInt32
+
+    public var stringEncoded: String { encoding }
+
+    /// Initializes a new UnifiedFullViewingKey (UFVK) from the provided string encoding
+    /// - Parameters:
+    ///  - parameter encoding: String encoding of unified full viewing key
+    ///  - parameter account: account number of the given UFVK
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `unifiedFullViewingKeyInvalidInput`when the provided encoding is found to be invalid
+    public init(encoding: String, account: UInt32, network: NetworkType) throws {
+        guard DerivationTool(networkType: network).isValidUnifiedFullViewingKey(encoding) else {
+            throw ZcashError.unifiedFullViewingKeyInvalidInput
+        }
+
+        self.encoding = encoding
+        self.account = account
+    }
+}
+
+public struct SaplingExtendedFullViewingKey: Equatable, StringEncoded, Undescribable {
+    let encoding: String
+    public var stringEncoded: String {
+        encoding
+    }
+
+    /// Initializes a new Extended Full Viewing key (EFVK) for Sapling from the provided string encoding
+    /// - Parameters:
+    ///  - parameter encoding: String encoding of Sapling extended full viewing key
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `extetendedFullViewingKeyInvalidInput`when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        guard ZcashKeyDerivationBackend(networkType: network).isValidSaplingExtendedFullViewingKey(encoding) else {
+            throw ZcashError.extetendedFullViewingKeyInvalidInput
+        }
+        self.encoding = encoding
+    }
+}
+
+public enum AddressType: Equatable {
+    case p2pkh
+    case p2sh
+    case sapling
+    case unified
+    
+    var id: UInt32 {
+        switch self {
+        case .p2pkh:  return 0
+        case .p2sh:  return 1
+        case .sapling: return 2
+        case .unified: return 3
+        }
+    }
+}
+
+extension AddressType {
+    static func forId(_ id: UInt32) -> AddressType? {
+        switch id {
+        case 0: return .p2pkh
+        case 1: return .p2sh
+        case 2: return .sapling
+        case 3: return .unified
+        default: return nil
+        }
+    }
+}
+
+/// A Transparent Address that can be encoded as a String
+///
+/// Transactions sent to this address are totally visible in the public
+/// ledger. See "Multiple transaction types" in https://z.cash/technology/
+public struct TransparentAddress: Equatable, StringEncoded, Comparable {
+    let encoding: String
+
+    public var stringEncoded: String { encoding }
+
+    /// Initializes a new TransparentAddress (t-address) from the provided string encoding
+    ///
+    ///  - parameter encoding: String encoding of the t-address
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `transparentAddressInvalidInput`when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        guard DerivationTool(networkType: network).isValidTransparentAddress(encoding) else {
+            throw ZcashError.transparentAddressInvalidInput
+        }
+
+        self.encoding = encoding
+    }
+
+    public static func < (lhs: TransparentAddress, rhs: TransparentAddress) -> Bool {
+        return lhs.encoding < rhs.encoding
+    }
 }
 
+/// Represents a Sapling receiver address. Comonly called zAddress.
+/// This address corresponds to the Zcash Sapling shielded pool.
+/// Although this it is fully functional, we encourage developers to
+/// choose `UnifiedAddress` before Sapling or Transparent ones.
+public struct SaplingAddress: Equatable, StringEncoded {
+    let encoding: String
+
+    public var stringEncoded: String { encoding }
 
-extension WalletBirthday: Decodable {
-  //  let height: BlockHeight
-  //  let hash: String
-  //  let time: UInt32
-  //  let tree: String
-  //
-  //  func walletBirthday() -> WalletBirthday {
-  //    WalletBirthday(
-  //      height: height,
-  //      hash: hash,
-  //      time: time,
-  //      tree: tree
-  //    )
-  //  }
-
-  public enum CodingKeys: String, CodingKey {
-    case height
-    case hash
-    case time
-    case tree
-  }
-
-  public init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: CodingKeys.self)
-    self.height = try Self.getHeight(from: container)
-    self.hash = try container.decode(String.self, forKey: .hash)
-    self.time = try container.decode(UInt32.self, forKey: .time)
-    self.tree = try container.decode(String.self, forKey: .tree)
-  }
-
-  static func getHeight(from container: KeyedDecodingContainer<CodingKeys>) throws -> Int {
-    guard
-      let heightString = try? container.decode(String.self, forKey: .height),
-      let height = Int(heightString)
-    else {
-      throw DecodingError.typeMismatch(
-        String.self,
-        DecodingError.Context(
-          codingPath: [CodingKeys.height],
-          debugDescription: "expected height to be encoded as a string",
-          underlyingError: nil
-        )
-      )
-    }
-    return height
-  }
+    /// Initializes a new Sapling shielded address (z-address) from the provided string encoding
+    ///
+    /// - parameter encoding: String encoding of the z-address
+    /// - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    ///
+    /// - Throws: `saplingAddressInvalidInput` when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        guard DerivationTool(networkType: network).isValidSaplingAddress(encoding) else {
+            throw ZcashError.saplingAddressInvalidInput
+        }
+
+        self.encoding = encoding
+    }
 }
 
+public struct UnifiedAddress: Equatable, StringEncoded {
+    let networkType: NetworkType
+
+    public enum ReceiverTypecodes: Hashable {
+        case p2pkh
+        case p2sh
+        case sapling
+        case orchard
+        case unknown(UInt32)
+
+        init(typecode: UInt32) {
+            switch typecode {
+            case 0x00:
+                self = .p2pkh
+            case 0x01:
+                self = .p2sh
+            case 0x02:
+                self = .sapling
+            case 0x03:
+                self = .orchard
+            default:
+                self = .unknown(typecode)
+            }
+        }
+    }
+
+    let encoding: String
+
+    public var stringEncoded: String { encoding }
 
-/**
-Groups a Sapling Extended Full Viewing Key an a tranparent address extended public key.
-*/
+    /// Initializes a new Unified Address (UA) from the provided string encoding
+    /// - Parameters:
+    ///  - parameter encoding: String encoding of the UA
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `unifiedAddressInvalidInput` when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        networkType = network
+        guard DerivationTool(networkType: network).isValidUnifiedAddress(encoding) else {
+            throw ZcashError.unifiedAddressInvalidInput
+        }
 
-public typealias ExtendedFullViewingKey = String
-public typealias ExtendedPublicKey = String
+        self.encoding = encoding
+    }
 
-public protocol UnifiedViewingKey {
-    var extfvk: ExtendedFullViewingKey { get set }
-    var extpub: ExtendedPublicKey { get set }
+    /// returns an array of `UnifiedAddress.ReceiverTypecodes` ordered by precedence
+    public func availableReceiverTypecodes() throws -> [UnifiedAddress.ReceiverTypecodes] {
+        return try DerivationTool(networkType: networkType).receiverTypecodesFromUnifiedAddress(self)
+    }
 }
 
-public typealias TransparentAddress = String
-public typealias SaplingShieldedAddress = String
+public enum TransactionRecipient: Equatable {
+    case address(Recipient)
+    case internalAccount(UInt32)
+}
+
+/// Represents a valid recipient of Zcash
+public enum Recipient: Equatable, StringEncoded {
+    case transparent(TransparentAddress)
+    case sapling(SaplingAddress)
+    case unified(UnifiedAddress)
+
+    public var stringEncoded: String {
+        switch self {
+        case .transparent(let tAddr):
+            return tAddr.stringEncoded
+        case .sapling(let zAddr):
+            return zAddr.stringEncoded
+        case .unified(let uAddr):
+            return uAddr.stringEncoded
+        }
+    }
 
-public protocol UnifiedAddress {
-    var tAddress: TransparentAddress { get }
-    var zAddress: SaplingShieldedAddress { get }
+    /// Initializes a `Recipient` with string encoded Zcash address
+    /// - Parameter string: a string encoded Zcash address
+    /// - Parameter network: the `ZcashNetwork.NetworkType` of the recipient
+    /// - Throws: `recipientInvalidInput` if the received string-encoded address can't be initialized as a valid Zcash Address.
+    public init(_ string: String, network: NetworkType) throws {
+        if let unified = try? UnifiedAddress(encoding: string, network: network) {
+            self = .unified(unified)
+        } else if let sapling = try? SaplingAddress(encoding: string, network: network) {
+            self = .sapling(sapling)
+        } else if let transparent = try? TransparentAddress(encoding: string, network: network) {
+            self = .transparent(transparent)
+        } else {
+            throw ZcashError.recipientInvalidInput
+        }
+    }
+    
+    static func forEncodedAddress(encoded: String) -> (Recipient, NetworkType)? {
+        return DerivationTool.getAddressMetadata(encoded).map { metadata in
+            switch metadata.addressType {
+            case .p2pkh: return (.transparent(TransparentAddress(validatedEncoding: encoded)),
+                metadata.networkType)
+            case .p2sh:  return (.transparent(TransparentAddress(validatedEncoding: encoded)), metadata.networkType)
+            case .sapling: return (.sapling(SaplingAddress(validatedEncoding: encoded)), metadata.networkType)
+            case .unified: return (.unified(UnifiedAddress(validatedEncoding: encoded, networkType: metadata.networkType)), metadata.networkType)
+            }
+        }
+    }
 }
 
-public protocol WalletBalance {
-    var verified: Int64 { get set }
-    var total: Int64 { get set }
+public struct WalletBalance: Equatable {
+    public let verified: Zatoshi
+    public let total: Zatoshi
+    
+    public init(verified: Zatoshi, total: Zatoshi) {
+        self.verified = verified
+        self.total = total
+    }
+}
+
+public extension WalletBalance {
+    static var zero: WalletBalance {
+        Self(verified: .zero, total: .zero)
+    }
 }

package/ios/ZCashLightClientKit/Model/Zatoshi.swift

@@ -0,0 +1,115 @@
+//
+//  Zatoshi.swift
+//  secant-testnet
+//
+//  Created by Lukáš Korba on 26.05.2022.
+//  Modified and ported to ZcashLightClientKit by Francisco Gindre
+
+import Foundation
+
+public struct Zatoshi {
+    public enum Constants {
+        public static let oneZecInZatoshi: Int64 = 100_000_000
+        public static let maxZecSupply: Int64 = 21_000_000
+        public static let maxZatoshi: Int64 = Constants.oneZecInZatoshi * Constants.maxZecSupply
+    }
+    
+    public static var zero: Zatoshi { Zatoshi() }
+    
+    public static let decimalHandler = NSDecimalNumberHandler(
+        roundingMode: NSDecimalNumber.RoundingMode.bankers,
+        scale: 8,
+        raiseOnExactness: true,
+        raiseOnOverflow: true,
+        raiseOnUnderflow: true,
+        raiseOnDivideByZero: true
+    )
+    
+    @Clamped(-Constants.maxZatoshi...Constants.maxZatoshi)
+    public var amount: Int64 = 0
+
+    /// Converts `Zatoshi` to `NSDecimalNumber`
+    public var decimalValue: NSDecimalNumber {
+        NSDecimalNumber(decimal: Decimal(amount) / Decimal(Constants.oneZecInZatoshi))
+    }
+
+    public init(_ amount: Int64 = 0) {
+        self.amount = amount
+    }
+    /// Converts `Zatoshi` to human readable format, up to 8 fraction digits
+    public func decimalString(formatter: NumberFormatter = NumberFormatter.zcashNumberFormatter) -> String {
+        formatter.string(from: decimalValue.roundedZec) ?? ""
+    }
+
+    /// Converts `Decimal` to `Zatoshi`
+    public static func from(decimal: Decimal) -> Zatoshi {
+        let roundedZec = NSDecimalNumber(decimal: decimal).roundedZec
+        let zec2zatoshi = Decimal(Constants.oneZecInZatoshi) * roundedZec.decimalValue
+        return Zatoshi(NSDecimalNumber(decimal: zec2zatoshi).int64Value)
+    }
+
+    /// Converts `String` to `Zatoshi`
+    public static func from(decimalString: String, formatter: NumberFormatter = NumberFormatter.zcashNumberFormatter) -> Zatoshi? {
+        if let number = formatter.number(from: decimalString) {
+            return Zatoshi.from(decimal: number.decimalValue)
+        }
+        
+        return nil
+    }
+    
+    public static func + (left: Zatoshi, right: Zatoshi) -> Zatoshi {
+        Zatoshi(left.amount + right.amount)
+    }
+
+    public static func - (left: Zatoshi, right: Zatoshi) -> Zatoshi {
+        Zatoshi(left.amount - right.amount)
+    }
+}
+
+extension Zatoshi: Equatable {
+    public static func == (lhs: Zatoshi, rhs: Zatoshi) -> Bool {
+        lhs.amount == rhs.amount
+    }
+}
+
+extension Zatoshi: Comparable {
+    public static func < (lhs: Zatoshi, rhs: Zatoshi) -> Bool {
+        lhs.amount < rhs.amount
+    }
+}
+
+public extension NSDecimalNumber {
+    /// Round the decimal to 8 fraction digits
+    var roundedZec: NSDecimalNumber {
+        self.rounding(accordingToBehavior: Zatoshi.decimalHandler)
+    }
+
+    /// Converts `NSDecimalNumber` to human readable format, up to 8 fraction digits
+    var decimalString: String {
+        self.roundedZec.stringValue
+    }
+}
+
+extension Zatoshi: Codable {
+    enum CodingKeys: String, CodingKey {
+        case amount
+    }
+
+    public init(from decoder: Decoder) throws {
+        do {
+            let values = try decoder.container(keyedBy: CodingKeys.self)
+            self.amount = try values.decode(Int64.self, forKey: .amount)
+        } catch {
+            throw ZcashError.zatoshiDecode(error)
+        }
+    }
+    
+    public func encode(to encoder: Encoder) throws {
+        do {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            try container.encode(self.amount, forKey: .amount)
+        } catch {
+            throw ZcashError.zatoshiEncode(error)
+        }
+    }
+}