@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.47

package/esm/sparkdream/vault/v1/tx.js

@@ -0,0 +1,1393 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { VaultSigner } from "./vault_signer";
+import { Any } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../helpers";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * @name MsgUpdateParams
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/sparkdream.vault.v1.MsgUpdateParams",
+    aminoType: "sparkdream/x/vault/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) : Params.toAmino(Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgUpdateParams",
+            value: MsgUpdateParams.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * @name MsgUpdateParamsResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/sparkdream.vault.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: "/sparkdream.vault.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCreateVault() {
+    return {
+        creator: "",
+        signers: [],
+        threshold: BigInt(0),
+        proposalTtl: BigInt(0),
+        label: ""
+    };
+}
+/**
+ * MsgCreateVault creates a vault. Burns params.creation_fee from the creator,
+ * who need not be a signer. Refused while params.creation_enabled is false.
+ * @name MsgCreateVault
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgCreateVault
+ */
+export const MsgCreateVault = {
+    typeUrl: "/sparkdream.vault.v1.MsgCreateVault",
+    aminoType: "sparkdream/x/vault/MsgCreateVault",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        for (const v of message.signers) {
+            VaultSigner.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.threshold !== BigInt(0)) {
+            writer.uint32(24).uint64(message.threshold);
+        }
+        if (message.proposalTtl !== BigInt(0)) {
+            writer.uint32(32).int64(message.proposalTtl);
+        }
+        if (message.label !== "") {
+            writer.uint32(42).string(message.label);
+        }
+        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 = createBaseMsgCreateVault();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.signers.push(VaultSigner.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.threshold = reader.uint64();
+                    break;
+                case 4:
+                    message.proposalTtl = reader.int64();
+                    break;
+                case 5:
+                    message.label = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateVault();
+        message.creator = object.creator ?? "";
+        message.signers = object.signers?.map(e => VaultSigner.fromPartial(e)) || [];
+        message.threshold = object.threshold !== undefined && object.threshold !== null ? BigInt(object.threshold.toString()) : BigInt(0);
+        message.proposalTtl = object.proposalTtl !== undefined && object.proposalTtl !== null ? BigInt(object.proposalTtl.toString()) : BigInt(0);
+        message.label = object.label ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateVault();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        message.signers = object.signers?.map(e => VaultSigner.fromAmino(e)) || [];
+        if (object.threshold !== undefined && object.threshold !== null) {
+            message.threshold = BigInt(object.threshold);
+        }
+        if (object.proposal_ttl !== undefined && object.proposal_ttl !== null) {
+            message.proposalTtl = BigInt(object.proposal_ttl);
+        }
+        if (object.label !== undefined && object.label !== null) {
+            message.label = object.label;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        if (message.signers) {
+            obj.signers = message.signers.map(e => e ? VaultSigner.toAmino(e) : undefined);
+        }
+        else {
+            obj.signers = message.signers;
+        }
+        obj.threshold = message.threshold !== BigInt(0) ? message.threshold?.toString() : undefined;
+        obj.proposal_ttl = message.proposalTtl !== BigInt(0) ? message.proposalTtl?.toString() : undefined;
+        obj.label = message.label === "" ? undefined : message.label;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateVault.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgCreateVault",
+            value: MsgCreateVault.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCreateVault.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateVault.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgCreateVault",
+            value: MsgCreateVault.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCreateVaultResponse() {
+    return {
+        vaultId: BigInt(0),
+        address: ""
+    };
+}
+/**
+ * MsgCreateVaultResponse defines the MsgCreateVaultResponse message.
+ * @name MsgCreateVaultResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgCreateVaultResponse
+ */
+export const MsgCreateVaultResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgCreateVaultResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.vaultId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.vaultId);
+        }
+        if (message.address !== "") {
+            writer.uint32(18).string(message.address);
+        }
+        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 = createBaseMsgCreateVaultResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.vaultId = reader.uint64();
+                    break;
+                case 2:
+                    message.address = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateVaultResponse();
+        message.vaultId = object.vaultId !== undefined && object.vaultId !== null ? BigInt(object.vaultId.toString()) : BigInt(0);
+        message.address = object.address ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateVaultResponse();
+        if (object.vault_id !== undefined && object.vault_id !== null) {
+            message.vaultId = BigInt(object.vault_id);
+        }
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.vault_id = message.vaultId !== BigInt(0) ? message.vaultId?.toString() : undefined;
+        obj.address = message.address === "" ? undefined : message.address;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateVaultResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCreateVaultResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateVaultResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgCreateVaultResponse",
+            value: MsgCreateVaultResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgPropose() {
+    return {
+        signer: "",
+        vaultId: BigInt(0),
+        messages: [],
+        memo: "",
+        execute: false
+    };
+}
+/**
+ * MsgPropose opens a proposal on a vault. Signed by a current signer; records
+ * the proposer's approval and executes at once when `execute` is set and the
+ * threshold is already met (1-of-n vaults). Refused when the proposer has
+ * MaxPendingProposalsPerProposer pending proposals in this vault; a proposal
+ * whose only message is MsgUpdateVault counts against
+ * MaxPendingUpdateProposalsPerProposer instead, so rotation is always possible.
+ * @name MsgPropose
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgPropose
+ */
+export const MsgPropose = {
+    typeUrl: "/sparkdream.vault.v1.MsgPropose",
+    aminoType: "sparkdream/x/vault/MsgPropose",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.vaultId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.vaultId);
+        }
+        for (const v of message.messages) {
+            Any.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.memo !== "") {
+            writer.uint32(34).string(message.memo);
+        }
+        if (message.execute === true) {
+            writer.uint32(40).bool(message.execute);
+        }
+        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 = createBaseMsgPropose();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.vaultId = reader.uint64();
+                    break;
+                case 3:
+                    message.messages.push(Any.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.memo = reader.string();
+                    break;
+                case 5:
+                    message.execute = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgPropose();
+        message.signer = object.signer ?? "";
+        message.vaultId = object.vaultId !== undefined && object.vaultId !== null ? BigInt(object.vaultId.toString()) : BigInt(0);
+        message.messages = object.messages?.map(e => Any.fromPartial(e)) || [];
+        message.memo = object.memo ?? "";
+        message.execute = object.execute ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgPropose();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.vault_id !== undefined && object.vault_id !== null) {
+            message.vaultId = BigInt(object.vault_id);
+        }
+        message.messages = object.messages?.map(e => Cosmos_basev1beta1Msg_FromAmino(e)) || [];
+        if (object.memo !== undefined && object.memo !== null) {
+            message.memo = object.memo;
+        }
+        if (object.execute !== undefined && object.execute !== null) {
+            message.execute = object.execute;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.vault_id = message.vaultId !== BigInt(0) ? message.vaultId?.toString() : undefined;
+        if (message.messages) {
+            obj.messages = message.messages.map(e => e ? Cosmos_basev1beta1Msg_ToAmino(e) : undefined);
+        }
+        else {
+            obj.messages = message.messages;
+        }
+        obj.memo = message.memo === "" ? undefined : message.memo;
+        obj.execute = message.execute === false ? undefined : message.execute;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgPropose.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgPropose",
+            value: MsgPropose.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgPropose.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPropose.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgPropose",
+            value: MsgPropose.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgProposeResponse() {
+    return {
+        proposalId: BigInt(0),
+        executed: false
+    };
+}
+/**
+ * MsgProposeResponse defines the MsgProposeResponse message.
+ * @name MsgProposeResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgProposeResponse
+ */
+export const MsgProposeResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgProposeResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.proposalId);
+        }
+        if (message.executed === true) {
+            writer.uint32(16).bool(message.executed);
+        }
+        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 = createBaseMsgProposeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.proposalId = reader.uint64();
+                    break;
+                case 2:
+                    message.executed = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgProposeResponse();
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        message.executed = object.executed ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgProposeResponse();
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        if (object.executed !== undefined && object.executed !== null) {
+            message.executed = object.executed;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        obj.executed = message.executed === false ? undefined : message.executed;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgProposeResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgProposeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgProposeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgProposeResponse",
+            value: MsgProposeResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgApprove() {
+    return {
+        signer: "",
+        proposalId: BigInt(0),
+        messagesHash: new Uint8Array(),
+        execute: false
+    };
+}
+/**
+ * MsgApprove adds a current signer's approval. messages_hash must equal the
+ * proposal's hash (wallets fill it, so a hardware wallet displays what is
+ * approved). Executes at once when `execute` is set and the threshold is met.
+ * @name MsgApprove
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgApprove
+ */
+export const MsgApprove = {
+    typeUrl: "/sparkdream.vault.v1.MsgApprove",
+    aminoType: "sparkdream/x/vault/MsgApprove",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.proposalId);
+        }
+        if (message.messagesHash.length !== 0) {
+            writer.uint32(26).bytes(message.messagesHash);
+        }
+        if (message.execute === true) {
+            writer.uint32(32).bool(message.execute);
+        }
+        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 = createBaseMsgApprove();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.proposalId = reader.uint64();
+                    break;
+                case 3:
+                    message.messagesHash = reader.bytes();
+                    break;
+                case 4:
+                    message.execute = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgApprove();
+        message.signer = object.signer ?? "";
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        message.messagesHash = object.messagesHash ?? new Uint8Array();
+        message.execute = object.execute ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgApprove();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        if (object.messages_hash !== undefined && object.messages_hash !== null) {
+            message.messagesHash = bytesFromBase64(object.messages_hash);
+        }
+        if (object.execute !== undefined && object.execute !== null) {
+            message.execute = object.execute;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        obj.messages_hash = message.messagesHash ? base64FromBytes(message.messagesHash) : undefined;
+        obj.execute = message.execute === false ? undefined : message.execute;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgApprove.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgApprove",
+            value: MsgApprove.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgApprove.decode(message.value);
+    },
+    toProto(message) {
+        return MsgApprove.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgApprove",
+            value: MsgApprove.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgApproveResponse() {
+    return {
+        executed: false
+    };
+}
+/**
+ * MsgApproveResponse defines the MsgApproveResponse message.
+ * @name MsgApproveResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgApproveResponse
+ */
+export const MsgApproveResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgApproveResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.executed === true) {
+            writer.uint32(8).bool(message.executed);
+        }
+        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 = createBaseMsgApproveResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.executed = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgApproveResponse();
+        message.executed = object.executed ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgApproveResponse();
+        if (object.executed !== undefined && object.executed !== null) {
+            message.executed = object.executed;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.executed = message.executed === false ? undefined : message.executed;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgApproveResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgApproveResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgApproveResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgApproveResponse",
+            value: MsgApproveResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRevokeApproval() {
+    return {
+        signer: "",
+        proposalId: BigInt(0)
+    };
+}
+/**
+ * MsgRevokeApproval withdraws the signer's approval from a PENDING proposal.
+ * @name MsgRevokeApproval
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgRevokeApproval
+ */
+export const MsgRevokeApproval = {
+    typeUrl: "/sparkdream.vault.v1.MsgRevokeApproval",
+    aminoType: "sparkdream/x/vault/MsgRevokeApproval",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.proposalId);
+        }
+        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 = createBaseMsgRevokeApproval();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.proposalId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRevokeApproval();
+        message.signer = object.signer ?? "";
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgRevokeApproval();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeApproval.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgRevokeApproval",
+            value: MsgRevokeApproval.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeApproval.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeApproval.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgRevokeApproval",
+            value: MsgRevokeApproval.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgRevokeApprovalResponse() {
+    return {};
+}
+/**
+ * MsgRevokeApprovalResponse defines the MsgRevokeApprovalResponse message.
+ * @name MsgRevokeApprovalResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgRevokeApprovalResponse
+ */
+export const MsgRevokeApprovalResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgRevokeApprovalResponse",
+    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 = createBaseMsgRevokeApprovalResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRevokeApprovalResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgRevokeApprovalResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgRevokeApprovalResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgRevokeApprovalResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRevokeApprovalResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgRevokeApprovalResponse",
+            value: MsgRevokeApprovalResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgExecute() {
+    return {
+        signer: "",
+        proposalId: BigInt(0)
+    };
+}
+/**
+ * MsgExecute runs a PENDING proposal whose tally meets the threshold. Signed
+ * by any current signer, who pays the gas. A failing inner message reverts the
+ * whole tx and leaves the proposal PENDING for a retry until it expires.
+ * @name MsgExecute
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgExecute
+ */
+export const MsgExecute = {
+    typeUrl: "/sparkdream.vault.v1.MsgExecute",
+    aminoType: "sparkdream/x/vault/MsgExecute",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.proposalId);
+        }
+        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 = createBaseMsgExecute();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.proposalId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgExecute();
+        message.signer = object.signer ?? "";
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgExecute();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgExecute.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgExecute",
+            value: MsgExecute.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgExecute.decode(message.value);
+    },
+    toProto(message) {
+        return MsgExecute.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgExecute",
+            value: MsgExecute.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgExecuteResponse() {
+    return {};
+}
+/**
+ * MsgExecuteResponse defines the MsgExecuteResponse message.
+ * @name MsgExecuteResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgExecuteResponse
+ */
+export const MsgExecuteResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgExecuteResponse",
+    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 = createBaseMsgExecuteResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgExecuteResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgExecuteResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgExecuteResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgExecuteResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgExecuteResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgExecuteResponse",
+            value: MsgExecuteResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCancelProposal() {
+    return {
+        signer: "",
+        proposalId: BigInt(0)
+    };
+}
+/**
+ * MsgCancelProposal cancels a PENDING proposal. Signed by the proposer, or by
+ * the vault address itself through an executed proposal (one of the two vault
+ * messages allowed as an inner message, so a threshold of signers can clear a
+ * proposal nobody wants).
+ * @name MsgCancelProposal
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgCancelProposal
+ */
+export const MsgCancelProposal = {
+    typeUrl: "/sparkdream.vault.v1.MsgCancelProposal",
+    aminoType: "sparkdream/x/vault/MsgCancelProposal",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.proposalId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.proposalId);
+        }
+        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 = createBaseMsgCancelProposal();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.proposalId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCancelProposal();
+        message.signer = object.signer ?? "";
+        message.proposalId = object.proposalId !== undefined && object.proposalId !== null ? BigInt(object.proposalId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCancelProposal();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.proposal_id !== undefined && object.proposal_id !== null) {
+            message.proposalId = BigInt(object.proposal_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.proposal_id = message.proposalId !== BigInt(0) ? message.proposalId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCancelProposal.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgCancelProposal",
+            value: MsgCancelProposal.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgCancelProposal.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCancelProposal.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgCancelProposal",
+            value: MsgCancelProposal.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCancelProposalResponse() {
+    return {};
+}
+/**
+ * MsgCancelProposalResponse defines the MsgCancelProposalResponse message.
+ * @name MsgCancelProposalResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgCancelProposalResponse
+ */
+export const MsgCancelProposalResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgCancelProposalResponse",
+    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 = createBaseMsgCancelProposalResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgCancelProposalResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgCancelProposalResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCancelProposalResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCancelProposalResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCancelProposalResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgCancelProposalResponse",
+            value: MsgCancelProposalResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateVault() {
+    return {
+        vault: "",
+        signers: [],
+        threshold: BigInt(0),
+        proposalTtl: BigInt(0),
+        label: ""
+    };
+}
+/**
+ * MsgUpdateVault replaces the signer set, threshold, proposal TTL and label.
+ * Its signer is the vault address, so it only ever runs as an inner message of
+ * an executed proposal. Bumps config_version and INVALIDATES every other
+ * pending proposal of the vault (the executing one is marked EXECUTED first).
+ * @name MsgUpdateVault
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgUpdateVault
+ */
+export const MsgUpdateVault = {
+    typeUrl: "/sparkdream.vault.v1.MsgUpdateVault",
+    aminoType: "sparkdream/x/vault/MsgUpdateVault",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.vault !== "") {
+            writer.uint32(10).string(message.vault);
+        }
+        for (const v of message.signers) {
+            VaultSigner.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.threshold !== BigInt(0)) {
+            writer.uint32(24).uint64(message.threshold);
+        }
+        if (message.proposalTtl !== BigInt(0)) {
+            writer.uint32(32).int64(message.proposalTtl);
+        }
+        if (message.label !== "") {
+            writer.uint32(42).string(message.label);
+        }
+        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 = createBaseMsgUpdateVault();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.vault = reader.string();
+                    break;
+                case 2:
+                    message.signers.push(VaultSigner.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.threshold = reader.uint64();
+                    break;
+                case 4:
+                    message.proposalTtl = reader.int64();
+                    break;
+                case 5:
+                    message.label = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateVault();
+        message.vault = object.vault ?? "";
+        message.signers = object.signers?.map(e => VaultSigner.fromPartial(e)) || [];
+        message.threshold = object.threshold !== undefined && object.threshold !== null ? BigInt(object.threshold.toString()) : BigInt(0);
+        message.proposalTtl = object.proposalTtl !== undefined && object.proposalTtl !== null ? BigInt(object.proposalTtl.toString()) : BigInt(0);
+        message.label = object.label ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateVault();
+        if (object.vault !== undefined && object.vault !== null) {
+            message.vault = object.vault;
+        }
+        message.signers = object.signers?.map(e => VaultSigner.fromAmino(e)) || [];
+        if (object.threshold !== undefined && object.threshold !== null) {
+            message.threshold = BigInt(object.threshold);
+        }
+        if (object.proposal_ttl !== undefined && object.proposal_ttl !== null) {
+            message.proposalTtl = BigInt(object.proposal_ttl);
+        }
+        if (object.label !== undefined && object.label !== null) {
+            message.label = object.label;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.vault = message.vault === "" ? undefined : message.vault;
+        if (message.signers) {
+            obj.signers = message.signers.map(e => e ? VaultSigner.toAmino(e) : undefined);
+        }
+        else {
+            obj.signers = message.signers;
+        }
+        obj.threshold = message.threshold !== BigInt(0) ? message.threshold?.toString() : undefined;
+        obj.proposal_ttl = message.proposalTtl !== BigInt(0) ? message.proposalTtl?.toString() : undefined;
+        obj.label = message.label === "" ? undefined : message.label;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateVault.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "sparkdream/x/vault/MsgUpdateVault",
+            value: MsgUpdateVault.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateVault.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateVault.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgUpdateVault",
+            value: MsgUpdateVault.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateVaultResponse() {
+    return {};
+}
+/**
+ * MsgUpdateVaultResponse defines the MsgUpdateVaultResponse message.
+ * @name MsgUpdateVaultResponse
+ * @package sparkdream.vault.v1
+ * @see proto type: sparkdream.vault.v1.MsgUpdateVaultResponse
+ */
+export const MsgUpdateVaultResponse = {
+    typeUrl: "/sparkdream.vault.v1.MsgUpdateVaultResponse",
+    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 = createBaseMsgUpdateVaultResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateVaultResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateVaultResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateVaultResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateVaultResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateVaultResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.vault.v1.MsgUpdateVaultResponse",
+            value: MsgUpdateVaultResponse.encode(message).finish()
+        };
+    }
+};
+export const Cosmos_basev1beta1Msg_InterfaceDecoder = (input) => {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const data = Any.decode(reader, reader.uint32());
+    switch (data.typeUrl) {
+        default:
+            return data;
+    }
+};
+export const Cosmos_basev1beta1Msg_FromAmino = (content) => {
+    return Any.fromAmino(content);
+};
+export const Cosmos_basev1beta1Msg_ToAmino = (content) => {
+    return Any.toAmino(content);
+};