@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.30

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

@@ -0,0 +1,107 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseLedgerRecordFilters() {
+    return {
+        source: "",
+        denom: "",
+        toDenom: "",
+        status: ""
+    };
+}
+/**
+ * LedgerRecordFilters defines filters used to filter ledger records
+ * @name LedgerRecordFilters
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.LedgerRecordFilters
+ */
+export const LedgerRecordFilters = {
+    typeUrl: "/akash.bme.v1.LedgerRecordFilters",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.source !== "") {
+            writer.uint32(10).string(message.source);
+        }
+        if (message.denom !== "") {
+            writer.uint32(18).string(message.denom);
+        }
+        if (message.toDenom !== "") {
+            writer.uint32(26).string(message.toDenom);
+        }
+        if (message.status !== "") {
+            writer.uint32(34).string(message.status);
+        }
+        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 = createBaseLedgerRecordFilters();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.source = reader.string();
+                    break;
+                case 2:
+                    message.denom = reader.string();
+                    break;
+                case 3:
+                    message.toDenom = reader.string();
+                    break;
+                case 4:
+                    message.status = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLedgerRecordFilters();
+        message.source = object.source ?? "";
+        message.denom = object.denom ?? "";
+        message.toDenom = object.toDenom ?? "";
+        message.status = object.status ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLedgerRecordFilters();
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.to_denom !== undefined && object.to_denom !== null) {
+            message.toDenom = object.to_denom;
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.source = message.source ?? "";
+        obj.denom = message.denom ?? "";
+        obj.to_denom = message.toDenom ?? "";
+        obj.status = message.status ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LedgerRecordFilters.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return LedgerRecordFilters.decode(message.value);
+    },
+    toProto(message) {
+        return LedgerRecordFilters.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.LedgerRecordFilters",
+            value: LedgerRecordFilters.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,449 @@
+//@ts-nocheck
+import { LedgerRecordID, LedgerRecord, LedgerPendingRecord } from "./types";
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisLedgerRecord() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        record: LedgerRecord.fromPartial({})
+    };
+}
+/**
+ * GenesisLedgerRecord
+ * @name GenesisLedgerRecord
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.GenesisLedgerRecord
+ */
+export const GenesisLedgerRecord = {
+    typeUrl: "/akash.bme.v1.GenesisLedgerRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            LedgerRecordID.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.record !== undefined) {
+            LedgerRecord.encode(message.record, 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 = createBaseGenesisLedgerRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = LedgerRecordID.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.record = LedgerRecord.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisLedgerRecord();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.record = object.record !== undefined && object.record !== null ? LedgerRecord.fromPartial(object.record) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisLedgerRecord();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.record !== undefined && object.record !== null) {
+            message.record = LedgerRecord.fromAmino(object.record);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? LedgerRecordID.toAmino(message.id) : LedgerRecordID.toAmino(LedgerRecordID.fromPartial({}));
+        obj.record = message.record ? LedgerRecord.toAmino(message.record) : LedgerRecord.toAmino(LedgerRecord.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisLedgerRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisLedgerRecord.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisLedgerRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.GenesisLedgerRecord",
+            value: GenesisLedgerRecord.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisLedgerPendingRecord() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        record: LedgerPendingRecord.fromPartial({})
+    };
+}
+/**
+ * GenesisLedgerPendingRecord
+ * @name GenesisLedgerPendingRecord
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.GenesisLedgerPendingRecord
+ */
+export const GenesisLedgerPendingRecord = {
+    typeUrl: "/akash.bme.v1.GenesisLedgerPendingRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== undefined) {
+            LedgerRecordID.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.record !== undefined) {
+            LedgerPendingRecord.encode(message.record, 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 = createBaseGenesisLedgerPendingRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = LedgerRecordID.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.record = LedgerPendingRecord.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisLedgerPendingRecord();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.record = object.record !== undefined && object.record !== null ? LedgerPendingRecord.fromPartial(object.record) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisLedgerPendingRecord();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.record !== undefined && object.record !== null) {
+            message.record = LedgerPendingRecord.fromAmino(object.record);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id ? LedgerRecordID.toAmino(message.id) : LedgerRecordID.toAmino(LedgerRecordID.fromPartial({}));
+        obj.record = message.record ? LedgerPendingRecord.toAmino(message.record) : LedgerPendingRecord.toAmino(LedgerPendingRecord.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisLedgerPendingRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisLedgerPendingRecord.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisLedgerPendingRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.GenesisLedgerPendingRecord",
+            value: GenesisLedgerPendingRecord.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisLedgerState() {
+    return {
+        records: [],
+        pendingRecords: []
+    };
+}
+/**
+ * GenesisLedgerState
+ * @name GenesisLedgerState
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.GenesisLedgerState
+ */
+export const GenesisLedgerState = {
+    typeUrl: "/akash.bme.v1.GenesisLedgerState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.records) {
+            GenesisLedgerRecord.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.pendingRecords) {
+            GenesisLedgerPendingRecord.encode(v, 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 = createBaseGenesisLedgerState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.records.push(GenesisLedgerRecord.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pendingRecords.push(GenesisLedgerPendingRecord.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisLedgerState();
+        message.records = object.records?.map(e => GenesisLedgerRecord.fromPartial(e)) || [];
+        message.pendingRecords = object.pendingRecords?.map(e => GenesisLedgerPendingRecord.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisLedgerState();
+        message.records = object.records?.map(e => GenesisLedgerRecord.fromAmino(e)) || [];
+        message.pendingRecords = object.pending_records?.map(e => GenesisLedgerPendingRecord.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.records) {
+            obj.records = message.records.map(e => e ? GenesisLedgerRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.records = message.records;
+        }
+        if (message.pendingRecords) {
+            obj.pending_records = message.pendingRecords.map(e => e ? GenesisLedgerPendingRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.pending_records = message.pendingRecords;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisLedgerState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisLedgerState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisLedgerState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.GenesisLedgerState",
+            value: GenesisLedgerState.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisVaultState() {
+    return {
+        totalBurned: [],
+        totalMinted: [],
+        remintCredits: []
+    };
+}
+/**
+ * GenesisVaultState
+ * @name GenesisVaultState
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.GenesisVaultState
+ */
+export const GenesisVaultState = {
+    typeUrl: "/akash.bme.v1.GenesisVaultState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.totalBurned) {
+            Coin.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.totalMinted) {
+            Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.remintCredits) {
+            Coin.encode(v, writer.uint32(26).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 = createBaseGenesisVaultState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.totalBurned.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.totalMinted.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.remintCredits.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisVaultState();
+        message.totalBurned = object.totalBurned?.map(e => Coin.fromPartial(e)) || [];
+        message.totalMinted = object.totalMinted?.map(e => Coin.fromPartial(e)) || [];
+        message.remintCredits = object.remintCredits?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisVaultState();
+        message.totalBurned = object.total_burned?.map(e => Coin.fromAmino(e)) || [];
+        message.totalMinted = object.total_minted?.map(e => Coin.fromAmino(e)) || [];
+        message.remintCredits = object.remint_credits?.map(e => Coin.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.totalBurned) {
+            obj.total_burned = message.totalBurned.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.total_burned = message.totalBurned;
+        }
+        if (message.totalMinted) {
+            obj.total_minted = message.totalMinted.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.total_minted = message.totalMinted;
+        }
+        if (message.remintCredits) {
+            obj.remint_credits = message.remintCredits.map(e => e ? Coin.toAmino(e) : undefined);
+        }
+        else {
+            obj.remint_credits = message.remintCredits;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisVaultState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisVaultState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisVaultState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.GenesisVaultState",
+            value: GenesisVaultState.encode(message).finish()
+        };
+    }
+};
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        state: GenesisVaultState.fromPartial({}),
+        ledger: undefined
+    };
+}
+/**
+ * GenesisState defines the BME module's genesis state
+ * @name GenesisState
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/akash.bme.v1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.state !== undefined) {
+            GenesisVaultState.encode(message.state, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.ledger !== undefined) {
+            GenesisLedgerState.encode(message.ledger, writer.uint32(26).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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.state = GenesisVaultState.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.ledger = GenesisLedgerState.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        message.state = object.state !== undefined && object.state !== null ? GenesisVaultState.fromPartial(object.state) : undefined;
+        message.ledger = object.ledger !== undefined && object.ledger !== null ? GenesisLedgerState.fromPartial(object.ledger) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        if (object.state !== undefined && object.state !== null) {
+            message.state = GenesisVaultState.fromAmino(object.state);
+        }
+        if (object.ledger !== undefined && object.ledger !== null) {
+            message.ledger = GenesisLedgerState.fromAmino(object.ledger);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        obj.state = message.state ? GenesisVaultState.toAmino(message.state) : undefined;
+        obj.ledger = message.ledger ? GenesisLedgerState.toAmino(message.ledger) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};