@sparkdreamnft/sparkdreamjs 0.0.8 → 0.0.9

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

@@ -0,0 +1,26 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryGetPeerRequest, QueryGetPeerResponse, QueryListPeersRequest, QueryListPeersResponse, QueryGetPeerPolicyRequest, QueryGetPeerPolicyResponse, QueryGetBridgeOperatorRequest, QueryGetBridgeOperatorResponse, QueryListBridgeOperatorsRequest, QueryListBridgeOperatorsResponse, QueryGetFederatedContentRequest, QueryGetFederatedContentResponse, QueryListFederatedContentRequest, QueryListFederatedContentResponse, QueryGetIdentityLinkRequest, QueryGetIdentityLinkResponse, QueryListIdentityLinksRequest, QueryListIdentityLinksResponse, QueryResolveRemoteIdentityRequest, QueryResolveRemoteIdentityResponse, QueryGetPendingIdentityChallengeRequest, QueryGetPendingIdentityChallengeResponse, QueryListPendingIdentityChallengesRequest, QueryListPendingIdentityChallengesResponse, QueryGetReputationAttestationRequest, QueryGetReputationAttestationResponse, QueryListOutboundAttestationsRequest, QueryListOutboundAttestationsResponse, QueryGetVerifierRequest, QueryGetVerifierResponse, QueryListVerifiersRequest, QueryListVerifiersResponse, QueryGetVerificationRecordRequest, QueryGetVerificationRecordResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    getPeer: (params: QueryGetPeerRequest) => Promise<QueryGetPeerResponse>;
+    listPeers: (params?: QueryListPeersRequest) => Promise<QueryListPeersResponse>;
+    getPeerPolicy: (params: QueryGetPeerPolicyRequest) => Promise<QueryGetPeerPolicyResponse>;
+    getBridgeOperator: (params: QueryGetBridgeOperatorRequest) => Promise<QueryGetBridgeOperatorResponse>;
+    listBridgeOperators: (params?: QueryListBridgeOperatorsRequest) => Promise<QueryListBridgeOperatorsResponse>;
+    getFederatedContent: (params: QueryGetFederatedContentRequest) => Promise<QueryGetFederatedContentResponse>;
+    listFederatedContent: (params?: QueryListFederatedContentRequest) => Promise<QueryListFederatedContentResponse>;
+    getIdentityLink: (params: QueryGetIdentityLinkRequest) => Promise<QueryGetIdentityLinkResponse>;
+    listIdentityLinks: (params?: QueryListIdentityLinksRequest) => Promise<QueryListIdentityLinksResponse>;
+    resolveRemoteIdentity: (params: QueryResolveRemoteIdentityRequest) => Promise<QueryResolveRemoteIdentityResponse>;
+    getPendingIdentityChallenge: (params: QueryGetPendingIdentityChallengeRequest) => Promise<QueryGetPendingIdentityChallengeResponse>;
+    listPendingIdentityChallenges: (params: QueryListPendingIdentityChallengesRequest) => Promise<QueryListPendingIdentityChallengesResponse>;
+    getReputationAttestation: (params: QueryGetReputationAttestationRequest) => Promise<QueryGetReputationAttestationResponse>;
+    listOutboundAttestations: (params?: QueryListOutboundAttestationsRequest) => Promise<QueryListOutboundAttestationsResponse>;
+    getVerifier: (params: QueryGetVerifierRequest) => Promise<QueryGetVerifierResponse>;
+    listVerifiers: (params?: QueryListVerifiersRequest) => Promise<QueryListVerifiersResponse>;
+    getVerificationRecord: (params: QueryGetVerificationRecordRequest) => Promise<QueryGetVerificationRecordResponse>;
+}

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

@@ -0,0 +1,156 @@
+"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 */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/federation/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* GetPeer */
+    getPeer = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_peer/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListPeers */
+    listPeers = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_peers`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetPeerPolicy */
+    getPeerPolicy = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_peer_policy/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* GetBridgeOperator */
+    getBridgeOperator = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_bridge_operator/${params.address}/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListBridgeOperators */
+    listBridgeOperators = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_bridge_operators`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetFederatedContent */
+    getFederatedContent = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_federated_content/${params.id}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListFederatedContent */
+    listFederatedContent = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_federated_content`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetIdentityLink */
+    getIdentityLink = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_identity_link/${params.localAddress}/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListIdentityLinks */
+    listIdentityLinks = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_identity_links`;
+        return await this.req.get(endpoint, options);
+    };
+    /* ResolveRemoteIdentity */
+    resolveRemoteIdentity = async (params) => {
+        const endpoint = `sparkdream/federation/v1/resolve_remote_identity/${params.peerId}/${params.remoteIdentity}`;
+        return await this.req.get(endpoint);
+    };
+    /* GetPendingIdentityChallenge */
+    getPendingIdentityChallenge = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_pending_identity_challenge/${params.claimedAddress}/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListPendingIdentityChallenges */
+    listPendingIdentityChallenges = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_pending_identity_challenges/${params.claimedAddress}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetReputationAttestation */
+    getReputationAttestation = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_reputation_attestation/${params.localAddress}/${params.peerId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListOutboundAttestations */
+    listOutboundAttestations = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_outbound_attestations`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetVerifier */
+    getVerifier = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_verifier/${params.address}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListVerifiers */
+    listVerifiers = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/federation/v1/list_verifiers`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetVerificationRecord */
+    getVerificationRecord = async (params) => {
+        const endpoint = `sparkdream/federation/v1/get_verification_record/${params.contentId}`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

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

@@ -0,0 +1,66 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryGetPeerRequest, QueryGetPeerResponse, QueryListPeersRequest, QueryListPeersResponse, QueryGetPeerPolicyRequest, QueryGetPeerPolicyResponse, QueryGetBridgeOperatorRequest, QueryGetBridgeOperatorResponse, QueryListBridgeOperatorsRequest, QueryListBridgeOperatorsResponse, QueryGetFederatedContentRequest, QueryGetFederatedContentResponse, QueryListFederatedContentRequest, QueryListFederatedContentResponse, QueryGetIdentityLinkRequest, QueryGetIdentityLinkResponse, QueryListIdentityLinksRequest, QueryListIdentityLinksResponse, QueryResolveRemoteIdentityRequest, QueryResolveRemoteIdentityResponse, QueryGetPendingIdentityChallengeRequest, QueryGetPendingIdentityChallengeResponse, QueryListPendingIdentityChallengesRequest, QueryListPendingIdentityChallengesResponse, QueryGetReputationAttestationRequest, QueryGetReputationAttestationResponse, QueryListOutboundAttestationsRequest, QueryListOutboundAttestationsResponse, QueryGetVerifierRequest, QueryGetVerifierResponse, QueryListVerifiersRequest, QueryListVerifiersResponse, QueryGetVerificationRecordRequest, QueryGetVerificationRecordResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    getPeer(request: QueryGetPeerRequest): Promise<QueryGetPeerResponse>;
+    listPeers(request?: QueryListPeersRequest): Promise<QueryListPeersResponse>;
+    getPeerPolicy(request: QueryGetPeerPolicyRequest): Promise<QueryGetPeerPolicyResponse>;
+    getBridgeOperator(request: QueryGetBridgeOperatorRequest): Promise<QueryGetBridgeOperatorResponse>;
+    listBridgeOperators(request?: QueryListBridgeOperatorsRequest): Promise<QueryListBridgeOperatorsResponse>;
+    getFederatedContent(request: QueryGetFederatedContentRequest): Promise<QueryGetFederatedContentResponse>;
+    listFederatedContent(request?: QueryListFederatedContentRequest): Promise<QueryListFederatedContentResponse>;
+    getIdentityLink(request: QueryGetIdentityLinkRequest): Promise<QueryGetIdentityLinkResponse>;
+    listIdentityLinks(request?: QueryListIdentityLinksRequest): Promise<QueryListIdentityLinksResponse>;
+    resolveRemoteIdentity(request: QueryResolveRemoteIdentityRequest): Promise<QueryResolveRemoteIdentityResponse>;
+    getPendingIdentityChallenge(request: QueryGetPendingIdentityChallengeRequest): Promise<QueryGetPendingIdentityChallengeResponse>;
+    listPendingIdentityChallenges(request: QueryListPendingIdentityChallengesRequest): Promise<QueryListPendingIdentityChallengesResponse>;
+    getReputationAttestation(request: QueryGetReputationAttestationRequest): Promise<QueryGetReputationAttestationResponse>;
+    listOutboundAttestations(request?: QueryListOutboundAttestationsRequest): Promise<QueryListOutboundAttestationsResponse>;
+    getVerifier(request: QueryGetVerifierRequest): Promise<QueryGetVerifierResponse>;
+    listVerifiers(request?: QueryListVerifiersRequest): Promise<QueryListVerifiersResponse>;
+    getVerificationRecord(request: QueryGetVerificationRecordRequest): Promise<QueryGetVerificationRecordResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    getPeer: (request: QueryGetPeerRequest) => Promise<QueryGetPeerResponse>;
+    listPeers: (request?: QueryListPeersRequest) => Promise<QueryListPeersResponse>;
+    getPeerPolicy: (request: QueryGetPeerPolicyRequest) => Promise<QueryGetPeerPolicyResponse>;
+    getBridgeOperator: (request: QueryGetBridgeOperatorRequest) => Promise<QueryGetBridgeOperatorResponse>;
+    listBridgeOperators: (request?: QueryListBridgeOperatorsRequest) => Promise<QueryListBridgeOperatorsResponse>;
+    getFederatedContent: (request: QueryGetFederatedContentRequest) => Promise<QueryGetFederatedContentResponse>;
+    listFederatedContent: (request?: QueryListFederatedContentRequest) => Promise<QueryListFederatedContentResponse>;
+    getIdentityLink: (request: QueryGetIdentityLinkRequest) => Promise<QueryGetIdentityLinkResponse>;
+    listIdentityLinks: (request?: QueryListIdentityLinksRequest) => Promise<QueryListIdentityLinksResponse>;
+    resolveRemoteIdentity: (request: QueryResolveRemoteIdentityRequest) => Promise<QueryResolveRemoteIdentityResponse>;
+    getPendingIdentityChallenge: (request: QueryGetPendingIdentityChallengeRequest) => Promise<QueryGetPendingIdentityChallengeResponse>;
+    listPendingIdentityChallenges: (request: QueryListPendingIdentityChallengesRequest) => Promise<QueryListPendingIdentityChallengesResponse>;
+    getReputationAttestation: (request: QueryGetReputationAttestationRequest) => Promise<QueryGetReputationAttestationResponse>;
+    listOutboundAttestations: (request?: QueryListOutboundAttestationsRequest) => Promise<QueryListOutboundAttestationsResponse>;
+    getVerifier: (request: QueryGetVerifierRequest) => Promise<QueryGetVerifierResponse>;
+    listVerifiers: (request?: QueryListVerifiersRequest) => Promise<QueryListVerifiersResponse>;
+    getVerificationRecord: (request: QueryGetVerificationRecordRequest) => Promise<QueryGetVerificationRecordResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    getPeer(request: QueryGetPeerRequest): Promise<QueryGetPeerResponse>;
+    listPeers(request?: QueryListPeersRequest): Promise<QueryListPeersResponse>;
+    getPeerPolicy(request: QueryGetPeerPolicyRequest): Promise<QueryGetPeerPolicyResponse>;
+    getBridgeOperator(request: QueryGetBridgeOperatorRequest): Promise<QueryGetBridgeOperatorResponse>;
+    listBridgeOperators(request?: QueryListBridgeOperatorsRequest): Promise<QueryListBridgeOperatorsResponse>;
+    getFederatedContent(request: QueryGetFederatedContentRequest): Promise<QueryGetFederatedContentResponse>;
+    listFederatedContent(request?: QueryListFederatedContentRequest): Promise<QueryListFederatedContentResponse>;
+    getIdentityLink(request: QueryGetIdentityLinkRequest): Promise<QueryGetIdentityLinkResponse>;
+    listIdentityLinks(request?: QueryListIdentityLinksRequest): Promise<QueryListIdentityLinksResponse>;
+    resolveRemoteIdentity(request: QueryResolveRemoteIdentityRequest): Promise<QueryResolveRemoteIdentityResponse>;
+    getPendingIdentityChallenge(request: QueryGetPendingIdentityChallengeRequest): Promise<QueryGetPendingIdentityChallengeResponse>;
+    listPendingIdentityChallenges(request: QueryListPendingIdentityChallengesRequest): Promise<QueryListPendingIdentityChallengesResponse>;
+    getReputationAttestation(request: QueryGetReputationAttestationRequest): Promise<QueryGetReputationAttestationResponse>;
+    listOutboundAttestations(request?: QueryListOutboundAttestationsRequest): Promise<QueryListOutboundAttestationsResponse>;
+    getVerifier(request: QueryGetVerifierRequest): Promise<QueryGetVerifierResponse>;
+    listVerifiers(request?: QueryListVerifiersRequest): Promise<QueryListVerifiersResponse>;
+    getVerificationRecord(request: QueryGetVerificationRecordRequest): Promise<QueryGetVerificationRecordResponse>;
+};

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

@@ -0,0 +1,194 @@
+"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 */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetPeer */
+    getPeer = async (request) => {
+        const data = query_1.QueryGetPeerRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetPeer", data);
+        return promise.then(data => query_1.QueryGetPeerResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListPeers */
+    listPeers = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListPeersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListPeers", data);
+        return promise.then(data => query_1.QueryListPeersResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetPeerPolicy */
+    getPeerPolicy = async (request) => {
+        const data = query_1.QueryGetPeerPolicyRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetPeerPolicy", data);
+        return promise.then(data => query_1.QueryGetPeerPolicyResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetBridgeOperator */
+    getBridgeOperator = async (request) => {
+        const data = query_1.QueryGetBridgeOperatorRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetBridgeOperator", data);
+        return promise.then(data => query_1.QueryGetBridgeOperatorResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListBridgeOperators */
+    listBridgeOperators = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListBridgeOperatorsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListBridgeOperators", data);
+        return promise.then(data => query_1.QueryListBridgeOperatorsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetFederatedContent */
+    getFederatedContent = async (request) => {
+        const data = query_1.QueryGetFederatedContentRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetFederatedContent", data);
+        return promise.then(data => query_1.QueryGetFederatedContentResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListFederatedContent */
+    listFederatedContent = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListFederatedContentRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListFederatedContent", data);
+        return promise.then(data => query_1.QueryListFederatedContentResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetIdentityLink */
+    getIdentityLink = async (request) => {
+        const data = query_1.QueryGetIdentityLinkRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetIdentityLink", data);
+        return promise.then(data => query_1.QueryGetIdentityLinkResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListIdentityLinks */
+    listIdentityLinks = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListIdentityLinksRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListIdentityLinks", data);
+        return promise.then(data => query_1.QueryListIdentityLinksResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ResolveRemoteIdentity */
+    resolveRemoteIdentity = async (request) => {
+        const data = query_1.QueryResolveRemoteIdentityRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ResolveRemoteIdentity", data);
+        return promise.then(data => query_1.QueryResolveRemoteIdentityResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetPendingIdentityChallenge */
+    getPendingIdentityChallenge = async (request) => {
+        const data = query_1.QueryGetPendingIdentityChallengeRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetPendingIdentityChallenge", data);
+        return promise.then(data => query_1.QueryGetPendingIdentityChallengeResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListPendingIdentityChallenges */
+    listPendingIdentityChallenges = async (request) => {
+        const data = query_1.QueryListPendingIdentityChallengesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListPendingIdentityChallenges", data);
+        return promise.then(data => query_1.QueryListPendingIdentityChallengesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetReputationAttestation */
+    getReputationAttestation = async (request) => {
+        const data = query_1.QueryGetReputationAttestationRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetReputationAttestation", data);
+        return promise.then(data => query_1.QueryGetReputationAttestationResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListOutboundAttestations */
+    listOutboundAttestations = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListOutboundAttestationsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListOutboundAttestations", data);
+        return promise.then(data => query_1.QueryListOutboundAttestationsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetVerifier */
+    getVerifier = async (request) => {
+        const data = query_1.QueryGetVerifierRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetVerifier", data);
+        return promise.then(data => query_1.QueryGetVerifierResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListVerifiers */
+    listVerifiers = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryListVerifiersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "ListVerifiers", data);
+        return promise.then(data => query_1.QueryListVerifiersResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetVerificationRecord */
+    getVerificationRecord = async (request) => {
+        const data = query_1.QueryGetVerificationRecordRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.federation.v1.Query", "GetVerificationRecord", data);
+        return promise.then(data => query_1.QueryGetVerificationRecordResponse.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);
+        },
+        getPeer(request) {
+            return queryService.getPeer(request);
+        },
+        listPeers(request) {
+            return queryService.listPeers(request);
+        },
+        getPeerPolicy(request) {
+            return queryService.getPeerPolicy(request);
+        },
+        getBridgeOperator(request) {
+            return queryService.getBridgeOperator(request);
+        },
+        listBridgeOperators(request) {
+            return queryService.listBridgeOperators(request);
+        },
+        getFederatedContent(request) {
+            return queryService.getFederatedContent(request);
+        },
+        listFederatedContent(request) {
+            return queryService.listFederatedContent(request);
+        },
+        getIdentityLink(request) {
+            return queryService.getIdentityLink(request);
+        },
+        listIdentityLinks(request) {
+            return queryService.listIdentityLinks(request);
+        },
+        resolveRemoteIdentity(request) {
+            return queryService.resolveRemoteIdentity(request);
+        },
+        getPendingIdentityChallenge(request) {
+            return queryService.getPendingIdentityChallenge(request);
+        },
+        listPendingIdentityChallenges(request) {
+            return queryService.listPendingIdentityChallenges(request);
+        },
+        getReputationAttestation(request) {
+            return queryService.getReputationAttestation(request);
+        },
+        listOutboundAttestations(request) {
+            return queryService.listOutboundAttestations(request);
+        },
+        getVerifier(request) {
+            return queryService.getVerifier(request);
+        },
+        listVerifiers(request) {
+            return queryService.listVerifiers(request);
+        },
+        getVerificationRecord(request) {
+            return queryService.getVerificationRecord(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

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

@@ -0,0 +1,138 @@
+import { MsgUpdateParams, MsgRegisterPeer, MsgRemovePeer, MsgSuspendPeer, MsgResumePeer, MsgUpdatePeerPolicy, MsgRegisterBridge, MsgRevokeBridge, MsgSlashBridge, MsgUpdateBridge, MsgUnbondBridge, MsgTopUpBridgeStake, MsgSubmitFederatedContent, MsgFederateContent, MsgAttestOutbound, MsgModerateContent, MsgLinkIdentity, MsgUnlinkIdentity, MsgConfirmIdentityLink, MsgRequestReputationAttestation, MsgBondVerifier, MsgUnbondVerifier, MsgVerifyContent, MsgChallengeVerification, MsgSubmitArbiterHash, MsgEscalateChallenge, MsgUpdateOperationalParams } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.federation.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.federation.v1.MsgRegisterPeer": {
+        aminoType: string;
+        toAmino: (message: MsgRegisterPeer) => import("./tx").MsgRegisterPeerAmino;
+        fromAmino: (object: import("./tx").MsgRegisterPeerAmino) => MsgRegisterPeer;
+    };
+    "/sparkdream.federation.v1.MsgRemovePeer": {
+        aminoType: string;
+        toAmino: (message: MsgRemovePeer) => import("./tx").MsgRemovePeerAmino;
+        fromAmino: (object: import("./tx").MsgRemovePeerAmino) => MsgRemovePeer;
+    };
+    "/sparkdream.federation.v1.MsgSuspendPeer": {
+        aminoType: string;
+        toAmino: (message: MsgSuspendPeer) => import("./tx").MsgSuspendPeerAmino;
+        fromAmino: (object: import("./tx").MsgSuspendPeerAmino) => MsgSuspendPeer;
+    };
+    "/sparkdream.federation.v1.MsgResumePeer": {
+        aminoType: string;
+        toAmino: (message: MsgResumePeer) => import("./tx").MsgResumePeerAmino;
+        fromAmino: (object: import("./tx").MsgResumePeerAmino) => MsgResumePeer;
+    };
+    "/sparkdream.federation.v1.MsgUpdatePeerPolicy": {
+        aminoType: string;
+        toAmino: (message: MsgUpdatePeerPolicy) => import("./tx").MsgUpdatePeerPolicyAmino;
+        fromAmino: (object: import("./tx").MsgUpdatePeerPolicyAmino) => MsgUpdatePeerPolicy;
+    };
+    "/sparkdream.federation.v1.MsgRegisterBridge": {
+        aminoType: string;
+        toAmino: (message: MsgRegisterBridge) => import("./tx").MsgRegisterBridgeAmino;
+        fromAmino: (object: import("./tx").MsgRegisterBridgeAmino) => MsgRegisterBridge;
+    };
+    "/sparkdream.federation.v1.MsgRevokeBridge": {
+        aminoType: string;
+        toAmino: (message: MsgRevokeBridge) => import("./tx").MsgRevokeBridgeAmino;
+        fromAmino: (object: import("./tx").MsgRevokeBridgeAmino) => MsgRevokeBridge;
+    };
+    "/sparkdream.federation.v1.MsgSlashBridge": {
+        aminoType: string;
+        toAmino: (message: MsgSlashBridge) => import("./tx").MsgSlashBridgeAmino;
+        fromAmino: (object: import("./tx").MsgSlashBridgeAmino) => MsgSlashBridge;
+    };
+    "/sparkdream.federation.v1.MsgUpdateBridge": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateBridge) => import("./tx").MsgUpdateBridgeAmino;
+        fromAmino: (object: import("./tx").MsgUpdateBridgeAmino) => MsgUpdateBridge;
+    };
+    "/sparkdream.federation.v1.MsgUnbondBridge": {
+        aminoType: string;
+        toAmino: (message: MsgUnbondBridge) => import("./tx").MsgUnbondBridgeAmino;
+        fromAmino: (object: import("./tx").MsgUnbondBridgeAmino) => MsgUnbondBridge;
+    };
+    "/sparkdream.federation.v1.MsgTopUpBridgeStake": {
+        aminoType: string;
+        toAmino: (message: MsgTopUpBridgeStake) => import("./tx").MsgTopUpBridgeStakeAmino;
+        fromAmino: (object: import("./tx").MsgTopUpBridgeStakeAmino) => MsgTopUpBridgeStake;
+    };
+    "/sparkdream.federation.v1.MsgSubmitFederatedContent": {
+        aminoType: string;
+        toAmino: (message: MsgSubmitFederatedContent) => import("./tx").MsgSubmitFederatedContentAmino;
+        fromAmino: (object: import("./tx").MsgSubmitFederatedContentAmino) => MsgSubmitFederatedContent;
+    };
+    "/sparkdream.federation.v1.MsgFederateContent": {
+        aminoType: string;
+        toAmino: (message: MsgFederateContent) => import("./tx").MsgFederateContentAmino;
+        fromAmino: (object: import("./tx").MsgFederateContentAmino) => MsgFederateContent;
+    };
+    "/sparkdream.federation.v1.MsgAttestOutbound": {
+        aminoType: string;
+        toAmino: (message: MsgAttestOutbound) => import("./tx").MsgAttestOutboundAmino;
+        fromAmino: (object: import("./tx").MsgAttestOutboundAmino) => MsgAttestOutbound;
+    };
+    "/sparkdream.federation.v1.MsgModerateContent": {
+        aminoType: string;
+        toAmino: (message: MsgModerateContent) => import("./tx").MsgModerateContentAmino;
+        fromAmino: (object: import("./tx").MsgModerateContentAmino) => MsgModerateContent;
+    };
+    "/sparkdream.federation.v1.MsgLinkIdentity": {
+        aminoType: string;
+        toAmino: (message: MsgLinkIdentity) => import("./tx").MsgLinkIdentityAmino;
+        fromAmino: (object: import("./tx").MsgLinkIdentityAmino) => MsgLinkIdentity;
+    };
+    "/sparkdream.federation.v1.MsgUnlinkIdentity": {
+        aminoType: string;
+        toAmino: (message: MsgUnlinkIdentity) => import("./tx").MsgUnlinkIdentityAmino;
+        fromAmino: (object: import("./tx").MsgUnlinkIdentityAmino) => MsgUnlinkIdentity;
+    };
+    "/sparkdream.federation.v1.MsgConfirmIdentityLink": {
+        aminoType: string;
+        toAmino: (message: MsgConfirmIdentityLink) => import("./tx").MsgConfirmIdentityLinkAmino;
+        fromAmino: (object: import("./tx").MsgConfirmIdentityLinkAmino) => MsgConfirmIdentityLink;
+    };
+    "/sparkdream.federation.v1.MsgRequestReputationAttestation": {
+        aminoType: string;
+        toAmino: (message: MsgRequestReputationAttestation) => import("./tx").MsgRequestReputationAttestationAmino;
+        fromAmino: (object: import("./tx").MsgRequestReputationAttestationAmino) => MsgRequestReputationAttestation;
+    };
+    "/sparkdream.federation.v1.MsgBondVerifier": {
+        aminoType: string;
+        toAmino: (message: MsgBondVerifier) => import("./tx").MsgBondVerifierAmino;
+        fromAmino: (object: import("./tx").MsgBondVerifierAmino) => MsgBondVerifier;
+    };
+    "/sparkdream.federation.v1.MsgUnbondVerifier": {
+        aminoType: string;
+        toAmino: (message: MsgUnbondVerifier) => import("./tx").MsgUnbondVerifierAmino;
+        fromAmino: (object: import("./tx").MsgUnbondVerifierAmino) => MsgUnbondVerifier;
+    };
+    "/sparkdream.federation.v1.MsgVerifyContent": {
+        aminoType: string;
+        toAmino: (message: MsgVerifyContent) => import("./tx").MsgVerifyContentAmino;
+        fromAmino: (object: import("./tx").MsgVerifyContentAmino) => MsgVerifyContent;
+    };
+    "/sparkdream.federation.v1.MsgChallengeVerification": {
+        aminoType: string;
+        toAmino: (message: MsgChallengeVerification) => import("./tx").MsgChallengeVerificationAmino;
+        fromAmino: (object: import("./tx").MsgChallengeVerificationAmino) => MsgChallengeVerification;
+    };
+    "/sparkdream.federation.v1.MsgSubmitArbiterHash": {
+        aminoType: string;
+        toAmino: (message: MsgSubmitArbiterHash) => import("./tx").MsgSubmitArbiterHashAmino;
+        fromAmino: (object: import("./tx").MsgSubmitArbiterHashAmino) => MsgSubmitArbiterHash;
+    };
+    "/sparkdream.federation.v1.MsgEscalateChallenge": {
+        aminoType: string;
+        toAmino: (message: MsgEscalateChallenge) => import("./tx").MsgEscalateChallengeAmino;
+        fromAmino: (object: import("./tx").MsgEscalateChallengeAmino) => MsgEscalateChallenge;
+    };
+    "/sparkdream.federation.v1.MsgUpdateOperationalParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateOperationalParams) => import("./tx").MsgUpdateOperationalParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateOperationalParamsAmino) => MsgUpdateOperationalParams;
+    };
+};