react-native-zcash 0.5.0 → 0.6.0

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

@@ -7,7 +7,7 @@
 // For information on using the generated types, please see the documentation:
 //   https://github.com/apple/swift-protobuf/
 
-// Copyright (c) 2019-2020 The Zcash developers
+// Copyright (c) 2019-2021 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php .
 
@@ -24,6 +24,23 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP
   typealias Version = _2
 }
 
+/// ChainMetadata represents information about the state of the chain as of a given block.
+struct ChainMetadata {
+  // 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 size of the Sapling note commitment tree as of the end of this block
+  var saplingCommitmentTreeSize: UInt32 = 0
+
+  /// the size of the Orchard note commitment tree as of the end of this block
+  var orchardCommitmentTreeSize: UInt32 = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
 /// 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
@@ -40,23 +57,35 @@ struct CompactBlock {
   var height: UInt64 = 0
 
   /// the ID (hash) of this block, same as in block explorers
-  var hash: Data = SwiftProtobuf.Internal.emptyData
+  var hash: Data = Data()
 
   /// the ID (hash) of this block's predecessor
-  var prevHash: Data = SwiftProtobuf.Internal.emptyData
+  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 = SwiftProtobuf.Internal.emptyData
+  var header: Data = Data()
 
   /// zero or more compact transactions from this block
   var vtx: [CompactTx] = []
 
+  /// information about the state of the chain as of this block
+  var chainMetadata: ChainMetadata {
+    get {return _chainMetadata ?? ChainMetadata()}
+    set {_chainMetadata = newValue}
+  }
+  /// Returns true if `chainMetadata` has been explicitly set.
+  var hasChainMetadata: Bool {return self._chainMetadata != nil}
+  /// Clears the value of `chainMetadata`. Subsequent reads from it will return its default value.
+  mutating func clearChainMetadata() {self._chainMetadata = nil}
+
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
+
+  fileprivate var _chainMetadata: ChainMetadata? = nil
 }
 
 /// CompactTx contains the minimum information for a wallet to know if this transaction
@@ -67,23 +96,23 @@ struct CompactTx {
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
 
-  /// the index within the full block
+  /// Index and hash will allow the receiver to call out to chain
+  /// explorers or other data structures to retrieve more information
+  /// about this transaction.
   var index: UInt64 = 0
 
   /// the ID (hash) of this transaction, same as in block explorers
-  var hash: Data = SwiftProtobuf.Internal.emptyData
+  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))
+  /// If there are no transparent inputs, the fee will be calculable as:
+  ///    valueBalanceSapling + valueBalanceOrchard + sum(vPubNew) - sum(vPubOld) - sum(tOut)
   var fee: UInt32 = 0
 
-  /// inputs
   var spends: [CompactSaplingSpend] = []
 
-  /// outputs
   var outputs: [CompactSaplingOutput] = []
 
   var actions: [CompactOrchardAction] = []
@@ -101,28 +130,31 @@ struct CompactSaplingSpend {
   // methods supported on all messages.
 
   /// nullifier (see the Zcash protocol specification)
-  var nf: Data = SwiftProtobuf.Internal.emptyData
+  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.
+/// output encodes the `cmu` field, `ephemeralKey` field, and a 52-byte prefix of the
+/// `encCiphertext` field of a Sapling Output Description. These fields are described in
+/// section 7.4 of the Zcash protocol spec:
+/// https://zips.z.cash/protocol/protocol.pdf#outputencodingandconsensus
+/// Total size is 116 bytes.
 struct CompactSaplingOutput {
   // 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 = SwiftProtobuf.Internal.emptyData
+  var cmu: Data = Data()
 
   /// ephemeral public key
-  var epk: Data = SwiftProtobuf.Internal.emptyData
+  var ephemeralKey: Data = Data()
 
   /// first 52 bytes of ciphertext
-  var ciphertext: Data = SwiftProtobuf.Internal.emptyData
+  var ciphertext: Data = Data()
 
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
@@ -137,26 +169,73 @@ struct CompactOrchardAction {
   // methods supported on all messages.
 
   /// [32] The nullifier of the input note
-  var nullifier: Data = SwiftProtobuf.Internal.emptyData
+  var nullifier: Data = Data()
 
   /// [32] The x-coordinate of the note commitment for the output note
-  var cmx: Data = SwiftProtobuf.Internal.emptyData
+  var cmx: Data = Data()
 
   /// [32] An encoding of an ephemeral Pallas public key
-  var ephemeralKey: Data = SwiftProtobuf.Internal.emptyData
+  var ephemeralKey: Data = Data()
 
-  /// [52] The note plaintext component of the encCiphertext field
-  var ciphertext: Data = SwiftProtobuf.Internal.emptyData
+  /// [52] The first 52 bytes of the encCiphertext field
+  var ciphertext: Data = Data()
 
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
 }
 
+#if swift(>=5.5) && canImport(_Concurrency)
+extension ChainMetadata: @unchecked Sendable {}
+extension CompactBlock: @unchecked Sendable {}
+extension CompactTx: @unchecked Sendable {}
+extension CompactSaplingSpend: @unchecked Sendable {}
+extension CompactSaplingOutput: @unchecked Sendable {}
+extension CompactOrchardAction: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
 // MARK: - Code below here is support for the SwiftProtobuf runtime.
 
 fileprivate let _protobuf_package = "cash.z.wallet.sdk.rpc"
 
+extension ChainMetadata: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ChainMetadata"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "saplingCommitmentTreeSize"),
+    2: .same(proto: "orchardCommitmentTreeSize"),
+  ]
+
+  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.saplingCommitmentTreeSize) }()
+      case 2: try { try decoder.decodeSingularUInt32Field(value: &self.orchardCommitmentTreeSize) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.saplingCommitmentTreeSize != 0 {
+      try visitor.visitSingularUInt32Field(value: self.saplingCommitmentTreeSize, fieldNumber: 1)
+    }
+    if self.orchardCommitmentTreeSize != 0 {
+      try visitor.visitSingularUInt32Field(value: self.orchardCommitmentTreeSize, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: ChainMetadata, rhs: ChainMetadata) -> Bool {
+    if lhs.saplingCommitmentTreeSize != rhs.saplingCommitmentTreeSize {return false}
+    if lhs.orchardCommitmentTreeSize != rhs.orchardCommitmentTreeSize {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
 extension CompactBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   static let protoMessageName: String = _protobuf_package + ".CompactBlock"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
@@ -167,24 +246,33 @@ extension CompactBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat
     5: .same(proto: "time"),
     6: .same(proto: "header"),
     7: .same(proto: "vtx"),
+    8: .same(proto: "chainMetadata"),
   ]
 
   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 decoder.decodeSingularUInt32Field(value: &self.protoVersion)
-      case 2: try decoder.decodeSingularUInt64Field(value: &self.height)
-      case 3: try decoder.decodeSingularBytesField(value: &self.hash)
-      case 4: try decoder.decodeSingularBytesField(value: &self.prevHash)
-      case 5: try decoder.decodeSingularUInt32Field(value: &self.time)
-      case 6: try decoder.decodeSingularBytesField(value: &self.header)
-      case 7: try decoder.decodeRepeatedMessageField(value: &self.vtx)
+      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) }()
+      case 8: try { try decoder.decodeSingularMessageField(value: &self._chainMetadata) }()
       default: break
       }
     }
   }
 
   func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
     if self.protoVersion != 0 {
       try visitor.visitSingularUInt32Field(value: self.protoVersion, fieldNumber: 1)
     }
@@ -206,6 +294,9 @@ extension CompactBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat
     if !self.vtx.isEmpty {
       try visitor.visitRepeatedMessageField(value: self.vtx, fieldNumber: 7)
     }
+    try { if let v = self._chainMetadata {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
+    } }()
     try unknownFields.traverse(visitor: &visitor)
   }
 
@@ -217,6 +308,7 @@ extension CompactBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementat
     if lhs.time != rhs.time {return false}
     if lhs.header != rhs.header {return false}
     if lhs.vtx != rhs.vtx {return false}
+    if lhs._chainMetadata != rhs._chainMetadata {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
@@ -235,13 +327,16 @@ extension CompactTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementation
 
   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 decoder.decodeSingularUInt64Field(value: &self.index)
-      case 2: try decoder.decodeSingularBytesField(value: &self.hash)
-      case 3: try decoder.decodeSingularUInt32Field(value: &self.fee)
-      case 4: try decoder.decodeRepeatedMessageField(value: &self.spends)
-      case 5: try decoder.decodeRepeatedMessageField(value: &self.outputs)
-      case 6: try decoder.decodeRepeatedMessageField(value: &self.actions)
+      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) }()
+      case 6: try { try decoder.decodeRepeatedMessageField(value: &self.actions) }()
       default: break
       }
     }
@@ -289,8 +384,11 @@ extension CompactSaplingSpend: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl
 
   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 decoder.decodeSingularBytesField(value: &self.nf)
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.nf) }()
       default: break
       }
     }
@@ -314,16 +412,19 @@ extension CompactSaplingOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
   static let protoMessageName: String = _protobuf_package + ".CompactSaplingOutput"
   static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     1: .same(proto: "cmu"),
-    2: .same(proto: "epk"),
+    2: .same(proto: "ephemeralKey"),
     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 decoder.decodeSingularBytesField(value: &self.cmu)
-      case 2: try decoder.decodeSingularBytesField(value: &self.epk)
-      case 3: try decoder.decodeSingularBytesField(value: &self.ciphertext)
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.cmu) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.ephemeralKey) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.ciphertext) }()
       default: break
       }
     }
@@ -333,8 +434,8 @@ extension CompactSaplingOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
     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.ephemeralKey.isEmpty {
+      try visitor.visitSingularBytesField(value: self.ephemeralKey, fieldNumber: 2)
     }
     if !self.ciphertext.isEmpty {
       try visitor.visitSingularBytesField(value: self.ciphertext, fieldNumber: 3)
@@ -344,7 +445,7 @@ extension CompactSaplingOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
 
   static func ==(lhs: CompactSaplingOutput, rhs: CompactSaplingOutput) -> Bool {
     if lhs.cmu != rhs.cmu {return false}
-    if lhs.epk != rhs.epk {return false}
+    if lhs.ephemeralKey != rhs.ephemeralKey {return false}
     if lhs.ciphertext != rhs.ciphertext {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
@@ -362,11 +463,14 @@ extension CompactOrchardAction: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
 
   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 decoder.decodeSingularBytesField(value: &self.nullifier)
-      case 2: try decoder.decodeSingularBytesField(value: &self.cmx)
-      case 3: try decoder.decodeSingularBytesField(value: &self.ephemeralKey)
-      case 4: try decoder.decodeSingularBytesField(value: &self.ciphertext)
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.nullifier) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.cmx) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.ephemeralKey) }()
+      case 4: try { try decoder.decodeSingularBytesField(value: &self.ciphertext) }()
       default: break
       }
     }

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2020 The Zcash developers
+// Copyright (c) 2019-2021 The Zcash developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or https://www.opensource.org/licenses/mit-license.php .
 
@@ -6,39 +6,50 @@ 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.
 
+// ChainMetadata represents information about the state of the chain as of a given block.
+message ChainMetadata {
+    uint32 saplingCommitmentTreeSize = 1; // the size of the Sapling note commitment tree as of the end of this block
+    uint32 orchardCommitmentTreeSize = 2; // the size of the Orchard note commitment tree as of the end of this block
+}
+
 // 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
+    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
+    ChainMetadata chainMetadata = 8; // information about the state of the chain as of 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 {
+    // Index and hash will allow the receiver to call out to chain
+    // explorers or other data structures to retrieve more information
+    // about this transaction.
     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))
+    // If there are no transparent inputs, the fee will be calculable as:
+    //    valueBalanceSapling + valueBalanceOrchard + sum(vPubNew) - sum(vPubOld) - sum(tOut)
     uint32 fee = 3;
 
-    repeated CompactSaplingSpend spends = 4;   // inputs
-    repeated CompactSaplingOutput outputs = 5; // outputs
+    repeated CompactSaplingSpend spends = 4;
+    repeated CompactSaplingOutput outputs = 5;
     repeated CompactOrchardAction actions = 6;
 }
 
@@ -48,11 +59,14 @@ message CompactSaplingSpend {
     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.
+// output encodes the `cmu` field, `ephemeralKey` field, and a 52-byte prefix of the
+// `encCiphertext` field of a Sapling Output Description. These fields are described in
+// section 7.4 of the Zcash protocol spec:
+// https://zips.z.cash/protocol/protocol.pdf#outputencodingandconsensus
+// Total size is 116 bytes.
 message CompactSaplingOutput {
     bytes cmu = 1;          // note commitment u-coordinate
-    bytes epk = 2;          // ephemeral public key
+    bytes ephemeralKey = 2; // ephemeral public key
     bytes ciphertext = 3;   // first 52 bytes of ciphertext
 }
 
@@ -62,5 +76,5 @@ message CompactOrchardAction {
     bytes nullifier = 1;        // [32] The nullifier of the input note
     bytes cmx = 2;              // [32] The x-coordinate of the note commitment for the output note
     bytes ephemeralKey = 3;     // [32] An encoding of an ephemeral Pallas public key
-    bytes ciphertext = 4;       // [52] The note plaintext component of the encCiphertext field
+    bytes ciphertext = 4;       // [52] The first 52 bytes of the encCiphertext field
 }

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 {
@@ -110,11 +110,28 @@ message Exclude {
 
 // The TreeState is derived from the Zcash z_gettreestate rpc.
 message TreeState {
-    string network = 1; // "main" or "test"
-    uint64 height = 2;
-    string hash = 3;    // block id
-    uint32 time = 4;    // Unix epoch time when the block was mined
-    string tree = 5;    // sapling commitment tree state
+    string network = 1;     // "main" or "test"
+    uint64 height = 2;      // block height
+    string hash = 3;        // block id
+    uint32 time = 4;        // Unix epoch time when the block was mined
+    string saplingTree = 5; // sapling commitment tree state
+    string orchardTree = 6; // orchard commitment tree state
+}
+
+enum ShieldedProtocol {
+    sapling = 0;
+    orchard = 1;
+}
+
+message GetSubtreeRootsArg {
+    uint32 startIndex = 1;                  // Index identifying where to start returning subtree roots
+    ShieldedProtocol shieldedProtocol = 2;  // Shielded protocol to return subtree roots for
+    uint32 maxEntries = 3;                  // Maximum number of entries to return, or 0 for all entries.
+}
+message SubtreeRoot {
+    bytes rootHash = 2;                     // The 32-byte Merkle root of the subtree.
+    bytes completingBlockHash = 3;          // The hash of the block that completed this subtree.
+    uint64 completingBlockHeight = 4;       // The height of the block that completed this subtree in the main chain.
 }
 
 // Results are sorted by height, which makes it easy to issue another
@@ -141,8 +158,12 @@ service CompactTxStreamer {
     rpc GetLatestBlock(ChainSpec) returns (BlockID) {}
     // Return the compact block corresponding to the given block identifier
     rpc GetBlock(BlockID) returns (CompactBlock) {}
+    // Same as GetBlock except actions contain only nullifiers
+    rpc GetBlockNullifiers(BlockID) returns (CompactBlock) {}
     // Return a list of consecutive compact blocks
     rpc GetBlockRange(BlockRange) returns (stream CompactBlock) {}
+    // Same as GetBlockRange except actions contain only nullifiers
+    rpc GetBlockRangeNullifiers(BlockRange) returns (stream CompactBlock) {}
 
     // Return the requested full (not compact) transaction (as from zcashd)
     rpc GetTransaction(TxFilter) returns (RawTransaction) {}
@@ -174,6 +195,11 @@ service CompactTxStreamer {
     // values also (even though they can be obtained using GetBlock).
     // The block can be specified by either height or hash.
     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.
+    rpc GetSubtreeRoots(GetSubtreeRootsArg) returns (stream SubtreeRoot) {}
 
     rpc GetAddressUtxos(GetAddressUtxosArg) returns (GetAddressUtxosReplyList) {}
     rpc GetAddressUtxosStream(GetAddressUtxosArg) returns (stream GetAddressUtxosReply) {}