@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.30

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

@@ -0,0 +1,864 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { LedgerRecordID } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams defines the message for updating module parameters
+ * @name MsgUpdateParams
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/akash.bme.v1.MsgUpdateParams",
+    aminoType: "akash/bme/v1/MsgUpdateParams",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "akash/bme/v1/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * MsgUpdateParamsResponse is the response type for MsgUpdateParams
+ * @name MsgUpdateParamsResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/akash.bme.v1.MsgUpdateParamsResponse",
+    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 = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgFundVault() {
+    return {
+        authority: "",
+        amount: Coin.fromPartial({}),
+        source: ""
+    };
+}
+/**
+ * MsgFundVault defines the message for funding the BME vault with AKT
+ * This is used to provide an initial volatility buffer
+ * @name MsgFundVault
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgFundVault
+ */
+export const MsgFundVault = {
+    typeUrl: "/akash.bme.v1.MsgFundVault",
+    aminoType: "akash/bme/v1/MsgFundVault",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.source !== "") {
+            writer.uint32(26).string(message.source);
+        }
+        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 = createBaseMsgFundVault();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.source = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgFundVault();
+        message.authority = object.authority ?? "";
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        message.source = object.source ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgFundVault();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        if (object.source !== undefined && object.source !== null) {
+            message.source = object.source;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        obj.source = message.source === "" ? undefined : message.source;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgFundVault.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "akash/bme/v1/MsgFundVault",
+            value: MsgFundVault.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgFundVault.decode(message.value);
+    },
+    toProto(message) {
+        return MsgFundVault.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgFundVault",
+            value: MsgFundVault.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgFundVaultResponse() {
+    return {};
+}
+/**
+ * MsgFundVaultResponse is the response type for MsgFundVault
+ * @name MsgFundVaultResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgFundVaultResponse
+ */
+export const MsgFundVaultResponse = {
+    typeUrl: "/akash.bme.v1.MsgFundVaultResponse",
+    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 = createBaseMsgFundVaultResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgFundVaultResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgFundVaultResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgFundVaultResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgFundVaultResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgFundVaultResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgFundVaultResponse",
+            value: MsgFundVaultResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgBurnMint() {
+    return {
+        owner: "",
+        to: "",
+        coinsToBurn: Coin.fromPartial({}),
+        denomToMint: ""
+    };
+}
+/**
+ * MsgBurnMint defines the message for burning one token to mint another
+ * Allows burning AKT to mint ACT, or burning unused ACT back to AKT
+ * @name MsgBurnMint
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgBurnMint
+ */
+export const MsgBurnMint = {
+    typeUrl: "/akash.bme.v1.MsgBurnMint",
+    aminoType: "akash/bme/v1/MsgBurnMint",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.to !== "") {
+            writer.uint32(18).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.denomToMint !== "") {
+            writer.uint32(34).string(message.denomToMint);
+        }
+        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 = createBaseMsgBurnMint();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.to = reader.string();
+                    break;
+                case 3:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.denomToMint = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurnMint();
+        message.owner = object.owner ?? "";
+        message.to = object.to ?? "";
+        message.coinsToBurn = object.coinsToBurn !== undefined && object.coinsToBurn !== null ? Coin.fromPartial(object.coinsToBurn) : undefined;
+        message.denomToMint = object.denomToMint ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurnMint();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.to !== undefined && object.to !== null) {
+            message.to = object.to;
+        }
+        if (object.coins_to_burn !== undefined && object.coins_to_burn !== null) {
+            message.coinsToBurn = Coin.fromAmino(object.coins_to_burn);
+        }
+        if (object.denom_to_mint !== undefined && object.denom_to_mint !== null) {
+            message.denomToMint = object.denom_to_mint;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.to = message.to ?? "";
+        obj.coins_to_burn = message.coinsToBurn ? Coin.toAmino(message.coinsToBurn) : Coin.toAmino(Coin.fromPartial({}));
+        obj.denom_to_mint = message.denomToMint ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnMint.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "akash/bme/v1/MsgBurnMint",
+            value: MsgBurnMint.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgBurnMint.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnMint.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgBurnMint",
+            value: MsgBurnMint.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgMintACT() {
+    return {
+        owner: "",
+        to: "",
+        coinsToBurn: Coin.fromPartial({})
+    };
+}
+/**
+ * MsgMintACT defines the message for burning one token to mint another
+ * Allows burning AKT to mint ACT, or burning unused ACT back to AKT
+ * @name MsgMintACT
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgMintACT
+ */
+export const MsgMintACT = {
+    typeUrl: "/akash.bme.v1.MsgMintACT",
+    aminoType: "akash/bme/v1/MsgMintACT",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.to !== "") {
+            writer.uint32(18).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, 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 = createBaseMsgMintACT();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.to = reader.string();
+                    break;
+                case 3:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgMintACT();
+        message.owner = object.owner ?? "";
+        message.to = object.to ?? "";
+        message.coinsToBurn = object.coinsToBurn !== undefined && object.coinsToBurn !== null ? Coin.fromPartial(object.coinsToBurn) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgMintACT();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.to !== undefined && object.to !== null) {
+            message.to = object.to;
+        }
+        if (object.coins_to_burn !== undefined && object.coins_to_burn !== null) {
+            message.coinsToBurn = Coin.fromAmino(object.coins_to_burn);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.to = message.to ?? "";
+        obj.coins_to_burn = message.coinsToBurn ? Coin.toAmino(message.coinsToBurn) : Coin.toAmino(Coin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgMintACT.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "akash/bme/v1/MsgMintACT",
+            value: MsgMintACT.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgMintACT.decode(message.value);
+    },
+    toProto(message) {
+        return MsgMintACT.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgMintACT",
+            value: MsgMintACT.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgBurnACT() {
+    return {
+        owner: "",
+        to: "",
+        coinsToBurn: Coin.fromPartial({})
+    };
+}
+/**
+ * MsgMintACT defines the message for burning one token to mint another
+ * Allows burning AKT to mint ACT, or burning unused ACT back to AKT
+ * @name MsgBurnACT
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgBurnACT
+ */
+export const MsgBurnACT = {
+    typeUrl: "/akash.bme.v1.MsgBurnACT",
+    aminoType: "akash/bme/v1/MsgBurnACT",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.to !== "") {
+            writer.uint32(18).string(message.to);
+        }
+        if (message.coinsToBurn !== undefined) {
+            Coin.encode(message.coinsToBurn, 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 = createBaseMsgBurnACT();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.to = reader.string();
+                    break;
+                case 3:
+                    message.coinsToBurn = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurnACT();
+        message.owner = object.owner ?? "";
+        message.to = object.to ?? "";
+        message.coinsToBurn = object.coinsToBurn !== undefined && object.coinsToBurn !== null ? Coin.fromPartial(object.coinsToBurn) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurnACT();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.to !== undefined && object.to !== null) {
+            message.to = object.to;
+        }
+        if (object.coins_to_burn !== undefined && object.coins_to_burn !== null) {
+            message.coinsToBurn = Coin.fromAmino(object.coins_to_burn);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner ?? "";
+        obj.to = message.to ?? "";
+        obj.coins_to_burn = message.coinsToBurn ? Coin.toAmino(message.coinsToBurn) : Coin.toAmino(Coin.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnACT.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "akash/bme/v1/MsgBurnACT",
+            value: MsgBurnACT.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgBurnACT.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnACT.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgBurnACT",
+            value: MsgBurnACT.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgBurnMintResponse() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        status: 0
+    };
+}
+/**
+ * MsgBurnMintResponse is the response type for MsgBurnMint
+ * @name MsgBurnMintResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgBurnMintResponse
+ */
+export const MsgBurnMintResponse = {
+    typeUrl: "/akash.bme.v1.MsgBurnMintResponse",
+    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);
+        }
+        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 = createBaseMsgBurnMintResponse();
+        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;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurnMintResponse();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.status = object.status ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurnMintResponse();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        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;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnMintResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgBurnMintResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnMintResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgBurnMintResponse",
+            value: MsgBurnMintResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgMintACTResponse() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        status: 0
+    };
+}
+/**
+ * MsgBurnMintResponse is the response type for MsgBurnMint
+ * @name MsgMintACTResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgMintACTResponse
+ */
+export const MsgMintACTResponse = {
+    typeUrl: "/akash.bme.v1.MsgMintACTResponse",
+    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);
+        }
+        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 = createBaseMsgMintACTResponse();
+        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;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgMintACTResponse();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.status = object.status ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgMintACTResponse();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        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;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgMintACTResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgMintACTResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgMintACTResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgMintACTResponse",
+            value: MsgMintACTResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgBurnACTResponse() {
+    return {
+        id: LedgerRecordID.fromPartial({}),
+        status: 0
+    };
+}
+/**
+ * MsgBurnMintResponse is the response type for MsgBurnMint
+ * @name MsgBurnACTResponse
+ * @package akash.bme.v1
+ * @see proto type: akash.bme.v1.MsgBurnACTResponse
+ */
+export const MsgBurnACTResponse = {
+    typeUrl: "/akash.bme.v1.MsgBurnACTResponse",
+    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);
+        }
+        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 = createBaseMsgBurnACTResponse();
+        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;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBurnACTResponse();
+        message.id = object.id !== undefined && object.id !== null ? LedgerRecordID.fromPartial(object.id) : undefined;
+        message.status = object.status ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgBurnACTResponse();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = LedgerRecordID.fromAmino(object.id);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        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;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgBurnACTResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgBurnACTResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBurnACTResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.bme.v1.MsgBurnACTResponse",
+            value: MsgBurnACTResponse.encode(message).finish()
+        };
+    }
+};