@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.47

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,2 @@
+export { configureNestedAminoConverter } from "../../../nested-amino";
+export declare const AminoConverter: Record<string, import("../../../chain-amino").ChainAminoConverter>;

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

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = exports.configureNestedAminoConverter = void 0;
+//@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's generated converters (and the per-message overrides that
+// used to patch them) disagree with the chain's aminojson on empty lists,
+// empty bytes, Dec strings, oneofs and non-nullable messages, and went stale
+// whenever a proto changed. Every Msg of x/vault is converted by the
+// schema-driven engine in chain-amino.ts instead, which renders amino JSON
+// from the protobuf bytes exactly as the chain does.
+//
+// MAINTENANCE: none per message. The schema (amino-schema.ts, regenerated from
+// the chain on every proto sync) lists every Msg; __tests__/amino-golden.test.ts
+// checks them all against the chain's encoder.
+const tx = __importStar(require("./tx"));
+const chain_amino_1 = require("../../../chain-amino");
+var nested_amino_1 = require("../../../nested-amino");
+Object.defineProperty(exports, "configureNestedAminoConverter", { enumerable: true, get: function () { return nested_amino_1.configureNestedAminoConverter; } });
+exports.AminoConverter = (0, chain_amino_1.chainAminoConverters)("sparkdream.vault.v1", tx);