@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

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

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export 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") {
+            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") {
+            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);
+    };
+}

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

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

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

@@ -0,0 +1,29 @@
+//@ts-nocheck
+import { MsgUpdateParams, MsgShieldedExec, MsgTriggerDkg, MsgRegisterShieldedOp, MsgDeregisterShieldedOp } from "./tx";
+export const AminoConverter = {
+    "/sparkdream.shield.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/shield/MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgShieldedExec": {
+        aminoType: "/sparkdream.shield.v1.MsgShieldedExec",
+        toAmino: MsgShieldedExec.toAmino,
+        fromAmino: MsgShieldedExec.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgTriggerDkg": {
+        aminoType: "/sparkdream.shield.v1.MsgTriggerDkg",
+        toAmino: MsgTriggerDkg.toAmino,
+        fromAmino: MsgTriggerDkg.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgRegisterShieldedOp": {
+        aminoType: "/sparkdream.shield.v1.MsgRegisterShieldedOp",
+        toAmino: MsgRegisterShieldedOp.toAmino,
+        fromAmino: MsgRegisterShieldedOp.fromAmino
+    },
+    "/sparkdream.shield.v1.MsgDeregisterShieldedOp": {
+        aminoType: "/sparkdream.shield.v1.MsgDeregisterShieldedOp",
+        toAmino: MsgDeregisterShieldedOp.toAmino,
+        fromAmino: MsgDeregisterShieldedOp.fromAmino
+    }
+};