@sparkdreamnft/sparkdreamjs 0.0.40 → 0.0.42

package/esm/sparkdream/federation/v1/genesis.js

@@ -1,6 +1,6 @@
 //@ts-nocheck
 import { Params } from "./params";
-import { Peer, PeerPolicy, BridgeBinding, FederatedContent, IdentityLink, ReputationAttestation, OutboundAttestation, VerificationRecord } from "./types";
+import { Peer, PeerPolicy, BridgeBinding, FederatedContent, IdentityLink, ReputationAttestation, OutboundAttestation, VerificationRecord, EscalatedChallenge, ArbiterHashSubmission } from "./types";
 import { VerifierActivity } from "./verifier_activity";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 function createBaseGenesisState() {
@@ -18,7 +18,16 @@ function createBaseGenesisState() {
         verificationRecords: [],
         nextContentId: BigInt(0),
         nextOutboundAttestationId: BigInt(0),
-        operatorRewardDayFundingList: []
+        operatorRewardDayFundingList: [],
+        verificationWindowQueue: [],
+        challengeWindowQueue: [],
+        arbiterResolutionQueue: [],
+        arbiterEscalationQueue: [],
+        escalatedChallenges: [],
+        escalatedChallengeDeadlineQueue: [],
+        arbiterSubmissions: [],
+        arbiterHashCounts: [],
+        nextArbiterAnonSubmissionId: BigInt(0)
     };
 }
 /**
@@ -72,6 +81,33 @@ export const GenesisState = {
         for (const v of message.operatorRewardDayFundingList) {
             OperatorRewardDayFunding.encode(v, writer.uint32(114).fork()).ldelim();
         }
+        for (const v of message.verificationWindowQueue) {
+            ContentDeadline.encode(v, writer.uint32(122).fork()).ldelim();
+        }
+        for (const v of message.challengeWindowQueue) {
+            ContentDeadline.encode(v, writer.uint32(130).fork()).ldelim();
+        }
+        for (const v of message.arbiterResolutionQueue) {
+            ContentDeadline.encode(v, writer.uint32(138).fork()).ldelim();
+        }
+        for (const v of message.arbiterEscalationQueue) {
+            ContentDeadline.encode(v, writer.uint32(146).fork()).ldelim();
+        }
+        for (const v of message.escalatedChallenges) {
+            EscalatedChallenge.encode(v, writer.uint32(154).fork()).ldelim();
+        }
+        for (const v of message.escalatedChallengeDeadlineQueue) {
+            ContentDeadline.encode(v, writer.uint32(162).fork()).ldelim();
+        }
+        for (const v of message.arbiterSubmissions) {
+            ArbiterSubmissionEntry.encode(v, writer.uint32(170).fork()).ldelim();
+        }
+        for (const v of message.arbiterHashCounts) {
+            ArbiterHashCount.encode(v, writer.uint32(178).fork()).ldelim();
+        }
+        if (message.nextArbiterAnonSubmissionId !== BigInt(0)) {
+            writer.uint32(184).uint64(message.nextArbiterAnonSubmissionId);
+        }
         return writer;
     },
     decode(input, length) {
@@ -123,6 +159,33 @@ export const GenesisState = {
                 case 14:
                     message.operatorRewardDayFundingList.push(OperatorRewardDayFunding.decode(reader, reader.uint32()));
                     break;
+                case 15:
+                    message.verificationWindowQueue.push(ContentDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 16:
+                    message.challengeWindowQueue.push(ContentDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 17:
+                    message.arbiterResolutionQueue.push(ContentDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 18:
+                    message.arbiterEscalationQueue.push(ContentDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 19:
+                    message.escalatedChallenges.push(EscalatedChallenge.decode(reader, reader.uint32()));
+                    break;
+                case 20:
+                    message.escalatedChallengeDeadlineQueue.push(ContentDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 21:
+                    message.arbiterSubmissions.push(ArbiterSubmissionEntry.decode(reader, reader.uint32()));
+                    break;
+                case 22:
+                    message.arbiterHashCounts.push(ArbiterHashCount.decode(reader, reader.uint32()));
+                    break;
+                case 23:
+                    message.nextArbiterAnonSubmissionId = reader.uint64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -146,6 +209,15 @@ export const GenesisState = {
         message.nextContentId = object.nextContentId !== undefined && object.nextContentId !== null ? BigInt(object.nextContentId.toString()) : BigInt(0);
         message.nextOutboundAttestationId = object.nextOutboundAttestationId !== undefined && object.nextOutboundAttestationId !== null ? BigInt(object.nextOutboundAttestationId.toString()) : BigInt(0);
         message.operatorRewardDayFundingList = object.operatorRewardDayFundingList?.map(e => OperatorRewardDayFunding.fromPartial(e)) || [];
+        message.verificationWindowQueue = object.verificationWindowQueue?.map(e => ContentDeadline.fromPartial(e)) || [];
+        message.challengeWindowQueue = object.challengeWindowQueue?.map(e => ContentDeadline.fromPartial(e)) || [];
+        message.arbiterResolutionQueue = object.arbiterResolutionQueue?.map(e => ContentDeadline.fromPartial(e)) || [];
+        message.arbiterEscalationQueue = object.arbiterEscalationQueue?.map(e => ContentDeadline.fromPartial(e)) || [];
+        message.escalatedChallenges = object.escalatedChallenges?.map(e => EscalatedChallenge.fromPartial(e)) || [];
+        message.escalatedChallengeDeadlineQueue = object.escalatedChallengeDeadlineQueue?.map(e => ContentDeadline.fromPartial(e)) || [];
+        message.arbiterSubmissions = object.arbiterSubmissions?.map(e => ArbiterSubmissionEntry.fromPartial(e)) || [];
+        message.arbiterHashCounts = object.arbiterHashCounts?.map(e => ArbiterHashCount.fromPartial(e)) || [];
+        message.nextArbiterAnonSubmissionId = object.nextArbiterAnonSubmissionId !== undefined && object.nextArbiterAnonSubmissionId !== null ? BigInt(object.nextArbiterAnonSubmissionId.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -172,6 +244,17 @@ export const GenesisState = {
             message.nextOutboundAttestationId = BigInt(object.next_outbound_attestation_id);
         }
         message.operatorRewardDayFundingList = object.operator_reward_day_funding_list?.map(e => OperatorRewardDayFunding.fromAmino(e)) || [];
+        message.verificationWindowQueue = object.verification_window_queue?.map(e => ContentDeadline.fromAmino(e)) || [];
+        message.challengeWindowQueue = object.challenge_window_queue?.map(e => ContentDeadline.fromAmino(e)) || [];
+        message.arbiterResolutionQueue = object.arbiter_resolution_queue?.map(e => ContentDeadline.fromAmino(e)) || [];
+        message.arbiterEscalationQueue = object.arbiter_escalation_queue?.map(e => ContentDeadline.fromAmino(e)) || [];
+        message.escalatedChallenges = object.escalated_challenges?.map(e => EscalatedChallenge.fromAmino(e)) || [];
+        message.escalatedChallengeDeadlineQueue = object.escalated_challenge_deadline_queue?.map(e => ContentDeadline.fromAmino(e)) || [];
+        message.arbiterSubmissions = object.arbiter_submissions?.map(e => ArbiterSubmissionEntry.fromAmino(e)) || [];
+        message.arbiterHashCounts = object.arbiter_hash_counts?.map(e => ArbiterHashCount.fromAmino(e)) || [];
+        if (object.next_arbiter_anon_submission_id !== undefined && object.next_arbiter_anon_submission_id !== null) {
+            message.nextArbiterAnonSubmissionId = BigInt(object.next_arbiter_anon_submission_id);
+        }
         return message;
     },
     toAmino(message) {
@@ -240,6 +323,55 @@ export const GenesisState = {
         else {
             obj.operator_reward_day_funding_list = message.operatorRewardDayFundingList;
         }
+        if (message.verificationWindowQueue) {
+            obj.verification_window_queue = message.verificationWindowQueue.map(e => e ? ContentDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.verification_window_queue = message.verificationWindowQueue;
+        }
+        if (message.challengeWindowQueue) {
+            obj.challenge_window_queue = message.challengeWindowQueue.map(e => e ? ContentDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.challenge_window_queue = message.challengeWindowQueue;
+        }
+        if (message.arbiterResolutionQueue) {
+            obj.arbiter_resolution_queue = message.arbiterResolutionQueue.map(e => e ? ContentDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.arbiter_resolution_queue = message.arbiterResolutionQueue;
+        }
+        if (message.arbiterEscalationQueue) {
+            obj.arbiter_escalation_queue = message.arbiterEscalationQueue.map(e => e ? ContentDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.arbiter_escalation_queue = message.arbiterEscalationQueue;
+        }
+        if (message.escalatedChallenges) {
+            obj.escalated_challenges = message.escalatedChallenges.map(e => e ? EscalatedChallenge.toAmino(e) : undefined);
+        }
+        else {
+            obj.escalated_challenges = message.escalatedChallenges;
+        }
+        if (message.escalatedChallengeDeadlineQueue) {
+            obj.escalated_challenge_deadline_queue = message.escalatedChallengeDeadlineQueue.map(e => e ? ContentDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.escalated_challenge_deadline_queue = message.escalatedChallengeDeadlineQueue;
+        }
+        if (message.arbiterSubmissions) {
+            obj.arbiter_submissions = message.arbiterSubmissions.map(e => e ? ArbiterSubmissionEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.arbiter_submissions = message.arbiterSubmissions;
+        }
+        if (message.arbiterHashCounts) {
+            obj.arbiter_hash_counts = message.arbiterHashCounts.map(e => e ? ArbiterHashCount.toAmino(e) : undefined);
+        }
+        else {
+            obj.arbiter_hash_counts = message.arbiterHashCounts;
+        }
+        obj.next_arbiter_anon_submission_id = message.nextArbiterAnonSubmissionId !== BigInt(0) ? message.nextArbiterAnonSubmissionId?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {
@@ -258,6 +390,269 @@ export const GenesisState = {
         };
     }
 };
+function createBaseContentDeadline() {
+    return {
+        deadline: BigInt(0),
+        contentId: BigInt(0)
+    };
+}
+/**
+ * ContentDeadline is one (deadline, content_id) entry of a federation
+ * EndBlocker time queue. All four verification-lifecycle queues share this
+ * shape, so they share this message.
+ * @name ContentDeadline
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.ContentDeadline
+ */
+export const ContentDeadline = {
+    typeUrl: "/sparkdream.federation.v1.ContentDeadline",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.deadline !== BigInt(0)) {
+            writer.uint32(8).int64(message.deadline);
+        }
+        if (message.contentId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.contentId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseContentDeadline();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.deadline = reader.int64();
+                    break;
+                case 2:
+                    message.contentId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseContentDeadline();
+        message.deadline = object.deadline !== undefined && object.deadline !== null ? BigInt(object.deadline.toString()) : BigInt(0);
+        message.contentId = object.contentId !== undefined && object.contentId !== null ? BigInt(object.contentId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseContentDeadline();
+        if (object.deadline !== undefined && object.deadline !== null) {
+            message.deadline = BigInt(object.deadline);
+        }
+        if (object.content_id !== undefined && object.content_id !== null) {
+            message.contentId = BigInt(object.content_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.deadline = message.deadline !== BigInt(0) ? message.deadline?.toString() : undefined;
+        obj.content_id = message.contentId !== BigInt(0) ? message.contentId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ContentDeadline.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ContentDeadline.decode(message.value);
+    },
+    toProto(message) {
+        return ContentDeadline.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.federation.v1.ContentDeadline",
+            value: ContentDeadline.encode(message).finish()
+        };
+    }
+};
+function createBaseArbiterSubmissionEntry() {
+    return {
+        submitterKey: "",
+        submission: ArbiterHashSubmission.fromPartial({})
+    };
+}
+/**
+ * ArbiterSubmissionEntry is one ArbiterSubmissions map entry. The submitter
+ * key is part of the STATE key rather than of ArbiterHashSubmission —
+ * identified arbiters key by bech32 address, anonymous ones by "anon:<seq>"
+ * (where the Operator field holds the shield module address instead) — so it
+ * must be exported alongside the value or the "no double vote per operator"
+ * rule cannot be reconstructed.
+ * @name ArbiterSubmissionEntry
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.ArbiterSubmissionEntry
+ */
+export const ArbiterSubmissionEntry = {
+    typeUrl: "/sparkdream.federation.v1.ArbiterSubmissionEntry",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.submitterKey !== "") {
+            writer.uint32(10).string(message.submitterKey);
+        }
+        if (message.submission !== undefined) {
+            ArbiterHashSubmission.encode(message.submission, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseArbiterSubmissionEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.submitterKey = reader.string();
+                    break;
+                case 2:
+                    message.submission = ArbiterHashSubmission.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseArbiterSubmissionEntry();
+        message.submitterKey = object.submitterKey ?? "";
+        message.submission = object.submission !== undefined && object.submission !== null ? ArbiterHashSubmission.fromPartial(object.submission) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseArbiterSubmissionEntry();
+        if (object.submitter_key !== undefined && object.submitter_key !== null) {
+            message.submitterKey = object.submitter_key;
+        }
+        if (object.submission !== undefined && object.submission !== null) {
+            message.submission = ArbiterHashSubmission.fromAmino(object.submission);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.submitter_key = message.submitterKey === "" ? undefined : message.submitterKey;
+        obj.submission = message.submission ? ArbiterHashSubmission.toAmino(message.submission) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ArbiterSubmissionEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ArbiterSubmissionEntry.decode(message.value);
+    },
+    toProto(message) {
+        return ArbiterSubmissionEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.federation.v1.ArbiterSubmissionEntry",
+            value: ArbiterSubmissionEntry.encode(message).finish()
+        };
+    }
+};
+function createBaseArbiterHashCount() {
+    return {
+        contentId: BigInt(0),
+        contentHash: "",
+        count: 0
+    };
+}
+/**
+ * ArbiterHashCount is one (content_id, content_hash) -> votes tally from the
+ * arbiter quorum counter.
+ * @name ArbiterHashCount
+ * @package sparkdream.federation.v1
+ * @see proto type: sparkdream.federation.v1.ArbiterHashCount
+ */
+export const ArbiterHashCount = {
+    typeUrl: "/sparkdream.federation.v1.ArbiterHashCount",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.contentId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.contentId);
+        }
+        if (message.contentHash !== "") {
+            writer.uint32(18).string(message.contentHash);
+        }
+        if (message.count !== 0) {
+            writer.uint32(24).uint32(message.count);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseArbiterHashCount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contentId = reader.uint64();
+                    break;
+                case 2:
+                    message.contentHash = reader.string();
+                    break;
+                case 3:
+                    message.count = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseArbiterHashCount();
+        message.contentId = object.contentId !== undefined && object.contentId !== null ? BigInt(object.contentId.toString()) : BigInt(0);
+        message.contentHash = object.contentHash ?? "";
+        message.count = object.count ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseArbiterHashCount();
+        if (object.content_id !== undefined && object.content_id !== null) {
+            message.contentId = BigInt(object.content_id);
+        }
+        if (object.content_hash !== undefined && object.content_hash !== null) {
+            message.contentHash = object.content_hash;
+        }
+        if (object.count !== undefined && object.count !== null) {
+            message.count = object.count;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.content_id = message.contentId !== BigInt(0) ? message.contentId?.toString() : undefined;
+        obj.content_hash = message.contentHash === "" ? undefined : message.contentHash;
+        obj.count = message.count === 0 ? undefined : message.count;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ArbiterHashCount.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ArbiterHashCount.decode(message.value);
+    },
+    toProto(message) {
+        return ArbiterHashCount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.federation.v1.ArbiterHashCount",
+            value: ArbiterHashCount.encode(message).finish()
+        };
+    }
+};
 function createBaseOperatorRewardDayFunding() {
     return {
         day: BigInt(0),

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

@@ -998,7 +998,11 @@ export const QueryGetFederatedContentResponse = {
 };
 function createBaseQueryListFederatedContentRequest() {
     return {
-        pagination: undefined
+        pagination: undefined,
+        peerId: "",
+        contentType: "",
+        creatorIdentity: "",
+        status: ""
     };
 }
 /**
@@ -1012,6 +1016,18 @@ export const QueryListFederatedContentRequest = {
         if (message.pagination !== undefined) {
             PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
         }
+        if (message.peerId !== "") {
+            writer.uint32(18).string(message.peerId);
+        }
+        if (message.contentType !== "") {
+            writer.uint32(26).string(message.contentType);
+        }
+        if (message.creatorIdentity !== "") {
+            writer.uint32(34).string(message.creatorIdentity);
+        }
+        if (message.status !== "") {
+            writer.uint32(42).string(message.status);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1024,6 +1040,18 @@ export const QueryListFederatedContentRequest = {
                 case 1:
                     message.pagination = PageRequest.decode(reader, reader.uint32());
                     break;
+                case 2:
+                    message.peerId = reader.string();
+                    break;
+                case 3:
+                    message.contentType = reader.string();
+                    break;
+                case 4:
+                    message.creatorIdentity = reader.string();
+                    break;
+                case 5:
+                    message.status = reader.string();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1034,6 +1062,10 @@ export const QueryListFederatedContentRequest = {
     fromPartial(object) {
         const message = createBaseQueryListFederatedContentRequest();
         message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        message.peerId = object.peerId ?? "";
+        message.contentType = object.contentType ?? "";
+        message.creatorIdentity = object.creatorIdentity ?? "";
+        message.status = object.status ?? "";
         return message;
     },
     fromAmino(object) {
@@ -1041,11 +1073,27 @@ export const QueryListFederatedContentRequest = {
         if (object.pagination !== undefined && object.pagination !== null) {
             message.pagination = PageRequest.fromAmino(object.pagination);
         }
+        if (object.peer_id !== undefined && object.peer_id !== null) {
+            message.peerId = object.peer_id;
+        }
+        if (object.content_type !== undefined && object.content_type !== null) {
+            message.contentType = object.content_type;
+        }
+        if (object.creator_identity !== undefined && object.creator_identity !== null) {
+            message.creatorIdentity = object.creator_identity;
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        obj.peer_id = message.peerId === "" ? undefined : message.peerId;
+        obj.content_type = message.contentType === "" ? undefined : message.contentType;
+        obj.creator_identity = message.creatorIdentity === "" ? undefined : message.creatorIdentity;
+        obj.status = message.status === "" ? undefined : message.status;
         return obj;
     },
     fromAminoMsg(object) {

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

@@ -57,15 +57,25 @@ export class LCDQueryClient {
         return await this.req.get(endpoint);
     };
     /* ListFederatedContent */
-    listFederatedContent = async (params = {
-        pagination: undefined
-    }) => {
+    listFederatedContent = async (params) => {
         const options = {
             params: {}
         };
         if (typeof params?.pagination !== "undefined") {
             setPaginationParams(options, params.pagination);
         }
+        if (typeof params?.peerId !== "undefined") {
+            options.params.peer_id = params.peerId;
+        }
+        if (typeof params?.contentType !== "undefined") {
+            options.params.content_type = params.contentType;
+        }
+        if (typeof params?.creatorIdentity !== "undefined") {
+            options.params.creator_identity = params.creatorIdentity;
+        }
+        if (typeof params?.status !== "undefined") {
+            options.params.status = params.status;
+        }
         const endpoint = `sparkdream/federation/v1/list_federated_content`;
         return await this.req.get(endpoint, options);
     };

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

@@ -53,9 +53,7 @@ export class QueryClientImpl {
         return promise.then(data => QueryGetFederatedContentResponse.decode(new BinaryReader(data)));
     };
     /* ListFederatedContent */
-    listFederatedContent = async (request = {
-        pagination: undefined
-    }) => {
+    listFederatedContent = async (request) => {
         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)));