dash-platform-sdk 1.4.0 → 1.5.0-dev.2

package/proto/generated/platform.js

@@ -9069,6 +9069,2072 @@ 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 message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosRequest$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0 }
+        ]);
+    }
+    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.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0.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.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0.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.GetFinalizedEpochInfosRequest
+ */
+export const GetFinalizedEpochInfosRequest = new GetFinalizedEpochInfosRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0", [
+            { no: 1, name: "start_epoch_index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "start_epoch_index_included", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "end_epoch_index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 4, name: "end_epoch_index_included", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "prove", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.startEpochIndex = 0;
+        message.startEpochIndexIncluded = false;
+        message.endEpochIndex = 0;
+        message.endEpochIndexIncluded = false;
+        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 /* uint32 start_epoch_index */ 1:
+                    message.startEpochIndex = reader.uint32();
+                    break;
+                case /* bool start_epoch_index_included */ 2:
+                    message.startEpochIndexIncluded = reader.bool();
+                    break;
+                case /* uint32 end_epoch_index */ 3:
+                    message.endEpochIndex = reader.uint32();
+                    break;
+                case /* bool end_epoch_index_included */ 4:
+                    message.endEpochIndexIncluded = reader.bool();
+                    break;
+                case /* bool prove */ 5:
+                    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) {
+        /* uint32 start_epoch_index = 1; */
+        if (message.startEpochIndex !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.startEpochIndex);
+        /* bool start_epoch_index_included = 2; */
+        if (message.startEpochIndexIncluded !== false)
+            writer.tag(2, WireType.Varint).bool(message.startEpochIndexIncluded);
+        /* uint32 end_epoch_index = 3; */
+        if (message.endEpochIndex !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.endEpochIndex);
+        /* bool end_epoch_index_included = 4; */
+        if (message.endEpochIndexIncluded !== false)
+            writer.tag(4, WireType.Varint).bool(message.endEpochIndexIncluded);
+        /* bool prove = 5; */
+        if (message.prove !== false)
+            writer.tag(5, 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.GetFinalizedEpochInfosRequest.GetFinalizedEpochInfosRequestV0
+ */
+export const GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0 = new GetFinalizedEpochInfosRequest_GetFinalizedEpochInfosRequestV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosResponse$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse", [
+            { no: 1, name: "v0", kind: "message", oneof: "version", T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0 }
+        ]);
+    }
+    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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0 v0 */ 1:
+                    message.version = {
+                        oneofKind: "v0",
+                        v0: GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0.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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0 v0 = 1; */
+        if (message.version.oneofKind === "v0")
+            GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0.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.GetFinalizedEpochInfosResponse
+ */
+export const GetFinalizedEpochInfosResponse = new GetFinalizedEpochInfosResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0", [
+            { no: 1, name: "epochs", kind: "message", oneof: "result", T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos },
+            { 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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos epochs */ 1:
+                    message.result = {
+                        oneofKind: "epochs",
+                        epochs: GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos.internalBinaryRead(reader, reader.uint32(), options, message.result.epochs)
+                    };
+                    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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos epochs = 1; */
+        if (message.result.oneofKind === "epochs")
+            GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos.internalBinaryWrite(message.result.epochs, 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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0
+ */
+export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0 = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos", [
+            { no: 1, name: "finalized_epoch_infos", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.finalizedEpochInfos = [];
+        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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo finalized_epoch_infos */ 1:
+                    message.finalizedEpochInfos.push(GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo.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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo finalized_epoch_infos = 1; */
+        for (let i = 0; i < message.finalizedEpochInfos.length; i++)
+            GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo.internalBinaryWrite(message.finalizedEpochInfos[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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfos
+ */
+export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfos$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo", [
+            { no: 1, name: "number", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "first_block_height", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 3, name: "first_core_block_height", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 4, name: "first_block_time", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 5, name: "fee_multiplier", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 6, name: "protocol_version", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 7, name: "total_blocks_in_epoch", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 8, name: "next_epoch_start_core_block_height", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 9, name: "total_processing_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 10, name: "total_distributed_storage_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 11, name: "total_created_storage_fees", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 12, name: "core_block_rewards", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
+            { no: 13, name: "block_proposers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.number = 0;
+        message.firstBlockHeight = "0";
+        message.firstCoreBlockHeight = 0;
+        message.firstBlockTime = "0";
+        message.feeMultiplier = 0;
+        message.protocolVersion = 0;
+        message.totalBlocksInEpoch = "0";
+        message.nextEpochStartCoreBlockHeight = 0;
+        message.totalProcessingFees = "0";
+        message.totalDistributedStorageFees = "0";
+        message.totalCreatedStorageFees = "0";
+        message.coreBlockRewards = "0";
+        message.blockProposers = [];
+        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 /* uint32 number */ 1:
+                    message.number = reader.uint32();
+                    break;
+                case /* uint64 first_block_height = 2 [jstype = JS_STRING] */ 2:
+                    message.firstBlockHeight = reader.uint64().toString();
+                    break;
+                case /* uint32 first_core_block_height */ 3:
+                    message.firstCoreBlockHeight = reader.uint32();
+                    break;
+                case /* uint64 first_block_time = 4 [jstype = JS_STRING] */ 4:
+                    message.firstBlockTime = reader.uint64().toString();
+                    break;
+                case /* double fee_multiplier */ 5:
+                    message.feeMultiplier = reader.double();
+                    break;
+                case /* uint32 protocol_version */ 6:
+                    message.protocolVersion = reader.uint32();
+                    break;
+                case /* uint64 total_blocks_in_epoch = 7 [jstype = JS_STRING] */ 7:
+                    message.totalBlocksInEpoch = reader.uint64().toString();
+                    break;
+                case /* uint32 next_epoch_start_core_block_height */ 8:
+                    message.nextEpochStartCoreBlockHeight = reader.uint32();
+                    break;
+                case /* uint64 total_processing_fees = 9 [jstype = JS_STRING] */ 9:
+                    message.totalProcessingFees = reader.uint64().toString();
+                    break;
+                case /* uint64 total_distributed_storage_fees = 10 [jstype = JS_STRING] */ 10:
+                    message.totalDistributedStorageFees = reader.uint64().toString();
+                    break;
+                case /* uint64 total_created_storage_fees = 11 [jstype = JS_STRING] */ 11:
+                    message.totalCreatedStorageFees = reader.uint64().toString();
+                    break;
+                case /* uint64 core_block_rewards = 12 [jstype = JS_STRING] */ 12:
+                    message.coreBlockRewards = reader.uint64().toString();
+                    break;
+                case /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer block_proposers */ 13:
+                    message.blockProposers.push(GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer.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) {
+        /* uint32 number = 1; */
+        if (message.number !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.number);
+        /* uint64 first_block_height = 2 [jstype = JS_STRING]; */
+        if (message.firstBlockHeight !== "0")
+            writer.tag(2, WireType.Varint).uint64(message.firstBlockHeight);
+        /* uint32 first_core_block_height = 3; */
+        if (message.firstCoreBlockHeight !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.firstCoreBlockHeight);
+        /* uint64 first_block_time = 4 [jstype = JS_STRING]; */
+        if (message.firstBlockTime !== "0")
+            writer.tag(4, WireType.Varint).uint64(message.firstBlockTime);
+        /* double fee_multiplier = 5; */
+        if (message.feeMultiplier !== 0)
+            writer.tag(5, WireType.Bit64).double(message.feeMultiplier);
+        /* uint32 protocol_version = 6; */
+        if (message.protocolVersion !== 0)
+            writer.tag(6, WireType.Varint).uint32(message.protocolVersion);
+        /* uint64 total_blocks_in_epoch = 7 [jstype = JS_STRING]; */
+        if (message.totalBlocksInEpoch !== "0")
+            writer.tag(7, WireType.Varint).uint64(message.totalBlocksInEpoch);
+        /* uint32 next_epoch_start_core_block_height = 8; */
+        if (message.nextEpochStartCoreBlockHeight !== 0)
+            writer.tag(8, WireType.Varint).uint32(message.nextEpochStartCoreBlockHeight);
+        /* uint64 total_processing_fees = 9 [jstype = JS_STRING]; */
+        if (message.totalProcessingFees !== "0")
+            writer.tag(9, WireType.Varint).uint64(message.totalProcessingFees);
+        /* uint64 total_distributed_storage_fees = 10 [jstype = JS_STRING]; */
+        if (message.totalDistributedStorageFees !== "0")
+            writer.tag(10, WireType.Varint).uint64(message.totalDistributedStorageFees);
+        /* uint64 total_created_storage_fees = 11 [jstype = JS_STRING]; */
+        if (message.totalCreatedStorageFees !== "0")
+            writer.tag(11, WireType.Varint).uint64(message.totalCreatedStorageFees);
+        /* uint64 core_block_rewards = 12 [jstype = JS_STRING]; */
+        if (message.coreBlockRewards !== "0")
+            writer.tag(12, WireType.Varint).uint64(message.coreBlockRewards);
+        /* repeated org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer block_proposers = 13; */
+        for (let i = 0; i < message.blockProposers.length; i++)
+            GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer.internalBinaryWrite(message.blockProposers[i], writer.tag(13, 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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.FinalizedEpochInfo
+ */
+export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_FinalizedEpochInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer$Type extends MessageType {
+    constructor() {
+        super("org.dash.platform.dapi.v0.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer", [
+            { no: 1, name: "proposer_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "block_count", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.proposerId = new Uint8Array(0);
+        message.blockCount = 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 proposer_id */ 1:
+                    message.proposerId = reader.bytes();
+                    break;
+                case /* uint32 block_count */ 2:
+                    message.blockCount = reader.uint32();
+                    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 proposer_id = 1; */
+        if (message.proposerId.length)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.proposerId);
+        /* uint32 block_count = 2; */
+        if (message.blockCount !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.blockCount);
+        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.GetFinalizedEpochInfosResponse.GetFinalizedEpochInfosResponseV0.BlockProposer
+ */
+export const GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer = new GetFinalizedEpochInfosResponse_GetFinalizedEpochInfosResponseV0_BlockProposer$Type();
 /**
  * @generated ServiceType for protobuf service org.dash.platform.dapi.v0.Platform
  */
@@ -9087,6 +11153,7 @@ export const Platform = new ServiceType("org.dash.platform.dapi.v0.Platform", [
     { name: "getIdentityByPublicKeyHash", options: {}, I: GetIdentityByPublicKeyHashRequest, O: GetIdentityByPublicKeyHashResponse },
     { name: "getIdentityByNonUniquePublicKeyHash", options: {}, I: GetIdentityByNonUniquePublicKeyHashRequest, O: GetIdentityByNonUniquePublicKeyHashResponse },
     { name: "getEpochsInfo", options: {}, I: GetEpochsInfoRequest, O: GetEpochsInfoResponse },
+    { name: "getFinalizedEpochInfos", options: {}, I: GetFinalizedEpochInfosRequest, O: GetFinalizedEpochInfosResponse },
     { name: "getContestedResources", options: {}, I: GetContestedResourcesRequest, O: GetContestedResourcesResponse },
     { name: "getContestedResourceVoteState", options: {}, I: GetContestedResourceVoteStateRequest, O: GetContestedResourceVoteStateResponse },
     { name: "getTotalCreditsInPlatform", options: {}, I: GetTotalCreditsInPlatformRequest, O: GetTotalCreditsInPlatformResponse },
@@ -9098,5 +11165,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 }
 ]);