@sparkdreamnft/sparkdreamjs 0.0.8 → 0.0.9

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

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

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

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

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

@@ -0,0 +1,139 @@
+//@ts-nocheck
+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 const AminoConverter = {
+    "/sparkdream.federation.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/federation/MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgRegisterPeer": {
+        aminoType: "/sparkdream.federation.v1.MsgRegisterPeer",
+        toAmino: MsgRegisterPeer.toAmino,
+        fromAmino: MsgRegisterPeer.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgRemovePeer": {
+        aminoType: "/sparkdream.federation.v1.MsgRemovePeer",
+        toAmino: MsgRemovePeer.toAmino,
+        fromAmino: MsgRemovePeer.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgSuspendPeer": {
+        aminoType: "/sparkdream.federation.v1.MsgSuspendPeer",
+        toAmino: MsgSuspendPeer.toAmino,
+        fromAmino: MsgSuspendPeer.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgResumePeer": {
+        aminoType: "/sparkdream.federation.v1.MsgResumePeer",
+        toAmino: MsgResumePeer.toAmino,
+        fromAmino: MsgResumePeer.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUpdatePeerPolicy": {
+        aminoType: "/sparkdream.federation.v1.MsgUpdatePeerPolicy",
+        toAmino: MsgUpdatePeerPolicy.toAmino,
+        fromAmino: MsgUpdatePeerPolicy.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgRegisterBridge": {
+        aminoType: "/sparkdream.federation.v1.MsgRegisterBridge",
+        toAmino: MsgRegisterBridge.toAmino,
+        fromAmino: MsgRegisterBridge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgRevokeBridge": {
+        aminoType: "/sparkdream.federation.v1.MsgRevokeBridge",
+        toAmino: MsgRevokeBridge.toAmino,
+        fromAmino: MsgRevokeBridge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgSlashBridge": {
+        aminoType: "/sparkdream.federation.v1.MsgSlashBridge",
+        toAmino: MsgSlashBridge.toAmino,
+        fromAmino: MsgSlashBridge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUpdateBridge": {
+        aminoType: "/sparkdream.federation.v1.MsgUpdateBridge",
+        toAmino: MsgUpdateBridge.toAmino,
+        fromAmino: MsgUpdateBridge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUnbondBridge": {
+        aminoType: "/sparkdream.federation.v1.MsgUnbondBridge",
+        toAmino: MsgUnbondBridge.toAmino,
+        fromAmino: MsgUnbondBridge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgTopUpBridgeStake": {
+        aminoType: "/sparkdream.federation.v1.MsgTopUpBridgeStake",
+        toAmino: MsgTopUpBridgeStake.toAmino,
+        fromAmino: MsgTopUpBridgeStake.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgSubmitFederatedContent": {
+        aminoType: "/sparkdream.federation.v1.MsgSubmitFederatedContent",
+        toAmino: MsgSubmitFederatedContent.toAmino,
+        fromAmino: MsgSubmitFederatedContent.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgFederateContent": {
+        aminoType: "/sparkdream.federation.v1.MsgFederateContent",
+        toAmino: MsgFederateContent.toAmino,
+        fromAmino: MsgFederateContent.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgAttestOutbound": {
+        aminoType: "/sparkdream.federation.v1.MsgAttestOutbound",
+        toAmino: MsgAttestOutbound.toAmino,
+        fromAmino: MsgAttestOutbound.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgModerateContent": {
+        aminoType: "/sparkdream.federation.v1.MsgModerateContent",
+        toAmino: MsgModerateContent.toAmino,
+        fromAmino: MsgModerateContent.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgLinkIdentity": {
+        aminoType: "/sparkdream.federation.v1.MsgLinkIdentity",
+        toAmino: MsgLinkIdentity.toAmino,
+        fromAmino: MsgLinkIdentity.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUnlinkIdentity": {
+        aminoType: "/sparkdream.federation.v1.MsgUnlinkIdentity",
+        toAmino: MsgUnlinkIdentity.toAmino,
+        fromAmino: MsgUnlinkIdentity.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgConfirmIdentityLink": {
+        aminoType: "/sparkdream.federation.v1.MsgConfirmIdentityLink",
+        toAmino: MsgConfirmIdentityLink.toAmino,
+        fromAmino: MsgConfirmIdentityLink.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgRequestReputationAttestation": {
+        aminoType: "/sparkdream.federation.v1.MsgRequestReputationAttestation",
+        toAmino: MsgRequestReputationAttestation.toAmino,
+        fromAmino: MsgRequestReputationAttestation.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgBondVerifier": {
+        aminoType: "/sparkdream.federation.v1.MsgBondVerifier",
+        toAmino: MsgBondVerifier.toAmino,
+        fromAmino: MsgBondVerifier.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUnbondVerifier": {
+        aminoType: "/sparkdream.federation.v1.MsgUnbondVerifier",
+        toAmino: MsgUnbondVerifier.toAmino,
+        fromAmino: MsgUnbondVerifier.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgVerifyContent": {
+        aminoType: "/sparkdream.federation.v1.MsgVerifyContent",
+        toAmino: MsgVerifyContent.toAmino,
+        fromAmino: MsgVerifyContent.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgChallengeVerification": {
+        aminoType: "/sparkdream.federation.v1.MsgChallengeVerification",
+        toAmino: MsgChallengeVerification.toAmino,
+        fromAmino: MsgChallengeVerification.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgSubmitArbiterHash": {
+        aminoType: "/sparkdream.federation.v1.MsgSubmitArbiterHash",
+        toAmino: MsgSubmitArbiterHash.toAmino,
+        fromAmino: MsgSubmitArbiterHash.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgEscalateChallenge": {
+        aminoType: "/sparkdream.federation.v1.MsgEscalateChallenge",
+        toAmino: MsgEscalateChallenge.toAmino,
+        fromAmino: MsgEscalateChallenge.fromAmino
+    },
+    "/sparkdream.federation.v1.MsgUpdateOperationalParams": {
+        aminoType: "/sparkdream.federation.v1.MsgUpdateOperationalParams",
+        toAmino: MsgUpdateOperationalParams.toAmino,
+        fromAmino: MsgUpdateOperationalParams.fromAmino
+    }
+};