@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

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

@@ -0,0 +1,25 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryShieldedOpRequest, QueryShieldedOpResponse, QueryShieldedOpsRequest, QueryShieldedOpsResponse, QueryModuleBalanceRequest, QueryModuleBalanceResponse, QueryNullifierUsedRequest, QueryNullifierUsedResponse, QueryDayFundingRequest, QueryDayFundingResponse, QueryShieldEpochRequest, QueryShieldEpochResponse, QueryPendingOpsRequest, QueryPendingOpsResponse, QueryPendingOpCountRequest, QueryPendingOpCountResponse, QueryTLEMasterPublicKeyRequest, QueryTLEMasterPublicKeyResponse, QueryTLEKeySetRequest, QueryTLEKeySetResponse, QueryVerificationKeyRequest, QueryVerificationKeyResponse, QueryTLEMissCountRequest, QueryTLEMissCountResponse, QueryDecryptionSharesRequest, QueryDecryptionSharesResponse, QueryIdentityRateLimitRequest, QueryIdentityRateLimitResponse, QueryDKGStateRequest, QueryDKGStateResponse, QueryDKGContributionsRequest, QueryDKGContributionsResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    shieldedOp: (params: QueryShieldedOpRequest) => Promise<QueryShieldedOpResponse>;
+    shieldedOps: (params?: QueryShieldedOpsRequest) => Promise<QueryShieldedOpsResponse>;
+    moduleBalance: (_params?: QueryModuleBalanceRequest) => Promise<QueryModuleBalanceResponse>;
+    nullifierUsed: (params: QueryNullifierUsedRequest) => Promise<QueryNullifierUsedResponse>;
+    dayFunding: (params: QueryDayFundingRequest) => Promise<QueryDayFundingResponse>;
+    shieldEpoch: (_params?: QueryShieldEpochRequest) => Promise<QueryShieldEpochResponse>;
+    pendingOps: (params: QueryPendingOpsRequest) => Promise<QueryPendingOpsResponse>;
+    pendingOpCount: (_params?: QueryPendingOpCountRequest) => Promise<QueryPendingOpCountResponse>;
+    tLEMasterPublicKey: (_params?: QueryTLEMasterPublicKeyRequest) => Promise<QueryTLEMasterPublicKeyResponse>;
+    tLEKeySet: (_params?: QueryTLEKeySetRequest) => Promise<QueryTLEKeySetResponse>;
+    verificationKey: (params: QueryVerificationKeyRequest) => Promise<QueryVerificationKeyResponse>;
+    tLEMissCount: (params: QueryTLEMissCountRequest) => Promise<QueryTLEMissCountResponse>;
+    decryptionShares: (params: QueryDecryptionSharesRequest) => Promise<QueryDecryptionSharesResponse>;
+    identityRateLimit: (params: QueryIdentityRateLimitRequest) => Promise<QueryIdentityRateLimitResponse>;
+    dKGState: (_params?: QueryDKGStateRequest) => Promise<QueryDKGStateResponse>;
+    dKGContributions: (_params?: QueryDKGContributionsRequest) => Promise<QueryDKGContributionsResponse>;
+}

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

@@ -0,0 +1,114 @@
+"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;
+    }
+    /* Params returns module parameters. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* ShieldedOp returns the registration for a specific message type. */
+    shieldedOp = async (params) => {
+        const endpoint = `sparkdream/shield/v1/shielded_op/${params.messageTypeUrl}`;
+        return await this.req.get(endpoint);
+    };
+    /* ShieldedOps returns all registered shielded operations. */
+    shieldedOps = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/shield/v1/shielded_ops`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ModuleBalance returns the shield module account's current balance. */
+    moduleBalance = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/module_balance`;
+        return await this.req.get(endpoint);
+    };
+    /* NullifierUsed checks if a nullifier has been used in a given domain+scope. */
+    nullifierUsed = async (params) => {
+        const endpoint = `sparkdream/shield/v1/nullifier_used/${params.domain}/${params.scope}/${params.nullifierHex}`;
+        return await this.req.get(endpoint);
+    };
+    /* DayFunding returns the amount funded from community pool for a given day. */
+    dayFunding = async (params) => {
+        const endpoint = `sparkdream/shield/v1/day_funding/${params.day}`;
+        return await this.req.get(endpoint);
+    };
+    /* ShieldEpoch returns the current shield epoch state. */
+    shieldEpoch = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/shield_epoch`;
+        return await this.req.get(endpoint);
+    };
+    /* PendingOps returns pending shielded operations (optionally filtered by epoch). */
+    pendingOps = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.epoch !== "undefined") {
+            options.params.epoch = params.epoch;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/shield/v1/pending_ops`;
+        return await this.req.get(endpoint, options);
+    };
+    /* PendingOpCount returns the count of pending operations. */
+    pendingOpCount = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/pending_op_count`;
+        return await this.req.get(endpoint);
+    };
+    /* TLEMasterPublicKey returns the TLE master public key (for client encryption). */
+    tLEMasterPublicKey = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/tle_master_public_key`;
+        return await this.req.get(endpoint);
+    };
+    /* TLEKeySet returns the full TLE key set (master key + validator shares). */
+    tLEKeySet = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/tle_key_set`;
+        return await this.req.get(endpoint);
+    };
+    /* VerificationKey returns a ZK verification key by circuit ID. */
+    verificationKey = async (params) => {
+        const endpoint = `sparkdream/shield/v1/verification_key/${params.circuitId}`;
+        return await this.req.get(endpoint);
+    };
+    /* TLEMissCount returns a validator's current TLE miss count. */
+    tLEMissCount = async (params) => {
+        const endpoint = `sparkdream/shield/v1/tle_miss_count/${params.validatorAddress}`;
+        return await this.req.get(endpoint);
+    };
+    /* DecryptionShares returns the decryption shares submitted for a given epoch. */
+    decryptionShares = async (params) => {
+        const endpoint = `sparkdream/shield/v1/decryption_shares/${params.epoch}`;
+        return await this.req.get(endpoint);
+    };
+    /* IdentityRateLimit returns the remaining rate limit for a given rate-limit nullifier. */
+    identityRateLimit = async (params) => {
+        const endpoint = `sparkdream/shield/v1/identity_rate_limit/${params.rateLimitNullifierHex}`;
+        return await this.req.get(endpoint);
+    };
+    /* DKGState returns the current DKG ceremony state. */
+    dKGState = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/dkg_state`;
+        return await this.req.get(endpoint);
+    };
+    /* DKGContributions returns all DKG contributions for the current round. */
+    dKGContributions = async (_params = {}) => {
+        const endpoint = `sparkdream/shield/v1/dkg_contributions`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

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

@@ -0,0 +1,80 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryShieldedOpRequest, QueryShieldedOpResponse, QueryShieldedOpsRequest, QueryShieldedOpsResponse, QueryModuleBalanceRequest, QueryModuleBalanceResponse, QueryNullifierUsedRequest, QueryNullifierUsedResponse, QueryDayFundingRequest, QueryDayFundingResponse, QueryShieldEpochRequest, QueryShieldEpochResponse, QueryPendingOpsRequest, QueryPendingOpsResponse, QueryPendingOpCountRequest, QueryPendingOpCountResponse, QueryTLEMasterPublicKeyRequest, QueryTLEMasterPublicKeyResponse, QueryTLEKeySetRequest, QueryTLEKeySetResponse, QueryVerificationKeyRequest, QueryVerificationKeyResponse, QueryTLEMissCountRequest, QueryTLEMissCountResponse, QueryDecryptionSharesRequest, QueryDecryptionSharesResponse, QueryIdentityRateLimitRequest, QueryIdentityRateLimitResponse, QueryDKGStateRequest, QueryDKGStateResponse, QueryDKGContributionsRequest, QueryDKGContributionsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Params returns module parameters. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** ShieldedOp returns the registration for a specific message type. */
+    shieldedOp(request: QueryShieldedOpRequest): Promise<QueryShieldedOpResponse>;
+    /** ShieldedOps returns all registered shielded operations. */
+    shieldedOps(request?: QueryShieldedOpsRequest): Promise<QueryShieldedOpsResponse>;
+    /** ModuleBalance returns the shield module account's current balance. */
+    moduleBalance(request?: QueryModuleBalanceRequest): Promise<QueryModuleBalanceResponse>;
+    /** NullifierUsed checks if a nullifier has been used in a given domain+scope. */
+    nullifierUsed(request: QueryNullifierUsedRequest): Promise<QueryNullifierUsedResponse>;
+    /** DayFunding returns the amount funded from community pool for a given day. */
+    dayFunding(request: QueryDayFundingRequest): Promise<QueryDayFundingResponse>;
+    /** ShieldEpoch returns the current shield epoch state. */
+    shieldEpoch(request?: QueryShieldEpochRequest): Promise<QueryShieldEpochResponse>;
+    /** PendingOps returns pending shielded operations (optionally filtered by epoch). */
+    pendingOps(request: QueryPendingOpsRequest): Promise<QueryPendingOpsResponse>;
+    /** PendingOpCount returns the count of pending operations. */
+    pendingOpCount(request?: QueryPendingOpCountRequest): Promise<QueryPendingOpCountResponse>;
+    /** TLEMasterPublicKey returns the TLE master public key (for client encryption). */
+    tLEMasterPublicKey(request?: QueryTLEMasterPublicKeyRequest): Promise<QueryTLEMasterPublicKeyResponse>;
+    /** TLEKeySet returns the full TLE key set (master key + validator shares). */
+    tLEKeySet(request?: QueryTLEKeySetRequest): Promise<QueryTLEKeySetResponse>;
+    /** VerificationKey returns a ZK verification key by circuit ID. */
+    verificationKey(request: QueryVerificationKeyRequest): Promise<QueryVerificationKeyResponse>;
+    /** TLEMissCount returns a validator's current TLE miss count. */
+    tLEMissCount(request: QueryTLEMissCountRequest): Promise<QueryTLEMissCountResponse>;
+    /** DecryptionShares returns the decryption shares submitted for a given epoch. */
+    decryptionShares(request: QueryDecryptionSharesRequest): Promise<QueryDecryptionSharesResponse>;
+    /** IdentityRateLimit returns the remaining rate limit for a given rate-limit nullifier. */
+    identityRateLimit(request: QueryIdentityRateLimitRequest): Promise<QueryIdentityRateLimitResponse>;
+    /** DKGState returns the current DKG ceremony state. */
+    dKGState(request?: QueryDKGStateRequest): Promise<QueryDKGStateResponse>;
+    /** DKGContributions returns all DKG contributions for the current round. */
+    dKGContributions(request?: QueryDKGContributionsRequest): Promise<QueryDKGContributionsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    shieldedOp: (request: QueryShieldedOpRequest) => Promise<QueryShieldedOpResponse>;
+    shieldedOps: (request?: QueryShieldedOpsRequest) => Promise<QueryShieldedOpsResponse>;
+    moduleBalance: (request?: QueryModuleBalanceRequest) => Promise<QueryModuleBalanceResponse>;
+    nullifierUsed: (request: QueryNullifierUsedRequest) => Promise<QueryNullifierUsedResponse>;
+    dayFunding: (request: QueryDayFundingRequest) => Promise<QueryDayFundingResponse>;
+    shieldEpoch: (request?: QueryShieldEpochRequest) => Promise<QueryShieldEpochResponse>;
+    pendingOps: (request: QueryPendingOpsRequest) => Promise<QueryPendingOpsResponse>;
+    pendingOpCount: (request?: QueryPendingOpCountRequest) => Promise<QueryPendingOpCountResponse>;
+    tLEMasterPublicKey: (request?: QueryTLEMasterPublicKeyRequest) => Promise<QueryTLEMasterPublicKeyResponse>;
+    tLEKeySet: (request?: QueryTLEKeySetRequest) => Promise<QueryTLEKeySetResponse>;
+    verificationKey: (request: QueryVerificationKeyRequest) => Promise<QueryVerificationKeyResponse>;
+    tLEMissCount: (request: QueryTLEMissCountRequest) => Promise<QueryTLEMissCountResponse>;
+    decryptionShares: (request: QueryDecryptionSharesRequest) => Promise<QueryDecryptionSharesResponse>;
+    identityRateLimit: (request: QueryIdentityRateLimitRequest) => Promise<QueryIdentityRateLimitResponse>;
+    dKGState: (request?: QueryDKGStateRequest) => Promise<QueryDKGStateResponse>;
+    dKGContributions: (request?: QueryDKGContributionsRequest) => Promise<QueryDKGContributionsResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    shieldedOp(request: QueryShieldedOpRequest): Promise<QueryShieldedOpResponse>;
+    shieldedOps(request?: QueryShieldedOpsRequest): Promise<QueryShieldedOpsResponse>;
+    moduleBalance(request?: QueryModuleBalanceRequest): Promise<QueryModuleBalanceResponse>;
+    nullifierUsed(request: QueryNullifierUsedRequest): Promise<QueryNullifierUsedResponse>;
+    dayFunding(request: QueryDayFundingRequest): Promise<QueryDayFundingResponse>;
+    shieldEpoch(request?: QueryShieldEpochRequest): Promise<QueryShieldEpochResponse>;
+    pendingOps(request: QueryPendingOpsRequest): Promise<QueryPendingOpsResponse>;
+    pendingOpCount(request?: QueryPendingOpCountRequest): Promise<QueryPendingOpCountResponse>;
+    tLEMasterPublicKey(request?: QueryTLEMasterPublicKeyRequest): Promise<QueryTLEMasterPublicKeyResponse>;
+    tLEKeySet(request?: QueryTLEKeySetRequest): Promise<QueryTLEKeySetResponse>;
+    verificationKey(request: QueryVerificationKeyRequest): Promise<QueryVerificationKeyResponse>;
+    tLEMissCount(request: QueryTLEMissCountRequest): Promise<QueryTLEMissCountResponse>;
+    decryptionShares(request: QueryDecryptionSharesRequest): Promise<QueryDecryptionSharesResponse>;
+    identityRateLimit(request: QueryIdentityRateLimitRequest): Promise<QueryIdentityRateLimitResponse>;
+    dKGState(request?: QueryDKGStateRequest): Promise<QueryDKGStateResponse>;
+    dKGContributions(request?: QueryDKGContributionsRequest): Promise<QueryDKGContributionsResponse>;
+};

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

@@ -0,0 +1,175 @@
+"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;
+    }
+    /* Params returns module parameters. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ShieldedOp returns the registration for a specific message type. */
+    shieldedOp = async (request) => {
+        const data = query_1.QueryShieldedOpRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "ShieldedOp", data);
+        return promise.then(data => query_1.QueryShieldedOpResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ShieldedOps returns all registered shielded operations. */
+    shieldedOps = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryShieldedOpsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "ShieldedOps", data);
+        return promise.then(data => query_1.QueryShieldedOpsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ModuleBalance returns the shield module account's current balance. */
+    moduleBalance = async (request = {}) => {
+        const data = query_1.QueryModuleBalanceRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "ModuleBalance", data);
+        return promise.then(data => query_1.QueryModuleBalanceResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* NullifierUsed checks if a nullifier has been used in a given domain+scope. */
+    nullifierUsed = async (request) => {
+        const data = query_1.QueryNullifierUsedRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "NullifierUsed", data);
+        return promise.then(data => query_1.QueryNullifierUsedResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* DayFunding returns the amount funded from community pool for a given day. */
+    dayFunding = async (request) => {
+        const data = query_1.QueryDayFundingRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "DayFunding", data);
+        return promise.then(data => query_1.QueryDayFundingResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ShieldEpoch returns the current shield epoch state. */
+    shieldEpoch = async (request = {}) => {
+        const data = query_1.QueryShieldEpochRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "ShieldEpoch", data);
+        return promise.then(data => query_1.QueryShieldEpochResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* PendingOps returns pending shielded operations (optionally filtered by epoch). */
+    pendingOps = async (request) => {
+        const data = query_1.QueryPendingOpsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "PendingOps", data);
+        return promise.then(data => query_1.QueryPendingOpsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* PendingOpCount returns the count of pending operations. */
+    pendingOpCount = async (request = {}) => {
+        const data = query_1.QueryPendingOpCountRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "PendingOpCount", data);
+        return promise.then(data => query_1.QueryPendingOpCountResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* TLEMasterPublicKey returns the TLE master public key (for client encryption). */
+    tLEMasterPublicKey = async (request = {}) => {
+        const data = query_1.QueryTLEMasterPublicKeyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "TLEMasterPublicKey", data);
+        return promise.then(data => query_1.QueryTLEMasterPublicKeyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* TLEKeySet returns the full TLE key set (master key + validator shares). */
+    tLEKeySet = async (request = {}) => {
+        const data = query_1.QueryTLEKeySetRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "TLEKeySet", data);
+        return promise.then(data => query_1.QueryTLEKeySetResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* VerificationKey returns a ZK verification key by circuit ID. */
+    verificationKey = async (request) => {
+        const data = query_1.QueryVerificationKeyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "VerificationKey", data);
+        return promise.then(data => query_1.QueryVerificationKeyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* TLEMissCount returns a validator's current TLE miss count. */
+    tLEMissCount = async (request) => {
+        const data = query_1.QueryTLEMissCountRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "TLEMissCount", data);
+        return promise.then(data => query_1.QueryTLEMissCountResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* DecryptionShares returns the decryption shares submitted for a given epoch. */
+    decryptionShares = async (request) => {
+        const data = query_1.QueryDecryptionSharesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "DecryptionShares", data);
+        return promise.then(data => query_1.QueryDecryptionSharesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* IdentityRateLimit returns the remaining rate limit for a given rate-limit nullifier. */
+    identityRateLimit = async (request) => {
+        const data = query_1.QueryIdentityRateLimitRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "IdentityRateLimit", data);
+        return promise.then(data => query_1.QueryIdentityRateLimitResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* DKGState returns the current DKG ceremony state. */
+    dKGState = async (request = {}) => {
+        const data = query_1.QueryDKGStateRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "DKGState", data);
+        return promise.then(data => query_1.QueryDKGStateResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* DKGContributions returns all DKG contributions for the current round. */
+    dKGContributions = async (request = {}) => {
+        const data = query_1.QueryDKGContributionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.shield.v1.Query", "DKGContributions", data);
+        return promise.then(data => query_1.QueryDKGContributionsResponse.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);
+        },
+        shieldedOp(request) {
+            return queryService.shieldedOp(request);
+        },
+        shieldedOps(request) {
+            return queryService.shieldedOps(request);
+        },
+        moduleBalance(request) {
+            return queryService.moduleBalance(request);
+        },
+        nullifierUsed(request) {
+            return queryService.nullifierUsed(request);
+        },
+        dayFunding(request) {
+            return queryService.dayFunding(request);
+        },
+        shieldEpoch(request) {
+            return queryService.shieldEpoch(request);
+        },
+        pendingOps(request) {
+            return queryService.pendingOps(request);
+        },
+        pendingOpCount(request) {
+            return queryService.pendingOpCount(request);
+        },
+        tLEMasterPublicKey(request) {
+            return queryService.tLEMasterPublicKey(request);
+        },
+        tLEKeySet(request) {
+            return queryService.tLEKeySet(request);
+        },
+        verificationKey(request) {
+            return queryService.verificationKey(request);
+        },
+        tLEMissCount(request) {
+            return queryService.tLEMissCount(request);
+        },
+        decryptionShares(request) {
+            return queryService.decryptionShares(request);
+        },
+        identityRateLimit(request) {
+            return queryService.identityRateLimit(request);
+        },
+        dKGState(request) {
+            return queryService.dKGState(request);
+        },
+        dKGContributions(request) {
+            return queryService.dKGContributions(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

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

@@ -0,0 +1,28 @@
+import { MsgUpdateParams, MsgShieldedExec, MsgTriggerDkg, MsgRegisterShieldedOp, MsgDeregisterShieldedOp } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.shield.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.shield.v1.MsgShieldedExec": {
+        aminoType: string;
+        toAmino: (message: MsgShieldedExec) => import("./tx").MsgShieldedExecAmino;
+        fromAmino: (object: import("./tx").MsgShieldedExecAmino) => MsgShieldedExec;
+    };
+    "/sparkdream.shield.v1.MsgTriggerDkg": {
+        aminoType: string;
+        toAmino: (message: MsgTriggerDkg) => import("./tx").MsgTriggerDkgAmino;
+        fromAmino: (object: import("./tx").MsgTriggerDkgAmino) => MsgTriggerDkg;
+    };
+    "/sparkdream.shield.v1.MsgRegisterShieldedOp": {
+        aminoType: string;
+        toAmino: (message: MsgRegisterShieldedOp) => import("./tx").MsgRegisterShieldedOpAmino;
+        fromAmino: (object: import("./tx").MsgRegisterShieldedOpAmino) => MsgRegisterShieldedOp;
+    };
+    "/sparkdream.shield.v1.MsgDeregisterShieldedOp": {
+        aminoType: string;
+        toAmino: (message: MsgDeregisterShieldedOp) => import("./tx").MsgDeregisterShieldedOpAmino;
+        fromAmino: (object: import("./tx").MsgDeregisterShieldedOpAmino) => MsgDeregisterShieldedOp;
+    };
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/sparkdream.shield.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/shield/MsgUpdateParams",
+        toAmino: tx_1.MsgUpdateParams.toAmino,
+        fromAmino: tx_1.MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgShieldedExec": {
+        aminoType: "/sparkdream.shield.v1.MsgShieldedExec",
+        toAmino: tx_1.MsgShieldedExec.toAmino,
+        fromAmino: tx_1.MsgShieldedExec.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgTriggerDkg": {
+        aminoType: "/sparkdream.shield.v1.MsgTriggerDkg",
+        toAmino: tx_1.MsgTriggerDkg.toAmino,
+        fromAmino: tx_1.MsgTriggerDkg.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgRegisterShieldedOp": {
+        aminoType: "/sparkdream.shield.v1.MsgRegisterShieldedOp",
+        toAmino: tx_1.MsgRegisterShieldedOp.toAmino,
+        fromAmino: tx_1.MsgRegisterShieldedOp.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgDeregisterShieldedOp": {
+        aminoType: "/sparkdream.shield.v1.MsgDeregisterShieldedOp",
+        toAmino: tx_1.MsgDeregisterShieldedOp.toAmino,
+        fromAmino: tx_1.MsgDeregisterShieldedOp.fromAmino
+    }
+};