dash-platform-sdk 1.5.0-dev.1 → 1.5.0-dev.3

package/proto/generated/platform.js

@@ -10644,6 +10644,497 @@ class GetShieldedNullifiersResponse_GetShieldedNullifiersResponseV0_NullifierSta
  * @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
  */
@@ -10662,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 },

package/src/node/{epochs.d.ts → epochInfos.d.ts}

@@ -7,4 +7,4 @@ export interface EpochInfo {
     feeMultiplier: bigint;
     protocolVersion: 9;
 }
-export default function epochs(grpcPool: GRPCConnectionPool, count: number, ascending: boolean, start?: number): Promise<EpochInfo[]>;
+export default function epochInfos(grpcPool: GRPCConnectionPool, count: number, ascending: boolean, start?: number): Promise<EpochInfo[]>;

package/src/node/{epochs.js → epochInfos.js}

@@ -5,7 +5,7 @@ import bytesToHex from '../utils/bytesToHex.js';
 import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
 import { UInt32Value } from '../../proto/generated/google/protobuf/wrappers.js';
 import { LATEST_PLATFORM_VERSION } from '../constants.js';
-export default async function epochs(grpcPool, count, ascending, start) {
+export default async function epochInfos(grpcPool, count, ascending, start) {
     const getEpochsInfoRequest = GetEpochsInfoRequest.create({
         version: {
             oneofKind: 'v0',

package/src/node/finalizedEpochInfos.d.ts

@@ -0,0 +1,21 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { IdentifierWASM } from 'pshenmic-dpp';
+export interface FinalizedEpochInfo {
+    epochIndex: number;
+    firstBlockTime: Date;
+    firstBlockHeight: bigint;
+    totalBlocksInEpoch: bigint;
+    firstCoreBlockHeight: number;
+    nextEpochStartCoreBlockHeight: number;
+    totalProcessingFees: bigint;
+    totalDistributedStorageFees: bigint;
+    totalCreatedStorageFees: bigint;
+    coreBlockRewards: bigint;
+    blockProposers: {
+        proposer: IdentifierWASM;
+        count: bigint;
+    }[];
+    feeMultiplier: bigint;
+    protocolVersion: number;
+}
+export default function getFinalizedEpochsInfo(grpcPool: GRPCConnectionPool, startEpochIndex: number, startEpochIndexIncluded: boolean, endEpochIndex: number, endEpochIndexIncluded: boolean): Promise<FinalizedEpochInfo[]>;

package/src/node/finalizedEpochInfos.js

@@ -0,0 +1,54 @@
+import { GetFinalizedEpochInfosRequest } from '../../proto/generated/platform.js';
+import { verifyFinalizedEpochInfosProof } from 'pshenmic-dpp';
+import { getQuorumPublicKey } from '../utils/getQuorumPublicKey.js';
+import bytesToHex from '../utils/bytesToHex.js';
+import verifyTenderdashProof from '../utils/verifyTenderdashProof.js';
+import { LATEST_PLATFORM_VERSION } from '../constants.js';
+export default async function getFinalizedEpochsInfo(grpcPool, startEpochIndex, startEpochIndexIncluded, endEpochIndex, endEpochIndexIncluded) {
+    const getEpochsInfoRequest = GetFinalizedEpochInfosRequest.create({
+        version: {
+            oneofKind: 'v0',
+            v0: {
+                startEpochIndex,
+                startEpochIndexIncluded,
+                endEpochIndex,
+                endEpochIndexIncluded,
+                prove: true
+            }
+        }
+    });
+    const { response } = await grpcPool.getClient().getFinalizedEpochInfos(getEpochsInfoRequest);
+    const { version } = response;
+    if (version.oneofKind !== 'v0') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be v0)');
+    }
+    const { v0 } = version;
+    if (v0.result.oneofKind !== 'proof') {
+        throw new Error('Unexpected oneOf type returned from DAPI (must be proof)');
+    }
+    const { result: { proof }, metadata } = v0;
+    if (metadata == null) {
+        throw new Error('Metadata not found');
+    }
+    const { rootHash, epochInfos } = verifyFinalizedEpochInfosProof(proof.grovedbProof, startEpochIndex, startEpochIndexIncluded, endEpochIndex, endEpochIndexIncluded, LATEST_PLATFORM_VERSION);
+    const quorumPublicKey = await getQuorumPublicKey(grpcPool.network, proof.quorumType, bytesToHex(proof.quorumHash));
+    const verify = await verifyTenderdashProof(proof, metadata, rootHash, quorumPublicKey);
+    if (!verify) {
+        throw new Error('Failed to verify query');
+    }
+    return epochInfos.map(info => ({
+        epochIndex: info.epochIndex,
+        firstBlockTime: info.firstBlockTime,
+        firstBlockHeight: info.firstBlockHeight,
+        totalBlocksInEpoch: info.totalBlocksInEpoch,
+        firstCoreBlockHeight: info.firstCoreBlockHeight,
+        nextEpochStartCoreBlockHeight: info.nextEpochStartCoreBlockHeight,
+        totalProcessingFees: info.totalProcessingFees,
+        totalDistributedStorageFees: info.totalDistributedStorageFees,
+        totalCreatedStorageFees: info.totalCreatedStorageFees,
+        coreBlockRewards: info.coreBlockRewards,
+        blockProposers: info.blockProposers,
+        feeMultiplier: info.feeMultiplierPermille,
+        protocolVersion: info.protocolVersion
+    }));
+}

package/src/node/index.d.ts

@@ -1,6 +1,7 @@
 import GRPCConnectionPool from '../grpcConnectionPool.js';
 import { NodeStatus } from '../../types.js';
-import { EpochInfo } from './epochs.js';
+import { EpochInfo } from './epochInfos.js';
+import { FinalizedEpochInfo } from './finalizedEpochInfos.js';
 /**
  * Node controller for requesting information about DAPI node
  *
@@ -30,4 +31,11 @@ export declare class NodeController {
      * @return {Promise<EpochInfo[]>}
      */
     getEpochsInfo(count: number, ascending: boolean, start?: number): Promise<EpochInfo[]>;
+    /**
+     * Retrieves an finalized info about epochs
+     * Includes information about first block height, time, fee multiplier, number
+     *
+     * @return {Promise<FinalizedEpochInfo[]>}
+     */
+    getFinalizedEpochsInfo(startEpochIndex: number, startEpochIndexIncluded: boolean, endEpochIndex: number, endEpochIndexIncluded: boolean): Promise<FinalizedEpochInfo[]>;
 }

package/src/node/index.js

@@ -1,5 +1,6 @@
 import getStatus from './status.js';
-import getEpochsInfo from './epochs.js';
+import getEpochsInfo from './epochInfos.js';
+import getFinalizedEpochsInfo from './finalizedEpochInfos.js';
 import getTotalCredits from './totalCredits.js';
 /**
  * Node controller for requesting information about DAPI node
@@ -38,4 +39,13 @@ export class NodeController {
     async getEpochsInfo(count, ascending, start) {
         return await getEpochsInfo(this.grpcPool, count, ascending, start);
     }
+    /**
+     * Retrieves an finalized info about epochs
+     * Includes information about first block height, time, fee multiplier, number
+     *
+     * @return {Promise<FinalizedEpochInfo[]>}
+     */
+    async getFinalizedEpochsInfo(startEpochIndex, startEpochIndexIncluded, endEpochIndex, endEpochIndexIncluded) {
+        return await getFinalizedEpochsInfo(this.grpcPool, startEpochIndex, startEpochIndexIncluded, endEpochIndex, endEpochIndexIncluded);
+    }
 }

package/src/shielded/createStateTransition.d.ts

@@ -1,3 +1,3 @@
 import { ShieldedBuilderWASM, StateTransitionWASM } from 'pshenmic-dpp';
 import { ShieldedTransitionParamsMap, ShieldedTransitionType } from '../../types.js';
-export default function createStateTransition<K extends ShieldedTransitionType>(builder: ShieldedBuilderWASM, type: K, params: ShieldedTransitionParamsMap[K]): StateTransitionWASM;
+export default function createStateTransition<K extends ShieldedTransitionType>(builder: ShieldedBuilderWASM, type: K, params: ShieldedTransitionParamsMap[K]): Promise<StateTransitionWASM>;