@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.46

package/sparkdream/vault/v1/query.lcd.d.ts

@@ -0,0 +1,18 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryVaultByAddressRequest, QueryVaultByAddressResponse, QueryVaultsBySignerRequest, QueryVaultsBySignerResponse, QueryProposalsByVaultRequest, QueryProposalsByVaultResponse, QueryTallyRequest, QueryTallyResponse, QueryGetVaultRequest, QueryGetVaultResponse, QueryAllVaultRequest, QueryAllVaultResponse, QueryGetVaultProposalRequest, QueryGetVaultProposalResponse, QueryAllVaultProposalRequest, QueryAllVaultProposalResponse, QueryProposalsByProposerRequest, QueryProposalsByProposerResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    vaultByAddress: (params: QueryVaultByAddressRequest) => Promise<QueryVaultByAddressResponse>;
+    vaultsBySigner: (params: QueryVaultsBySignerRequest) => Promise<QueryVaultsBySignerResponse>;
+    proposalsByVault: (params: QueryProposalsByVaultRequest) => Promise<QueryProposalsByVaultResponse>;
+    tally: (params: QueryTallyRequest) => Promise<QueryTallyResponse>;
+    getVault: (params: QueryGetVaultRequest) => Promise<QueryGetVaultResponse>;
+    listVault: (params?: QueryAllVaultRequest) => Promise<QueryAllVaultResponse>;
+    getVaultProposal: (params: QueryGetVaultProposalRequest) => Promise<QueryGetVaultProposalResponse>;
+    listVaultProposal: (params?: QueryAllVaultProposalRequest) => Promise<QueryAllVaultProposalResponse>;
+    proposalsByProposer: (params: QueryProposalsByProposerRequest) => Promise<QueryProposalsByProposerResponse>;
+}

package/sparkdream/vault/v1/query.lcd.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/vault/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* VaultByAddress Queries a list of VaultByAddress items. */
+    vaultByAddress = async (params) => {
+        const endpoint = `sparkdream/vault/v1/vault_by_address/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+    /* VaultsBySigner Queries a list of VaultsBySigner items. */
+    vaultsBySigner = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/vault/v1/vaults_by_signer/${params.address}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ProposalsByVault Queries a list of ProposalsByVault items. */
+    proposalsByVault = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.status !== "undefined") {
+            options.params.status = params.status;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/vault/v1/proposals_by_vault/${params.vaultId}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Tally Queries a list of Tally items. */
+    tally = async (params) => {
+        const endpoint = `sparkdream/vault/v1/tally/${params.proposalId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListVault Queries a list of Vault items. */
+    getVault = async (params) => {
+        const endpoint = `sparkdream/vault/v1/vault/${params.vaultId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListVault defines the ListVault RPC. */
+    listVault = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/vault/v1/vault`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ListVaultProposal Queries a list of VaultProposal items. */
+    getVaultProposal = async (params) => {
+        const endpoint = `sparkdream/vault/v1/vault_proposal/${params.proposalId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListVaultProposal defines the ListVaultProposal RPC. */
+    listVaultProposal = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/vault/v1/vault_proposal`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ProposalsByProposer lists the proposals a signer opened across every
+     vault, so a client can show how much of the per-proposer pending cap is
+     used. */
+    proposalsByProposer = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.status !== "undefined") {
+            options.params.status = params.status;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/vault/v1/proposals_by_proposer/${params.proposer}`;
+        return await this.req.get(endpoint, options);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/vault/v1/query.rpc.Query.d.ts

@@ -0,0 +1,56 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryVaultByAddressRequest, QueryVaultByAddressResponse, QueryVaultsBySignerRequest, QueryVaultsBySignerResponse, QueryProposalsByVaultRequest, QueryProposalsByVaultResponse, QueryTallyRequest, QueryTallyResponse, QueryGetVaultRequest, QueryGetVaultResponse, QueryAllVaultRequest, QueryAllVaultResponse, QueryGetVaultProposalRequest, QueryGetVaultProposalResponse, QueryAllVaultProposalRequest, QueryAllVaultProposalResponse, QueryProposalsByProposerRequest, QueryProposalsByProposerResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** VaultByAddress Queries a list of VaultByAddress items. */
+    vaultByAddress(request: QueryVaultByAddressRequest): Promise<QueryVaultByAddressResponse>;
+    /** VaultsBySigner Queries a list of VaultsBySigner items. */
+    vaultsBySigner(request: QueryVaultsBySignerRequest): Promise<QueryVaultsBySignerResponse>;
+    /** ProposalsByVault Queries a list of ProposalsByVault items. */
+    proposalsByVault(request: QueryProposalsByVaultRequest): Promise<QueryProposalsByVaultResponse>;
+    /** Tally Queries a list of Tally items. */
+    tally(request: QueryTallyRequest): Promise<QueryTallyResponse>;
+    /** ListVault Queries a list of Vault items. */
+    getVault(request: QueryGetVaultRequest): Promise<QueryGetVaultResponse>;
+    /** ListVault defines the ListVault RPC. */
+    listVault(request?: QueryAllVaultRequest): Promise<QueryAllVaultResponse>;
+    /** ListVaultProposal Queries a list of VaultProposal items. */
+    getVaultProposal(request: QueryGetVaultProposalRequest): Promise<QueryGetVaultProposalResponse>;
+    /** ListVaultProposal defines the ListVaultProposal RPC. */
+    listVaultProposal(request?: QueryAllVaultProposalRequest): Promise<QueryAllVaultProposalResponse>;
+    /**
+     * ProposalsByProposer lists the proposals a signer opened across every
+     * vault, so a client can show how much of the per-proposer pending cap is
+     * used.
+     */
+    proposalsByProposer(request: QueryProposalsByProposerRequest): Promise<QueryProposalsByProposerResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    vaultByAddress: (request: QueryVaultByAddressRequest) => Promise<QueryVaultByAddressResponse>;
+    vaultsBySigner: (request: QueryVaultsBySignerRequest) => Promise<QueryVaultsBySignerResponse>;
+    proposalsByVault: (request: QueryProposalsByVaultRequest) => Promise<QueryProposalsByVaultResponse>;
+    tally: (request: QueryTallyRequest) => Promise<QueryTallyResponse>;
+    getVault: (request: QueryGetVaultRequest) => Promise<QueryGetVaultResponse>;
+    listVault: (request?: QueryAllVaultRequest) => Promise<QueryAllVaultResponse>;
+    getVaultProposal: (request: QueryGetVaultProposalRequest) => Promise<QueryGetVaultProposalResponse>;
+    listVaultProposal: (request?: QueryAllVaultProposalRequest) => Promise<QueryAllVaultProposalResponse>;
+    proposalsByProposer: (request: QueryProposalsByProposerRequest) => Promise<QueryProposalsByProposerResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    vaultByAddress(request: QueryVaultByAddressRequest): Promise<QueryVaultByAddressResponse>;
+    vaultsBySigner(request: QueryVaultsBySignerRequest): Promise<QueryVaultsBySignerResponse>;
+    proposalsByVault(request: QueryProposalsByVaultRequest): Promise<QueryProposalsByVaultResponse>;
+    tally(request: QueryTallyRequest): Promise<QueryTallyResponse>;
+    getVault(request: QueryGetVaultRequest): Promise<QueryGetVaultResponse>;
+    listVault(request?: QueryAllVaultRequest): Promise<QueryAllVaultResponse>;
+    getVaultProposal(request: QueryGetVaultProposalRequest): Promise<QueryGetVaultProposalResponse>;
+    listVaultProposal(request?: QueryAllVaultProposalRequest): Promise<QueryAllVaultProposalResponse>;
+    proposalsByProposer(request: QueryProposalsByProposerRequest): Promise<QueryProposalsByProposerResponse>;
+};

package/sparkdream/vault/v1/query.rpc.Query.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* VaultByAddress Queries a list of VaultByAddress items. */
+    vaultByAddress = async (request) => {
+        const data = query_1.QueryVaultByAddressRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "VaultByAddress", data);
+        return promise.then(data => query_1.QueryVaultByAddressResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* VaultsBySigner Queries a list of VaultsBySigner items. */
+    vaultsBySigner = async (request) => {
+        const data = query_1.QueryVaultsBySignerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "VaultsBySigner", data);
+        return promise.then(data => query_1.QueryVaultsBySignerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ProposalsByVault Queries a list of ProposalsByVault items. */
+    proposalsByVault = async (request) => {
+        const data = query_1.QueryProposalsByVaultRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "ProposalsByVault", data);
+        return promise.then(data => query_1.QueryProposalsByVaultResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Tally Queries a list of Tally items. */
+    tally = async (request) => {
+        const data = query_1.QueryTallyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "Tally", data);
+        return promise.then(data => query_1.QueryTallyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListVault Queries a list of Vault items. */
+    getVault = async (request) => {
+        const data = query_1.QueryGetVaultRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "GetVault", data);
+        return promise.then(data => query_1.QueryGetVaultResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListVault defines the ListVault RPC. */
+    listVault = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryAllVaultRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "ListVault", data);
+        return promise.then(data => query_1.QueryAllVaultResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListVaultProposal Queries a list of VaultProposal items. */
+    getVaultProposal = async (request) => {
+        const data = query_1.QueryGetVaultProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "GetVaultProposal", data);
+        return promise.then(data => query_1.QueryGetVaultProposalResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListVaultProposal defines the ListVaultProposal RPC. */
+    listVaultProposal = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryAllVaultProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "ListVaultProposal", data);
+        return promise.then(data => query_1.QueryAllVaultProposalResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ProposalsByProposer lists the proposals a signer opened across every
+     vault, so a client can show how much of the per-proposer pending cap is
+     used. */
+    proposalsByProposer = async (request) => {
+        const data = query_1.QueryProposalsByProposerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.vault.v1.Query", "ProposalsByProposer", data);
+        return promise.then(data => query_1.QueryProposalsByProposerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        vaultByAddress(request) {
+            return queryService.vaultByAddress(request);
+        },
+        vaultsBySigner(request) {
+            return queryService.vaultsBySigner(request);
+        },
+        proposalsByVault(request) {
+            return queryService.proposalsByVault(request);
+        },
+        tally(request) {
+            return queryService.tally(request);
+        },
+        getVault(request) {
+            return queryService.getVault(request);
+        },
+        listVault(request) {
+            return queryService.listVault(request);
+        },
+        getVaultProposal(request) {
+            return queryService.getVaultProposal(request);
+        },
+        listVaultProposal(request) {
+            return queryService.listVaultProposal(request);
+        },
+        proposalsByProposer(request) {
+            return queryService.proposalsByProposer(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/sparkdream/vault/v1/tx.amino.d.ts

@@ -0,0 +1,44 @@
+import { MsgUpdateParams, MsgCreateVault, MsgApprove, MsgRevokeApproval, MsgExecute, MsgCancelProposal, MsgUpdateVault } from "./tx";
+export { configureNestedAminoConverter } from "../../../nested-amino";
+export declare const AminoConverter: {
+    "/sparkdream.vault.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.vault.v1.MsgCreateVault": {
+        aminoType: string;
+        toAmino(message: any): any;
+        fromAmino: (object: import("./tx").MsgCreateVaultAmino) => MsgCreateVault;
+    };
+    "/sparkdream.vault.v1.MsgPropose": {
+        aminoType: string;
+        toAmino(message: any): any;
+        fromAmino(object: any): any;
+    };
+    "/sparkdream.vault.v1.MsgApprove": {
+        aminoType: string;
+        toAmino: (message: MsgApprove) => import("./tx").MsgApproveAmino;
+        fromAmino: (object: import("./tx").MsgApproveAmino) => MsgApprove;
+    };
+    "/sparkdream.vault.v1.MsgRevokeApproval": {
+        aminoType: string;
+        toAmino: (message: MsgRevokeApproval) => import("./tx").MsgRevokeApprovalAmino;
+        fromAmino: (object: import("./tx").MsgRevokeApprovalAmino) => MsgRevokeApproval;
+    };
+    "/sparkdream.vault.v1.MsgExecute": {
+        aminoType: string;
+        toAmino: (message: MsgExecute) => import("./tx").MsgExecuteAmino;
+        fromAmino: (object: import("./tx").MsgExecuteAmino) => MsgExecute;
+    };
+    "/sparkdream.vault.v1.MsgCancelProposal": {
+        aminoType: string;
+        toAmino: (message: MsgCancelProposal) => import("./tx").MsgCancelProposalAmino;
+        fromAmino: (object: import("./tx").MsgCancelProposalAmino) => MsgCancelProposal;
+    };
+    "/sparkdream.vault.v1.MsgUpdateVault": {
+        aminoType: string;
+        toAmino(message: any): any;
+        fromAmino: (object: import("./tx").MsgUpdateVaultAmino) => MsgUpdateVault;
+    };
+};

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

@@ -0,0 +1,115 @@
+"use strict";
+//@ts-nocheck
+// HAND-WRITTEN OVERRIDE — overlaid on top of the Telescope-generated tx.amino.ts
+// by scripts/codegen.ts after each codegen run. Do not let codegen wipe this.
+//
+// Why: Telescope emits a flat AminoConverter that hands each entry's toAmino
+// straight through to the message's auto-generated toAmino. For
+// MsgPropose (`repeated google.protobuf.Any messages`), the auto-generated
+// toAmino calls Any.toAmino, which just attaches the raw Uint8Array bytes — Ledger rejects
+// the resulting JSON ("Dictionaries are not sorted") and the chain produces
+// different sign bytes ("signature verification failed").
+//
+// This override delegates the inner Any conversion to a consumer-supplied
+// proto registry + AminoTypes via `configureNestedAminoConverter`.
+//
+// MsgCreateVault / MsgUpdateVault (and MsgPropose's `messages`) additionally
+// omit an empty list to match aminojson's omitempty, rather than signing `[]`
+// (see the rep override for the full story).
+//
+// The rest of the converters are unchanged.
+//
+// MAINTENANCE: this map REPLACES the generated one wholesale, so it must list
+// every message in tx.proto. A message added to the proto but not added here
+// ends up with no amino converter at all, and amino (Ledger) signing for it
+// fails at runtime. When syncing protos, diff the message list in
+// protos/sparkdream/vault/v1/tx.proto against the keys below.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = exports.configureNestedAminoConverter = void 0;
+const tx_1 = require("./tx");
+const vault_signer_1 = require("./vault_signer");
+const nested_amino_1 = require("../../../nested-amino");
+var nested_amino_2 = require("../../../nested-amino");
+Object.defineProperty(exports, "configureNestedAminoConverter", { enumerable: true, get: function () { return nested_amino_2.configureNestedAminoConverter; } });
+exports.AminoConverter = {
+    "/sparkdream.vault.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/vault/MsgUpdateParams",
+        toAmino: tx_1.MsgUpdateParams.toAmino,
+        fromAmino: tx_1.MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgCreateVault": {
+        aminoType: "sparkdream/x/vault/MsgCreateVault",
+        toAmino(message) {
+            const obj = {};
+            obj.creator = message.creator === "" ? undefined : message.creator;
+            obj.signers = (message.signers?.length ?? 0) > 0
+                ? message.signers.map((e) => e ? vault_signer_1.VaultSigner.toAmino(e) : undefined)
+                : undefined;
+            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;
+        },
+        fromAmino: tx_1.MsgCreateVault.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgPropose": {
+        aminoType: "sparkdream/x/vault/MsgPropose",
+        toAmino(message) {
+            const obj = {};
+            obj.signer = message.signer === "" ? undefined : message.signer;
+            obj.vault_id = message.vaultId !== BigInt(0) ? message.vaultId?.toString() : undefined;
+            // Mirror aminojson's omitempty default for repeated fields: omit when
+            // empty rather than emitting `[]`.
+            obj.messages = (message.messages?.length ?? 0) > 0
+                ? message.messages.map((a) => (0, nested_amino_1.anyToAmino)(a))
+                : undefined;
+            obj.memo = message.memo === "" ? undefined : message.memo;
+            obj.execute = message.execute === false ? undefined : message.execute;
+            return obj;
+        },
+        fromAmino(object) {
+            return {
+                signer: object.signer ?? "",
+                vaultId: object.vault_id !== undefined && object.vault_id !== null ? BigInt(object.vault_id) : BigInt(0),
+                messages: (object.messages ?? []).map((e) => (0, nested_amino_1.aminoToAny)(e)),
+                memo: object.memo ?? "",
+                execute: object.execute ?? false,
+            };
+        },
+    },
+    "/sparkdream.vault.v1.MsgApprove": {
+        aminoType: "sparkdream/x/vault/MsgApprove",
+        toAmino: tx_1.MsgApprove.toAmino,
+        fromAmino: tx_1.MsgApprove.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgRevokeApproval": {
+        aminoType: "sparkdream/x/vault/MsgRevokeApproval",
+        toAmino: tx_1.MsgRevokeApproval.toAmino,
+        fromAmino: tx_1.MsgRevokeApproval.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgExecute": {
+        aminoType: "sparkdream/x/vault/MsgExecute",
+        toAmino: tx_1.MsgExecute.toAmino,
+        fromAmino: tx_1.MsgExecute.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgCancelProposal": {
+        aminoType: "sparkdream/x/vault/MsgCancelProposal",
+        toAmino: tx_1.MsgCancelProposal.toAmino,
+        fromAmino: tx_1.MsgCancelProposal.fromAmino
+    },
+    "/sparkdream.vault.v1.MsgUpdateVault": {
+        aminoType: "sparkdream/x/vault/MsgUpdateVault",
+        toAmino(message) {
+            const obj = {};
+            obj.vault = message.vault === "" ? undefined : message.vault;
+            obj.signers = (message.signers?.length ?? 0) > 0
+                ? message.signers.map((e) => e ? vault_signer_1.VaultSigner.toAmino(e) : undefined)
+                : undefined;
+            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;
+        },
+        fromAmino: tx_1.MsgUpdateVault.fromAmino
+    }
+};