@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.30

package/esm/akash/bme/v1/query.js

@@ -0,0 +1,724 @@
+//@ts-nocheck
+import { LedgerRecordFilters } from "./filters";
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params } from "./params";
+import { State, LedgerRecordID, LedgerPendingRecord, LedgerRecord, LedgerCanceledRecord } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is the request type for the Query/Params RPC method
+ * @name QueryParamsRequest
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/akash.bme.v1.QueryParamsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is the response type for the Query/Params RPC method
+ * @name QueryParamsResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/akash.bme.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryVaultStateRequest() {
+    return {};
+}
+/**
+ * QueryVaultStateRequest is the request type for the Query/VaultState RPC method
+ * @name QueryVaultStateRequest
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryVaultStateRequest
+ */
+export const QueryVaultStateRequest = {
+    typeUrl: "/akash.bme.v1.QueryVaultStateRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryVaultStateRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryVaultStateRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryVaultStateRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryVaultStateRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryVaultStateRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryVaultStateRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryVaultStateRequest",
+            value: QueryVaultStateRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryVaultStateResponse() {
+    return {
+        vaultState: State.fromPartial({})
+    };
+}
+/**
+ * QueryVaultStateResponse is the response type for the Query/VaultState RPC method
+ * @name QueryVaultStateResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryVaultStateResponse
+ */
+export const QueryVaultStateResponse = {
+    typeUrl: "/akash.bme.v1.QueryVaultStateResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.vaultState !== undefined) {
+            State.encode(message.vaultState, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryVaultStateResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.vaultState = State.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryVaultStateResponse();
+        message.vaultState = object.vaultState !== undefined && object.vaultState !== null ? State.fromPartial(object.vaultState) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryVaultStateResponse();
+        if (object.vault_state !== undefined && object.vault_state !== null) {
+            message.vaultState = State.fromAmino(object.vault_state);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.vault_state = message.vaultState ? State.toAmino(message.vaultState) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryVaultStateResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryVaultStateResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryVaultStateResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryVaultStateResponse",
+            value: QueryVaultStateResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryStatusRequest() {
+    return {};
+}
+/**
+ * QueryStatusRequest is the request type for the circuit breaker status
+ * @name QueryStatusRequest
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryStatusRequest
+ */
+export const QueryStatusRequest = {
+    typeUrl: "/akash.bme.v1.QueryStatusRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryStatusRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryStatusRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryStatusRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryStatusRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryStatusRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryStatusRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryStatusRequest",
+            value: QueryStatusRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryStatusResponse() {
+    return {
+        status: 0,
+        collateralRatio: "",
+        warnThreshold: "",
+        haltThreshold: "",
+        mintsAllowed: false,
+        refundsAllowed: false
+    };
+}
+/**
+ * QueryMintStatusResponse is the response type for the circuit breaker status
+ * @name QueryStatusResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryStatusResponse
+ */
+export const QueryStatusResponse = {
+    typeUrl: "/akash.bme.v1.QueryStatusResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.status !== 0) {
+            writer.uint32(8).int32(message.status);
+        }
+        if (message.collateralRatio !== "") {
+            writer.uint32(18).string(Decimal.fromUserInput(message.collateralRatio, 18).atomics);
+        }
+        if (message.warnThreshold !== "") {
+            writer.uint32(26).string(Decimal.fromUserInput(message.warnThreshold, 18).atomics);
+        }
+        if (message.haltThreshold !== "") {
+            writer.uint32(34).string(Decimal.fromUserInput(message.haltThreshold, 18).atomics);
+        }
+        if (message.mintsAllowed === true) {
+            writer.uint32(40).bool(message.mintsAllowed);
+        }
+        if (message.refundsAllowed === true) {
+            writer.uint32(48).bool(message.refundsAllowed);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryStatusResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.status = reader.int32();
+                    break;
+                case 2:
+                    message.collateralRatio = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 3:
+                    message.warnThreshold = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 4:
+                    message.haltThreshold = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 5:
+                    message.mintsAllowed = reader.bool();
+                    break;
+                case 6:
+                    message.refundsAllowed = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryStatusResponse();
+        message.status = object.status ?? 0;
+        message.collateralRatio = object.collateralRatio ?? "";
+        message.warnThreshold = object.warnThreshold ?? "";
+        message.haltThreshold = object.haltThreshold ?? "";
+        message.mintsAllowed = object.mintsAllowed ?? false;
+        message.refundsAllowed = object.refundsAllowed ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryStatusResponse();
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.collateral_ratio !== undefined && object.collateral_ratio !== null) {
+            message.collateralRatio = object.collateral_ratio;
+        }
+        if (object.warn_threshold !== undefined && object.warn_threshold !== null) {
+            message.warnThreshold = object.warn_threshold;
+        }
+        if (object.halt_threshold !== undefined && object.halt_threshold !== null) {
+            message.haltThreshold = object.halt_threshold;
+        }
+        if (object.mints_allowed !== undefined && object.mints_allowed !== null) {
+            message.mintsAllowed = object.mints_allowed;
+        }
+        if (object.refunds_allowed !== undefined && object.refunds_allowed !== null) {
+            message.refundsAllowed = object.refunds_allowed;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.collateral_ratio = message.collateralRatio === "" ? undefined : message.collateralRatio;
+        obj.warn_threshold = message.warnThreshold === "" ? undefined : message.warnThreshold;
+        obj.halt_threshold = message.haltThreshold === "" ? undefined : message.haltThreshold;
+        obj.mints_allowed = message.mintsAllowed === false ? undefined : message.mintsAllowed;
+        obj.refunds_allowed = message.refundsAllowed === false ? undefined : message.refundsAllowed;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryStatusResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryStatusResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryStatusResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryStatusResponse",
+            value: QueryStatusResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryLedgerRecordEntry() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        status: 0,
+        pendingRecord: undefined,
+        executedRecord: undefined,
+        canceledRecord: undefined
+    };
+}
+/**
+ * QueryLedgerRecordEntry wraps a ledger record with its ID and status
+ * @name QueryLedgerRecordEntry
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryLedgerRecordEntry
+ */
+export const QueryLedgerRecordEntry = {
+    typeUrl: "/akash.bme.v1.QueryLedgerRecordEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            LedgerRecordID.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.status !== 0) {
+            writer.uint32(16).int32(message.status);
+        }
+        if (message.pendingRecord !== undefined) {
+            LedgerPendingRecord.encode(message.pendingRecord, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.executedRecord !== undefined) {
+            LedgerRecord.encode(message.executedRecord, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.canceledRecord !== undefined) {
+            LedgerCanceledRecord.encode(message.canceledRecord, writer.uint32(42).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryLedgerRecordEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = LedgerRecordID.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.status = reader.int32();
+                    break;
+                case 3:
+                    message.pendingRecord = LedgerPendingRecord.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.executedRecord = LedgerRecord.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.canceledRecord = LedgerCanceledRecord.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryLedgerRecordEntry();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.status = object.status ?? 0;
+        message.pendingRecord = object.pendingRecord !== undefined && object.pendingRecord !== null ? LedgerPendingRecord.fromPartial(object.pendingRecord) : undefined;
+        message.executedRecord = object.executedRecord !== undefined && object.executedRecord !== null ? LedgerRecord.fromPartial(object.executedRecord) : undefined;
+        message.canceledRecord = object.canceledRecord !== undefined && object.canceledRecord !== null ? LedgerCanceledRecord.fromPartial(object.canceledRecord) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryLedgerRecordEntry();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.pending_record !== undefined && object.pending_record !== null) {
+            message.pendingRecord = LedgerPendingRecord.fromAmino(object.pending_record);
+        }
+        if (object.executed_record !== undefined && object.executed_record !== null) {
+            message.executedRecord = LedgerRecord.fromAmino(object.executed_record);
+        }
+        if (object.canceled_record !== undefined && object.canceled_record !== null) {
+            message.canceledRecord = LedgerCanceledRecord.fromAmino(object.canceled_record);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? LedgerRecordID.toAmino(message.id) : LedgerRecordID.toAmino(LedgerRecordID.fromPartial({}));
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.pending_record = message.pendingRecord ? LedgerPendingRecord.toAmino(message.pendingRecord) : undefined;
+        obj.executed_record = message.executedRecord ? LedgerRecord.toAmino(message.executedRecord) : undefined;
+        obj.canceled_record = message.canceledRecord ? LedgerCanceledRecord.toAmino(message.canceledRecord) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryLedgerRecordEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryLedgerRecordEntry.decode(message.value);
+    },
+    toProto(message) {
+        return QueryLedgerRecordEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryLedgerRecordEntry",
+            value: QueryLedgerRecordEntry.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryLedgerRecordsRequest() {
+    return {
+        filters: LedgerRecordFilters.fromPartial({}),
+        pagination: undefined
+    };
+}
+/**
+ * QueryLedgerRecordsRequest is the request type for the Query/LedgerRecords RPC method
+ * @name QueryLedgerRecordsRequest
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryLedgerRecordsRequest
+ */
+export const QueryLedgerRecordsRequest = {
+    typeUrl: "/akash.bme.v1.QueryLedgerRecordsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.filters !== undefined) {
+            LedgerRecordFilters.encode(message.filters, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryLedgerRecordsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.filters = LedgerRecordFilters.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryLedgerRecordsRequest();
+        message.filters = object.filters !== undefined && object.filters !== null ? LedgerRecordFilters.fromPartial(object.filters) : undefined;
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryLedgerRecordsRequest();
+        if (object.filters !== undefined && object.filters !== null) {
+            message.filters = LedgerRecordFilters.fromAmino(object.filters);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.filters = message.filters ? LedgerRecordFilters.toAmino(message.filters) : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryLedgerRecordsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryLedgerRecordsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryLedgerRecordsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryLedgerRecordsRequest",
+            value: QueryLedgerRecordsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryLedgerRecordsResponse() {
+    return {
+        records: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryLedgerRecordsResponse is the response type for the Query/LedgerRecords RPC method
+ * @name QueryLedgerRecordsResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.QueryLedgerRecordsResponse
+ */
+export const QueryLedgerRecordsResponse = {
+    typeUrl: "/akash.bme.v1.QueryLedgerRecordsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.records) {
+            QueryLedgerRecordEntry.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryLedgerRecordsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.records.push(QueryLedgerRecordEntry.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryLedgerRecordsResponse();
+        message.records = object.records?.map(e => QueryLedgerRecordEntry.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryLedgerRecordsResponse();
+        message.records = object.records?.map(e => QueryLedgerRecordEntry.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.records) {
+            obj.records = message.records.map(e => e ? QueryLedgerRecordEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.records = message.records;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryLedgerRecordsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryLedgerRecordsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryLedgerRecordsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.QueryLedgerRecordsResponse",
+            value: QueryLedgerRecordsResponse.encode(message).finish()
+        };
+    }
+};