react-native-zcash 0.6.10 → 0.6.11

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-2021 The Zcash developers
+// 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 .
 
@@ -24,23 +24,6 @@ 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
@@ -57,35 +40,23 @@ struct CompactBlock {
   var height: UInt64 = 0
 
   /// the ID (hash) of this block, same as in block explorers
-  var hash: Data = Data()
+  var hash: Data = SwiftProtobuf.Internal.emptyData
 
   /// the ID (hash) of this block's predecessor
-  var prevHash: Data = Data()
+  var prevHash: Data = SwiftProtobuf.Internal.emptyData
 
   /// Unix epoch time when the block was mined
   var time: UInt32 = 0
 
   /// (hash, prevHash, and time) OR (full header)
-  var header: Data = Data()
+  var header: Data = SwiftProtobuf.Internal.emptyData
 
   /// 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
@@ -96,23 +67,23 @@ struct CompactTx {
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
 
-  /// Index and hash will allow the receiver to call out to chain
-  /// explorers or other data structures to retrieve more information
-  /// about this transaction.
+  /// 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()
+  var hash: Data = SwiftProtobuf.Internal.emptyData
 
   /// 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.
-  /// If there are no transparent inputs, the fee will be calculable as:
-  ///    valueBalanceSapling + valueBalanceOrchard + sum(vPubNew) - sum(vPubOld) - sum(tOut)
+  /// 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: [CompactSaplingSpend] = []
 
+  /// outputs
   var outputs: [CompactSaplingOutput] = []
 
   var actions: [CompactOrchardAction] = []
@@ -130,31 +101,28 @@ struct CompactSaplingSpend {
   // methods supported on all messages.
 
   /// nullifier (see the Zcash protocol specification)
-  var nf: Data = Data()
+  var nf: Data = SwiftProtobuf.Internal.emptyData
 
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
   init() {}
 }
 
-/// 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.
+/// output is a Sapling Output Description as described in section 7.4 of the
+/// Zcash protocol spec. Total size is 948.
 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 = Data()
+  var cmu: Data = SwiftProtobuf.Internal.emptyData
 
   /// ephemeral public key
-  var ephemeralKey: Data = Data()
+  var epk: Data = SwiftProtobuf.Internal.emptyData
 
   /// first 52 bytes of ciphertext
-  var ciphertext: Data = Data()
+  var ciphertext: Data = SwiftProtobuf.Internal.emptyData
 
   var unknownFields = SwiftProtobuf.UnknownStorage()
 
@@ -169,73 +137,26 @@ struct CompactOrchardAction {
   // methods supported on all messages.
 
   /// [32] The nullifier of the input note
-  var nullifier: Data = Data()
+  var nullifier: Data = SwiftProtobuf.Internal.emptyData
 
   /// [32] The x-coordinate of the note commitment for the output note
-  var cmx: Data = Data()
+  var cmx: Data = SwiftProtobuf.Internal.emptyData
 
   /// [32] An encoding of an ephemeral Pallas public key
-  var ephemeralKey: Data = Data()
+  var ephemeralKey: Data = SwiftProtobuf.Internal.emptyData
 
-  /// [52] The first 52 bytes of the encCiphertext field
-  var ciphertext: Data = Data()
+  /// [52] The note plaintext component of the encCiphertext field
+  var ciphertext: Data = SwiftProtobuf.Internal.emptyData
 
   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 = [
@@ -246,33 +167,24 @@ 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 { 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) }()
+      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)
       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)
     }
@@ -294,9 +206,6 @@ 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)
   }
 
@@ -308,7 +217,6 @@ 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
   }
@@ -327,16 +235,13 @@ 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 { 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) }()
+      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)
       default: break
       }
     }
@@ -384,11 +289,8 @@ 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 { try decoder.decodeSingularBytesField(value: &self.nf) }()
+      case 1: try decoder.decodeSingularBytesField(value: &self.nf)
       default: break
       }
     }
@@ -412,19 +314,16 @@ 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: "ephemeralKey"),
+    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.ephemeralKey) }()
-      case 3: try { try decoder.decodeSingularBytesField(value: &self.ciphertext) }()
+      case 1: try decoder.decodeSingularBytesField(value: &self.cmu)
+      case 2: try decoder.decodeSingularBytesField(value: &self.epk)
+      case 3: try decoder.decodeSingularBytesField(value: &self.ciphertext)
       default: break
       }
     }
@@ -434,8 +333,8 @@ extension CompactSaplingOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
     if !self.cmu.isEmpty {
       try visitor.visitSingularBytesField(value: self.cmu, fieldNumber: 1)
     }
-    if !self.ephemeralKey.isEmpty {
-      try visitor.visitSingularBytesField(value: self.ephemeralKey, fieldNumber: 2)
+    if !self.epk.isEmpty {
+      try visitor.visitSingularBytesField(value: self.epk, fieldNumber: 2)
     }
     if !self.ciphertext.isEmpty {
       try visitor.visitSingularBytesField(value: self.ciphertext, fieldNumber: 3)
@@ -445,7 +344,7 @@ extension CompactSaplingOutput: SwiftProtobuf.Message, SwiftProtobuf._MessageImp
 
   static func ==(lhs: CompactSaplingOutput, rhs: CompactSaplingOutput) -> Bool {
     if lhs.cmu != rhs.cmu {return false}
-    if lhs.ephemeralKey != rhs.ephemeralKey {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
@@ -463,14 +362,11 @@ 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 { 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) }()
+      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)
       default: break
       }
     }

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 The Zcash developers
+// 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 .
 
@@ -6,50 +6,39 @@ 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
-    ChainMetadata chainMetadata = 8; // information about the state of the chain as of 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
 }
 
 // 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.
-    // If there are no transparent inputs, the fee will be calculable as:
-    //    valueBalanceSapling + valueBalanceOrchard + sum(vPubNew) - sum(vPubOld) - sum(tOut)
+    // in a pure-Sapling context, the fee will be calculable as:
+    //    valueBalance + (sum(vPubNew) - sum(vPubOld) - sum(tOut))
     uint32 fee = 3;
 
-    repeated CompactSaplingSpend spends = 4;
-    repeated CompactSaplingOutput outputs = 5;
+    repeated CompactSaplingSpend spends = 4;   // inputs
+    repeated CompactSaplingOutput outputs = 5; // outputs
     repeated CompactOrchardAction actions = 6;
 }
 
@@ -59,14 +48,11 @@ message CompactSaplingSpend {
     bytes nf = 1;   // nullifier (see the Zcash protocol specification)
 }
 
-// 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.
+// output is a Sapling Output Description as described in section 7.4 of the
+// Zcash protocol spec. Total size is 948.
 message CompactSaplingOutput {
     bytes cmu = 1;          // note commitment u-coordinate
-    bytes ephemeralKey = 2; // ephemeral public key
+    bytes epk = 2;          // ephemeral public key
     bytes ciphertext = 3;   // first 52 bytes of ciphertext
 }
 
@@ -76,5 +62,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 first 52 bytes of the encCiphertext field
+    bytes ciphertext = 4;       // [52] The note plaintext component 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,28 +110,11 @@ message Exclude {
 
 // The TreeState is derived from the Zcash z_gettreestate rpc.
 message TreeState {
-    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.
+    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
 }
 
 // Results are sorted by height, which makes it easy to issue another
@@ -158,12 +141,8 @@ 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) {}
@@ -195,11 +174,6 @@ 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) {}