react-native-zcash 0.3.3 → 0.3.5

package/ios/ZCashLightClientKit/Service/LightWalletService.swift

@@ -0,0 +1,214 @@
+//
+//  LightWalletService.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+import GRPC
+import SwiftProtobuf
+
+/**
+Wrapper for errors received from a Lightwalletd endpoint
+*/
+public enum LightWalletServiceError: Error {
+    case generalError(message: String)
+    case failed(statusCode: Int, message: String)
+    case invalidBlock
+    case sentFailed(error: Error)
+    case genericError(error: Error)
+    case timeOut
+    case criticalError
+    case userCancelled
+    case unknown
+}
+
+extension LightWalletServiceError: Equatable {
+    // swiftlint:disable cyclomatic_complexity
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        switch lhs {
+        case .generalError(let message):
+            switch rhs {
+            case .generalError(let msg):
+                return message == msg
+            default:
+                return false
+            }
+        case .failed(let statusCode, _):
+            switch rhs {
+            case .failed(let anotherStatus, _):
+                return statusCode == anotherStatus
+            default:
+                return false
+            }
+            
+        case .invalidBlock:
+            switch rhs {
+            case .invalidBlock:
+                return true
+            default:
+                return false
+            }
+        case .sentFailed:
+            switch rhs {
+            case .sentFailed:
+                return true
+            default:
+                return false
+            }
+        case .genericError:
+            return false
+        
+        case .timeOut:
+            switch rhs {
+            case .timeOut:
+                return true
+            default:
+                return false
+            }
+        case .criticalError:
+            switch rhs {
+            case .criticalError:
+                return true
+            default:
+                return false
+            }
+        case .userCancelled:
+            switch rhs {
+            case .userCancelled:
+                return true
+            default:
+                return false
+            }
+        case .unknown:
+            switch rhs {
+            case .unknown:
+                return true
+            default:
+                return false
+            }
+        }
+    }
+}
+
+public protocol LightWalletServiceResponse {
+    var errorCode: Int32 { get }
+    var errorMessage: String { get }
+    var unknownFields: SwiftProtobuf.UnknownStorage { get }
+}
+
+extension SendResponse: LightWalletServiceResponse {}
+
+public protocol LightWalletService {
+    /**
+    returns the info for this lightwalletd server (blocking)
+    */
+    func getInfo() throws -> LightWalletdInfo
+    
+    /**
+    returns the info for this lightwalletd server
+    */
+    func getInfo(result: @escaping (Result<LightWalletdInfo, LightWalletServiceError>) -> Void)
+
+    /**
+        Return the latest block height known to the service.
+     
+        - Parameter result: a result containing the height or an Error
+    */
+    func latestBlockHeight(result: @escaping (Result<BlockHeight, LightWalletServiceError>) -> Void)
+    
+    /**
+        Return the latest block height known to the service.
+    
+        - Parameter result: a result containing the height or an Error
+    */
+    func latestBlockHeight() throws -> BlockHeight
+
+    /**
+        Return the given range of blocks.
+      
+            - Parameter range: the inclusive range to fetch.
+                For instance if 1..5 is given, then every block in that will be fetched, including 1 and 5.
+        Non blocking
+    */
+    func blockRange(_ range: CompactBlockRange, result: @escaping (Result<[ZcashCompactBlock], LightWalletServiceError>) -> Void )
+    
+    /**
+        Return the given range of blocks.
+         
+            - Parameter range: the inclusive range to fetch.
+                For instance if 1..5 is given, then every block in that will be fetched, including 1 and 5.
+        blocking
+    */
+    func blockRange(_ range: CompactBlockRange) throws -> [ZcashCompactBlock]
+    
+    @discardableResult
+    func blockStream(
+        startHeight: BlockHeight,
+        endHeight: BlockHeight,
+        result: @escaping (Result<GRPCResult, LightWalletServiceError>) -> Void,
+        handler: @escaping (ZcashCompactBlock) -> Void,
+        progress: @escaping  (BlockProgress) -> Void
+    ) -> CancellableCall
+
+    /**
+    Submits a raw transaction over lightwalletd. Non-Blocking
+    - Parameter spendTransaction: data representing the transaction to be sent
+    - Parameter result: escaping closure that takes a result containing either LightWalletServiceResponse or LightWalletServiceError
+    */
+    func submit(spendTransaction: Data, result: @escaping(Result<LightWalletServiceResponse, LightWalletServiceError>) -> Void)
+    
+    /**
+    Submits a raw transaction over lightwalletd. Blocking
+    - Parameter spendTransaction: data representing the transaction to be sent
+    - Throws: LightWalletServiceError
+    - Returns: LightWalletServiceResponse
+    */
+    func submit(spendTransaction: Data) throws -> LightWalletServiceResponse
+    
+    /**
+    Gets a transaction by id
+    - Parameter txId: data representing the transaction ID
+    - Throws: LightWalletServiceError
+    - Returns: LightWalletServiceResponse
+    */
+    func fetchTransaction(txId: Data) throws -> TransactionEntity
+    
+    /**
+    Gets a transaction by id
+    - Parameter txId: data representing the transaction ID
+    - Parameter result: handler for the result
+    - Throws: LightWalletServiceError
+    - Returns: LightWalletServiceResponse
+    */
+    func fetchTransaction(
+        txId: Data,
+        result: @escaping (Result<TransactionEntity, LightWalletServiceError>) -> Void
+    )
+    
+    func fetchUTXOs(
+        for tAddress: String,
+        height: BlockHeight
+    ) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUTXOs(
+        for tAddress: String,
+        height: BlockHeight,
+        result: @escaping(Result<[UnspentTransactionOutputEntity], LightWalletServiceError>) -> Void
+    )
+    
+    func fetchUTXOs(
+        for tAddresses: [String],
+        height: BlockHeight
+    ) throws -> [UnspentTransactionOutputEntity]
+    
+    func fetchUTXOs(
+        for tAddresses: [String],
+        height: BlockHeight,
+        result: @escaping(Result<[UnspentTransactionOutputEntity], LightWalletServiceError>) -> Void
+    )
+    
+    func closeConnection()
+}

package/ios/ZCashLightClientKit/Service/Model/ZcashCompactBlock.swift

@@ -0,0 +1,46 @@
+//
+//  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>
+
+enum ZcashCompactBlockError: Error {
+    case unreadableBlock(compactBlock: CompactBlock)
+}
+
+extension BlockHeight {
+    static func empty() -> BlockHeight {
+        BlockHeight(-1)
+    }
+}
+
+extension ZcashCompactBlock {
+    init(compactBlock: CompactBlock) {
+        self.height = Int(compactBlock.height)
+        self.data = (try? compactBlock.serializedData()) ?? Data()
+    }
+}
+
+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/Service/ProtoBuf/Extensions/Protocolbuffer+Extensions.swift

@@ -0,0 +1,50 @@
+//
+//  Protocolbuffer+Extensions.swift
+//  ZcashLightClientKit
+//
+//  Created by Francisco Gindre on 12/09/2019.
+//  Copyright © 2019 Electric Coin Company. All rights reserved.
+//
+
+import Foundation
+
+extension CompactBlockRange {
+    func blockRange() -> BlockRange {
+        BlockRange(startHeight: lowerBound, endHeight: upperBound)
+    }
+}
+
+extension BlockID {
+    init(height: UInt64) {
+        self = BlockID()
+        self.height = height
+    }
+    
+    init(height: BlockHeight) {
+        self.init(height: UInt64(height))
+    }
+    
+    func compactBlockHeight() -> BlockHeight? {
+        BlockHeight(exactly: self.height)
+    }
+}
+
+extension BlockRange {
+    init(startHeight: Int, endHeight: Int? = nil) {
+        self = BlockRange()
+        self.start = BlockID(height: UInt64(startHeight))
+        if let endHeight = endHeight {
+            self.end = BlockID(height: UInt64(endHeight))
+        }
+    }
+    
+    var compactBlockRange: CompactBlockRange {
+        return Int(self.start.height) ... Int(self.end.height)
+    }
+}
+
+extension Array where Element == CompactBlock {
+    func asZcashCompactBlocks() -> [ZcashCompactBlock] {
+        self.map { ZcashCompactBlock(compactBlock: $0) }
+    }
+}

package/ios/ZCashLightClientKit/Service/ProtoBuf/compact_formats.pb.swift

@@ -0,0 +1,332 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: compact_formats.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+// Copyright (c) 2019-2020 The Zcash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php .
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+/// CompactBlock is a packaging of ONLY the data from a block that's needed to:
+///   1. Detect a payment to your shielded Sapling address
+///   2. Detect a spend of your shielded Sapling notes
+///   3. Update your witnesses to generate new Sapling spend proofs.
+struct CompactBlock {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// the version of this wire format, for storage
+  var protoVersion: UInt32 = 0
+
+  /// the height of this block
+  var height: UInt64 = 0
+
+  /// the ID (hash) of this block, same as in block explorers
+  var hash: Data = Data()
+
+  /// the ID (hash) of this block's predecessor
+  var prevHash: Data = Data()
+
+  /// Unix epoch time when the block was mined
+  var time: UInt32 = 0
+
+  /// (hash, prevHash, and time) OR (full header)
+  var header: Data = Data()
+
+  /// zero or more compact transactions from this block
+  var vtx: [CompactTx] = []
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+/// CompactTx contains the minimum information for a wallet to know if this transaction
+/// is relevant to it (either pays to it or spends from it) via shielded elements
+/// only. This message will not encode a transparent-to-transparent transaction.
+struct CompactTx {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// the index within the full block
+  var index: UInt64 = 0
+
+  /// the ID (hash) of this transaction, same as in block explorers
+  var hash: Data = Data()
+
+  /// The transaction fee: present if server can provide. In the case of a
+  /// stateless server and a transaction with transparent inputs, this will be
+  /// unset because the calculation requires reference to prior transactions.
+  /// in a pure-Sapling context, the fee will be calculable as:
+  ///    valueBalance + (sum(vPubNew) - sum(vPubOld) - sum(tOut))
+  var fee: UInt32 = 0
+
+  /// inputs
+  var spends: [CompactSpend] = []
+
+  /// outputs
+  var outputs: [CompactOutput] = []
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+/// CompactSpend is a Sapling Spend Description as described in 7.3 of the Zcash
+/// protocol specification.
+struct CompactSpend {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// nullifier (see the Zcash protocol specification)
+  var nf: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+/// output is a Sapling Output Description as described in section 7.4 of the
+/// Zcash protocol spec. Total size is 948.
+struct CompactOutput {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// note commitment u-coordinate
+  var cmu: Data = Data()
+
+  /// ephemeral public key
+  var epk: Data = Data()
+
+  /// ciphertext and zkproof
+  var ciphertext: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "cash.z.wallet.sdk.rpc"
+
+extension CompactBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CompactBlock"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "protoVersion"),
+    2: .same(proto: "height"),
+    3: .same(proto: "hash"),
+    4: .same(proto: "prevHash"),
+    5: .same(proto: "time"),
+    6: .same(proto: "header"),
+    7: .same(proto: "vtx"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.protoVersion) }()
+      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.height) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.hash) }()
+      case 4: try { try decoder.decodeSingularBytesField(value: &self.prevHash) }()
+      case 5: try { try decoder.decodeSingularUInt32Field(value: &self.time) }()
+      case 6: try { try decoder.decodeSingularBytesField(value: &self.header) }()
+      case 7: try { try decoder.decodeRepeatedMessageField(value: &self.vtx) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.protoVersion != 0 {
+      try visitor.visitSingularUInt32Field(value: self.protoVersion, fieldNumber: 1)
+    }
+    if self.height != 0 {
+      try visitor.visitSingularUInt64Field(value: self.height, fieldNumber: 2)
+    }
+    if !self.hash.isEmpty {
+      try visitor.visitSingularBytesField(value: self.hash, fieldNumber: 3)
+    }
+    if !self.prevHash.isEmpty {
+      try visitor.visitSingularBytesField(value: self.prevHash, fieldNumber: 4)
+    }
+    if self.time != 0 {
+      try visitor.visitSingularUInt32Field(value: self.time, fieldNumber: 5)
+    }
+    if !self.header.isEmpty {
+      try visitor.visitSingularBytesField(value: self.header, fieldNumber: 6)
+    }
+    if !self.vtx.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.vtx, fieldNumber: 7)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: CompactBlock, rhs: CompactBlock) -> Bool {
+    if lhs.protoVersion != rhs.protoVersion {return false}
+    if lhs.height != rhs.height {return false}
+    if lhs.hash != rhs.hash {return false}
+    if lhs.prevHash != rhs.prevHash {return false}
+    if lhs.time != rhs.time {return false}
+    if lhs.header != rhs.header {return false}
+    if lhs.vtx != rhs.vtx {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension CompactTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CompactTx"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "index"),
+    2: .same(proto: "hash"),
+    3: .same(proto: "fee"),
+    4: .same(proto: "spends"),
+    5: .same(proto: "outputs"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.index) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.hash) }()
+      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.fee) }()
+      case 4: try { try decoder.decodeRepeatedMessageField(value: &self.spends) }()
+      case 5: try { try decoder.decodeRepeatedMessageField(value: &self.outputs) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.index != 0 {
+      try visitor.visitSingularUInt64Field(value: self.index, fieldNumber: 1)
+    }
+    if !self.hash.isEmpty {
+      try visitor.visitSingularBytesField(value: self.hash, fieldNumber: 2)
+    }
+    if self.fee != 0 {
+      try visitor.visitSingularUInt32Field(value: self.fee, fieldNumber: 3)
+    }
+    if !self.spends.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.spends, fieldNumber: 4)
+    }
+    if !self.outputs.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.outputs, fieldNumber: 5)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: CompactTx, rhs: CompactTx) -> Bool {
+    if lhs.index != rhs.index {return false}
+    if lhs.hash != rhs.hash {return false}
+    if lhs.fee != rhs.fee {return false}
+    if lhs.spends != rhs.spends {return false}
+    if lhs.outputs != rhs.outputs {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension CompactSpend: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CompactSpend"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "nf"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.nf) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.nf.isEmpty {
+      try visitor.visitSingularBytesField(value: self.nf, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: CompactSpend, rhs: CompactSpend) -> Bool {
+    if lhs.nf != rhs.nf {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension CompactOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CompactOutput"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "cmu"),
+    2: .same(proto: "epk"),
+    3: .same(proto: "ciphertext"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.cmu) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.epk) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.ciphertext) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.cmu.isEmpty {
+      try visitor.visitSingularBytesField(value: self.cmu, fieldNumber: 1)
+    }
+    if !self.epk.isEmpty {
+      try visitor.visitSingularBytesField(value: self.epk, fieldNumber: 2)
+    }
+    if !self.ciphertext.isEmpty {
+      try visitor.visitSingularBytesField(value: self.ciphertext, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: CompactOutput, rhs: CompactOutput) -> Bool {
+    if lhs.cmu != rhs.cmu {return false}
+    if lhs.epk != rhs.epk {return false}
+    if lhs.ciphertext != rhs.ciphertext {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}

package/ios/ZCashLightClientKit/Service/ProtoBuf/proto/compact_formats.proto

@@ -0,0 +1,56 @@
+// Copyright (c) 2019-2020 The Zcash developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php .
+
+syntax = "proto3";
+package cash.z.wallet.sdk.rpc;
+option go_package = "lightwalletd/walletrpc";
+option swift_prefix = "";
+// Remember that proto3 fields are all optional. A field that is not present will be set to its zero value.
+// bytes fields of hashes are in canonical little-endian format.
+
+// CompactBlock is a packaging of ONLY the data from a block that's needed to:
+//   1. Detect a payment to your shielded Sapling address
+//   2. Detect a spend of your shielded Sapling notes
+//   3. Update your witnesses to generate new Sapling spend proofs.
+message CompactBlock {
+    uint32 protoVersion = 1;    // the version of this wire format, for storage
+    uint64 height = 2;          // the height of this block
+    bytes hash = 3;             // the ID (hash) of this block, same as in block explorers
+    bytes prevHash = 4;         // the ID (hash) of this block's predecessor
+    uint32 time = 5;            // Unix epoch time when the block was mined
+    bytes header = 6;           // (hash, prevHash, and time) OR (full header)
+    repeated CompactTx vtx = 7; // zero or more compact transactions from this block
+}
+
+// CompactTx contains the minimum information for a wallet to know if this transaction
+// is relevant to it (either pays to it or spends from it) via shielded elements
+// only. This message will not encode a transparent-to-transparent transaction.
+message CompactTx {
+    uint64 index = 1;   // the index within the full block
+    bytes hash = 2;     // the ID (hash) of this transaction, same as in block explorers
+
+    // The transaction fee: present if server can provide. In the case of a
+    // stateless server and a transaction with transparent inputs, this will be
+    // unset because the calculation requires reference to prior transactions.
+    // in a pure-Sapling context, the fee will be calculable as:
+    //    valueBalance + (sum(vPubNew) - sum(vPubOld) - sum(tOut))
+    uint32 fee = 3;
+
+    repeated CompactSpend spends = 4;   // inputs
+    repeated CompactOutput outputs = 5; // outputs
+}
+
+// CompactSpend is a Sapling Spend Description as described in 7.3 of the Zcash
+// protocol specification.
+message CompactSpend {
+    bytes nf = 1;   // nullifier (see the Zcash protocol specification)
+}
+
+// output is a Sapling Output Description as described in section 7.4 of the
+// Zcash protocol spec. Total size is 948.
+message CompactOutput {
+    bytes cmu = 1;          // note commitment u-coordinate
+    bytes epk = 2;          // ephemeral public key
+    bytes ciphertext = 3;   // ciphertext and zkproof
+}