dash-platform-sdk 1.4.0-dev.9 → 1.5.0-dev.1

package/proto/generated/platform.js

@@ -9069,6 +9069,1581 @@ class GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type extends Message
  * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetAddressesInfosResponse.GetAddressesInfosResponseV0
  */
 export const GetAddressesInfosResponse_GetAddressesInfosResponseV0 = new GetAddressesInfosResponse_GetAddressesInfosResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest
+ */
+export const GetShieldedEncryptedNotesRequest = new GetShieldedEncryptedNotesRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0", [
+            { no: 1, name: "start_index", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 2, name: "count", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 3, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.startIndex = "0";
+        message.count = 0;
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 start_index */ 1:
+                    message.startIndex = reader.uint64().toString();
+                    break;
+                case /* uint32 count */ 2:
+                    message.count = reader.uint32();
+                    break;
+                case /* bool prove */ 3:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 start_index = 1; */
+        if (message.startIndex !== "0")
+            writer.tag(1, WireType.Varint).uint64(message.startIndex);
+        /* uint32 count = 2; */
+        if (message.count !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.count);
+        /* bool prove = 3; */
+        if (message.prove !== false)
+            writer.tag(3, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0
+ */
+export const GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0 = new GetShieldedEncryptedNotesRequest_GetShieldedEncryptedNotesRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse
+ */
+export const GetShieldedEncryptedNotesResponse = new GetShieldedEncryptedNotesResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0", [
+            { no: 1, name: "encrypted_notes", kind: "message", oneof: "result", T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes encrypted_notes */ 1:
+                    message.result = {
+                        oneofKind: "encryptedNotes",
+                        encryptedNotes: GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes.internalBinaryRead(reader, reader.uint32(), options, message.result.encryptedNotes)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes encrypted_notes = 1; */
+        if (message.result.oneofKind === "encryptedNotes")
+            GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes.internalBinaryWrite(message.result.encryptedNotes, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0
+ */
+export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0 = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote", [
+            { no: 1, name: "nullifier", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "cmx", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "encrypted_note", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "cv_net", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.nullifier = new Uint8Array(0);
+        message.cmx = new Uint8Array(0);
+        message.encryptedNote = new Uint8Array(0);
+        message.cvNet = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes nullifier */ 1:
+                    message.nullifier = reader.bytes();
+                    break;
+                case /* bytes cmx */ 2:
+                    message.cmx = reader.bytes();
+                    break;
+                case /* bytes encrypted_note */ 3:
+                    message.encryptedNote = reader.bytes();
+                    break;
+                case /* bytes cv_net */ 4:
+                    message.cvNet = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bytes nullifier = 1; */
+        if (message.nullifier.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.nullifier);
+        /* bytes cmx = 2; */
+        if (message.cmx.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.cmx);
+        /* bytes encrypted_note = 3; */
+        if (message.encryptedNote.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.encryptedNote);
+        /* bytes cv_net = 4; */
+        if (message.cvNet.length)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.cvNet);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote
+ */
+export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes", [
+            { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.entries = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote entries */ 1:
+                    message.entries.push(GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote entries = 1; */
+        for (let i = 0; i < message.entries.length; i++)
+            GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNote.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes
+ */
+export const GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes = new GetShieldedEncryptedNotesResponse_GetShieldedEncryptedNotesResponseV0_EncryptedNotes$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedAnchorsRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedAnchorsRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsRequest
+ */
+export const GetShieldedAnchorsRequest = new GetShieldedAnchorsRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0", [
+            { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool prove */ 1:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool prove = 1; */
+        if (message.prove !== false)
+            writer.tag(1, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0
+ */
+export const GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0 = new GetShieldedAnchorsRequest_GetShieldedAnchorsRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedAnchorsResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse
+ */
+export const GetShieldedAnchorsResponse = new GetShieldedAnchorsResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0", [
+            { no: 1, name: "anchors", kind: "message", oneof: "result", T: () => GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors anchors */ 1:
+                    message.result = {
+                        oneofKind: "anchors",
+                        anchors: GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors.internalBinaryRead(reader, reader.uint32(), options, message.result.anchors)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors anchors = 1; */
+        if (message.result.oneofKind === "anchors")
+            GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors.internalBinaryWrite(message.result.anchors, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0
+ */
+export const GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0 = new GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors", [
+            { no: 1, name: "anchors", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.anchors = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated bytes anchors */ 1:
+                    message.anchors.push(reader.bytes());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated bytes anchors = 1; */
+        for (let i = 0; i < message.anchors.length; i++)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.anchors[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors
+ */
+export const GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors = new GetShieldedAnchorsResponse_GetShieldedAnchorsResponseV0_Anchors$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetMostRecentShieldedAnchorRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest
+ */
+export const GetMostRecentShieldedAnchorRequest = new GetMostRecentShieldedAnchorRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0", [
+            { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool prove */ 1:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool prove = 1; */
+        if (message.prove !== false)
+            writer.tag(1, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0
+ */
+export const GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0 = new GetMostRecentShieldedAnchorRequest_GetMostRecentShieldedAnchorRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetMostRecentShieldedAnchorResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse
+ */
+export const GetMostRecentShieldedAnchorResponse = new GetMostRecentShieldedAnchorResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0", [
+            { no: 1, name: "anchor", kind: "scalar", oneof: "result", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes anchor */ 1:
+                    message.result = {
+                        oneofKind: "anchor",
+                        anchor: reader.bytes()
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bytes anchor = 1; */
+        if (message.result.oneofKind === "anchor")
+            writer.tag(1, WireType.LengthDelimited).bytes(message.result.anchor);
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0
+ */
+export const GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0 = new GetMostRecentShieldedAnchorResponse_GetMostRecentShieldedAnchorResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedPoolStateRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedPoolStateRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateRequest
+ */
+export const GetShieldedPoolStateRequest = new GetShieldedPoolStateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0", [
+            { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool prove */ 1:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool prove = 1; */
+        if (message.prove !== false)
+            writer.tag(1, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0
+ */
+export const GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0 = new GetShieldedPoolStateRequest_GetShieldedPoolStateRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedPoolStateResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedPoolStateResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateResponse
+ */
+export const GetShieldedPoolStateResponse = new GetShieldedPoolStateResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0", [
+            { no: 1, name: "total_balance", kind: "scalar", oneof: "result", T: 4 /*ScalarType.UINT64*/ },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 total_balance = 1 [jstype = JS_STRING] */ 1:
+                    message.result = {
+                        oneofKind: "totalBalance",
+                        totalBalance: reader.uint64().toString()
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 total_balance = 1 [jstype = JS_STRING]; */
+        if (message.result.oneofKind === "totalBalance")
+            writer.tag(1, WireType.Varint).uint64(message.result.totalBalance);
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0
+ */
+export const GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0 = new GetShieldedPoolStateResponse_GetShieldedPoolStateResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNotesCountRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNotesCountRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountRequest
+ */
+export const GetShieldedNotesCountRequest = new GetShieldedNotesCountRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0", [
+            { no: 1, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool prove */ 1:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool prove = 1; */
+        if (message.prove !== false)
+            writer.tag(1, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountRequest.GetShieldedNotesCountRequestV0
+ */
+export const GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0 = new GetShieldedNotesCountRequest_GetShieldedNotesCountRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNotesCountResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNotesCountResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountResponse
+ */
+export const GetShieldedNotesCountResponse = new GetShieldedNotesCountResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0", [
+            { no: 1, name: "total_notes_count", kind: "scalar", oneof: "result", T: 4 /*ScalarType.UINT64*/ },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 total_notes_count = 1 [jstype = JS_STRING] */ 1:
+                    message.result = {
+                        oneofKind: "totalNotesCount",
+                        totalNotesCount: reader.uint64().toString()
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 total_notes_count = 1 [jstype = JS_STRING]; */
+        if (message.result.oneofKind === "totalNotesCount")
+            writer.tag(1, WireType.Varint).uint64(message.result.totalNotesCount);
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNotesCountResponse.GetShieldedNotesCountResponseV0
+ */
+export const GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0 = new GetShieldedNotesCountResponse_GetShieldedNotesCountResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersRequest
+ */
+export const GetShieldedNullifiersRequest = new GetShieldedNullifiersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0", [
+            { no: 1, name: "nullifiers", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.nullifiers = [];
+        message.prove = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated bytes nullifiers */ 1:
+                    message.nullifiers.push(reader.bytes());
+                    break;
+                case /* bool prove */ 2:
+                    message.prove = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated bytes nullifiers = 1; */
+        for (let i = 0; i < message.nullifiers.length; i++)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.nullifiers[i]);
+        /* bool prove = 2; */
+        if (message.prove !== false)
+            writer.tag(2, WireType.Varint).bool(message.prove);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0
+ */
+export const GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0 = new GetShieldedNullifiersRequest_GetShieldedNullifiersRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.version = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0.internalBinaryRead(reader, reader.uint32(), options, message.version.v0)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0.internalBinaryWrite(message.version.v0, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse
+ */
+export const GetShieldedNullifiersResponse = new GetShieldedNullifiersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0", [
+            { no: 1, name: "nullifier_statuses", kind: "message", oneof: "result", T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses },
+            { no: 2, name: "proof", kind: "message", oneof: "result", T: () => Proof },
+            { no: 3, name: "metadata", kind: "message", T: () => ResponseMetadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.result = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses nullifier_statuses */ 1:
+                    message.result = {
+                        oneofKind: "nullifierStatuses",
+                        nullifierStatuses: GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses.internalBinaryRead(reader, reader.uint32(), options, message.result.nullifierStatuses)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.Proof proof */ 2:
+                    message.result = {
+                        oneofKind: "proof",
+                        proof: Proof.internalBinaryRead(reader, reader.uint32(), options, message.result.proof)
+                    };
+                    break;
+                case /* org.dash.platform.dapi.v0.ResponseMetadata metadata */ 3:
+                    message.metadata = ResponseMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses nullifier_statuses = 1; */
+        if (message.result.oneofKind === "nullifierStatuses")
+            GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses.internalBinaryWrite(message.result.nullifierStatuses, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.Proof proof = 2; */
+        if (message.result.oneofKind === "proof")
+            Proof.internalBinaryWrite(message.result.proof, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* org.dash.platform.dapi.v0.ResponseMetadata metadata = 3; */
+        if (message.metadata)
+            ResponseMetadata.internalBinaryWrite(message.metadata, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0
+ */
+export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0 = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus", [
+            { no: 1, name: "nullifier", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "is_spent", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.nullifier = new Uint8Array(0);
+        message.isSpent = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bytes nullifier */ 1:
+                    message.nullifier = reader.bytes();
+                    break;
+                case /* bool is_spent */ 2:
+                    message.isSpent = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bytes nullifier = 1; */
+        if (message.nullifier.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.nullifier);
+        /* bool is_spent = 2; */
+        if (message.isSpent !== false)
+            writer.tag(2, WireType.Varint).bool(message.isSpent);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus
+ */
+export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses", [
+            { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.entries = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus entries */ 1:
+                    message.entries.push(GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* repeated org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus entries = 1; */
+        for (let i = 0; i < message.entries.length; i++)
+            GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatus.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message org.dash.platform.dapi.v0.GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses
+ */
+export const GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses = new GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierStatuses$Type();
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */
@@ -9098,5 +10673,11 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
     { name: "getTokenTotalSupply", options: {}, I: GetTokenTotalSupplyRequest, O: GetTokenTotalSupplyResponse },
     { name: "waitForStateTransitionResult", options: {}, I: WaitForStateTransitionResultRequest, O: WaitForStateTransitionResultResponse },
     { name: "getAddressInfo", options: {}, I: GetAddressInfoRequest, O: GetAddressInfoResponse },
-    { name: "getAddressesInfos", options: {}, I: GetAddressesInfosRequest, O: GetAddressesInfosResponse }
+    { name: "getAddressesInfos", options: {}, I: GetAddressesInfosRequest, O: GetAddressesInfosResponse },
+    { name: "getShieldedEncryptedNotes", options: {}, I: GetShieldedEncryptedNotesRequest, O: GetShieldedEncryptedNotesResponse },
+    { name: "getShieldedAnchors", options: {}, I: GetShieldedAnchorsRequest, O: GetShieldedAnchorsResponse },
+    { name: "getMostRecentShieldedAnchor", options: {}, I: GetMostRecentShieldedAnchorRequest, O: GetMostRecentShieldedAnchorResponse },
+    { name: "getShieldedPoolState", options: {}, I: GetShieldedPoolStateRequest, O: GetShieldedPoolStateResponse },
+    { name: "getShieldedNotesCount", options: {}, I: GetShieldedNotesCountRequest, O: GetShieldedNotesCountResponse },
+    { name: "getShieldedNullifiers", options: {}, I: GetShieldedNullifiersRequest, O: GetShieldedNullifiersResponse }
 ]);