react-native-zcash 0.8.1 → 0.9.0

package/ios/ZCashLightClientKit/Model/WalletTypes.swift

@@ -89,13 +89,15 @@ public enum AddressType: Equatable {
     case p2sh
     case sapling
     case unified
-    
+    case tex
+
     var id: UInt32 {
         switch self {
         case .p2pkh:  return 0
         case .p2sh:  return 1
         case .sapling: return 2
         case .unified: return 3
+        case .tex: return 4
         }
     }
 }
@@ -107,6 +109,7 @@ extension AddressType {
         case 1: return .p2sh
         case 2: return .sapling
         case 3: return .unified
+        case 4: return .tex
         default: return nil
         }
     }
@@ -213,6 +216,35 @@ public struct UnifiedAddress: Equatable, StringEncoded {
     }
 }
 
+/// A transparent-source-only (TEX) 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/
+///
+/// Transactions sent to this address must only have transparent inputs. See ZIP 320: https://zips.z.cash/zip-0320
+public struct TexAddress: Equatable, StringEncoded, Comparable {
+    let encoding: String
+
+    public var stringEncoded: String { encoding }
+
+    /// Initializes a new TexAddress from the provided string encoding
+    ///
+    ///  - parameter encoding: String encoding of the TEX address
+    ///  - parameter network: `NetworkType` corresponding to the encoding (Mainnet or Testnet)
+    /// - Throws: `texAddressInvalidInput`when the provided encoding is found to be invalid
+    public init(encoding: String, network: NetworkType) throws {
+        guard DerivationTool(networkType: network).isValidTexAddress(encoding) else {
+            throw ZcashError.texAddressInvalidInput
+        }
+
+        self.encoding = encoding
+    }
+
+    public static func < (lhs: TexAddress, rhs: TexAddress) -> Bool {
+        return lhs.encoding < rhs.encoding
+    }
+}
+
 public enum TransactionRecipient: Equatable {
     case address(Recipient)
     case internalAccount(UInt32)
@@ -223,6 +255,7 @@ public enum Recipient: Equatable, StringEncoded {
     case transparent(TransparentAddress)
     case sapling(SaplingAddress)
     case unified(UnifiedAddress)
+    case tex(TexAddress)
 
     public var stringEncoded: String {
         switch self {
@@ -232,6 +265,8 @@ public enum Recipient: Equatable, StringEncoded {
             return zAddr.stringEncoded
         case .unified(let uAddr):
             return uAddr.stringEncoded
+        case .tex(let texAddr):
+            return texAddr.stringEncoded
         }
     }
 
@@ -246,6 +281,8 @@ public enum Recipient: Equatable, StringEncoded {
             self = .sapling(sapling)
         } else if let transparent = try? TransparentAddress(encoding: string, network: network) {
             self = .transparent(transparent)
+        } else if let tex = try? TexAddress(encoding: string, network: network) {
+            self = .tex(tex)
         } else {
             throw ZcashError.recipientInvalidInput
         }
@@ -259,6 +296,7 @@ public enum Recipient: Equatable, StringEncoded {
             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)
+            case .tex: return (.tex(TexAddress(validatedEncoding: encoded)), metadata.networkType)
             }
         }
     }

package/ios/ZCashLightClientKit/Model/Zatoshi.swift

@@ -42,7 +42,7 @@ public struct Zatoshi {
     }
 
     /// Converts `Decimal` to `Zatoshi`
-    public static func from(decimal: Decimal) -> Zatoshi {
+    public static func from(decimal: Foundation.Decimal) -> Zatoshi {
         let roundedZec = NSDecimalNumber(decimal: decimal).roundedZec
         let zec2zatoshi = Decimal(Constants.oneZecInZatoshi) * roundedZec.decimalValue
         return Zatoshi(NSDecimalNumber(decimal: zec2zatoshi).int64Value)

package/ios/ZCashLightClientKit/Modules/Service/GRPC/LightWalletGRPCService.swift

@@ -187,13 +187,35 @@ extension LightWalletGRPCService: LightWalletService {
         }
     }
     
-    func fetchTransaction(txId: Data) async throws -> ZcashTransaction.Fetched {
+    func fetchTransaction(txId: Data) async throws -> (tx: ZcashTransaction.Fetched?, status: TransactionStatus) {
         var txFilter = TxFilter()
         txFilter.hash = txId
         
         do {
             let rawTx = try await compactTxStreamer.getTransaction(txFilter)
-            return ZcashTransaction.Fetched(rawID: txId, minedHeight: BlockHeight(rawTx.height), raw: rawTx.data)
+            
+            let isNotMined = rawTx.height == 0 || rawTx.height > UInt32.max
+            
+            return (
+                tx:
+                    ZcashTransaction.Fetched(
+                        rawID: txId,
+                        minedHeight: isNotMined ? nil : UInt32(rawTx.height),
+                        raw: rawTx.data
+                    ),
+                status: isNotMined ? .notInMainChain : .mined(Int(rawTx.height))
+            )
+        } catch let error as GRPCStatus {
+            if error.makeGRPCStatus().code == .notFound {
+                return (tx: nil, .txidNotRecognized)
+            } else if let notFound = error.message?.contains("Transaction not found"), notFound {
+                return (tx: nil, .txidNotRecognized)
+            } else if let notFound = error.message?.contains("No such mempool or blockchain transaction. Use gettransaction for wallet transactions."), notFound {
+                return (tx: nil, .txidNotRecognized)
+            } else {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceFetchTransactionFailed(serviceError)
+            }
         } catch {
             let serviceError = error.mapToServiceError()
             throw ZcashError.serviceFetchTransactionFailed(serviceError)
@@ -280,6 +302,21 @@ extension LightWalletGRPCService: LightWalletService {
         try await compactTxStreamer.getTreeState(id)
     }
 
+    func getTaddressTxids(_ request: TransparentAddressBlockFilter) -> AsyncThrowingStream<RawTransaction, Error> {
+        let stream = compactTxStreamer.getTaddressTxids(request)
+        var iterator = stream.makeAsyncIterator()
+        
+        return AsyncThrowingStream() {
+            do {
+                guard let rawTransaction = try await iterator.next() else { return nil }
+                return rawTransaction
+            } catch {
+                let serviceError = error.mapToServiceError()
+                throw ZcashError.serviceGetTaddressTxidsFailed(serviceError)
+            }
+        }
+    }
+    
     func closeConnection() {
         _ = channel.close()
     }

package/ios/ZCashLightClientKit/Modules/Service/GRPC/ProtoBuf/proto/service.proto

@@ -31,7 +31,7 @@ message TxFilter {
      bytes hash = 3;        // transaction ID (hash, txid)
 }
 
-// RawTransaction contains the complete transaction data. It also optionally includes
+// RawTransaction contains the complete transaction data. It also optionally includes 
 // the block height in which the transaction was included, or, when returned
 // by GetMempoolStream(), the latest block height.
 message RawTransaction {
@@ -170,7 +170,8 @@ service CompactTxStreamer {
     // Submit the given transaction to the Zcash network
     rpc SendTransaction(RawTransaction) returns (SendResponse) {}
 
-    // Return the txids corresponding to the given t-address within the given block range
+    // Return the transactions corresponding to the given t-address within the given block range
+    // NB - this method is misnamed, it returns transactions, not transaction IDs.
     rpc GetTaddressTxids(TransparentAddressBlockFilter) returns (stream RawTransaction) {}
     rpc GetTaddressBalance(AddressList) returns (Balance) {}
     rpc GetTaddressBalanceStream(stream Address) returns (Balance) {}
@@ -197,8 +198,8 @@ service CompactTxStreamer {
     rpc GetTreeState(BlockID) returns (TreeState) {}
     rpc GetLatestTreeState(Empty) returns (TreeState) {}
 
-    // Returns a stream of information about roots of subtrees of the Sapling and Orchard
-    // note commitment trees.
+    // Returns a stream of information about roots of subtrees of the note commitment tree
+    // for the specified shielded protocol (Sapling or Orchard).
     rpc GetSubtreeRoots(GetSubtreeRootsArg) returns (stream SubtreeRoot) {}
 
     rpc GetAddressUtxos(GetAddressUtxosArg) returns (GetAddressUtxosReplyList) {}