@sparkdreamnft/sparkdreamjs 0.0.44 → 0.0.45

package/sparkdream/bundle.d.ts

@@ -15190,6 +15190,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
+                    revokeInvitation(value: _471.MsgRevokeInvitation): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
                 };
                 withTypeUrl: {
                     updateParams(value: _471.MsgUpdateParams): {
@@ -15424,6 +15428,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _471.MsgReclaimInitiativeBounty;
                     };
+                    revokeInvitation(value: _471.MsgRevokeInvitation): {
+                        typeUrl: string;
+                        value: _471.MsgRevokeInvitation;
+                    };
                 };
                 fromPartial: {
                     updateParams(value: _471.MsgUpdateParams): {
@@ -15658,6 +15666,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _471.MsgReclaimInitiativeBounty;
                     };
+                    revokeInvitation(value: _471.MsgRevokeInvitation): {
+                        typeUrl: string;
+                        value: _471.MsgRevokeInvitation;
+                    };
                 };
             };
             AminoConverter: {
@@ -17454,6 +17466,32 @@ export declare namespace sparkdream {
                 toProto(message: _471.MsgReclaimInitiativeBountyResponse): Uint8Array;
                 toProtoMsg(message: _471.MsgReclaimInitiativeBountyResponse): _471.MsgReclaimInitiativeBountyResponseProtoMsg;
             };
+            MsgRevokeInvitation: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _471.MsgRevokeInvitation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _471.MsgRevokeInvitation;
+                fromPartial(object: import("../helpers").DeepPartial<_471.MsgRevokeInvitation>): _471.MsgRevokeInvitation;
+                fromAmino(object: _471.MsgRevokeInvitationAmino): _471.MsgRevokeInvitation;
+                toAmino(message: _471.MsgRevokeInvitation): _471.MsgRevokeInvitationAmino;
+                fromAminoMsg(object: _471.MsgRevokeInvitationAminoMsg): _471.MsgRevokeInvitation;
+                toAminoMsg(message: _471.MsgRevokeInvitation): _471.MsgRevokeInvitationAminoMsg;
+                fromProtoMsg(message: _471.MsgRevokeInvitationProtoMsg): _471.MsgRevokeInvitation;
+                toProto(message: _471.MsgRevokeInvitation): Uint8Array;
+                toProtoMsg(message: _471.MsgRevokeInvitation): _471.MsgRevokeInvitationProtoMsg;
+            };
+            MsgRevokeInvitationResponse: {
+                typeUrl: string;
+                encode(_: _471.MsgRevokeInvitationResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _471.MsgRevokeInvitationResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_471.MsgRevokeInvitationResponse>): _471.MsgRevokeInvitationResponse;
+                fromAmino(_: _471.MsgRevokeInvitationResponseAmino): _471.MsgRevokeInvitationResponse;
+                toAmino(_: _471.MsgRevokeInvitationResponse): _471.MsgRevokeInvitationResponseAmino;
+                fromAminoMsg(object: _471.MsgRevokeInvitationResponseAminoMsg): _471.MsgRevokeInvitationResponse;
+                fromProtoMsg(message: _471.MsgRevokeInvitationResponseProtoMsg): _471.MsgRevokeInvitationResponse;
+                toProto(message: _471.MsgRevokeInvitationResponse): Uint8Array;
+                toProtoMsg(message: _471.MsgRevokeInvitationResponse): _471.MsgRevokeInvitationResponseProtoMsg;
+            };
             Tag: {
                 typeUrl: string;
                 encode(message: _470.Tag, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
@@ -25264,6 +25302,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
+                    withdrawBond(value: _521.MsgWithdrawBond): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
                     reportOperator(value: _521.MsgReportOperator): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
@@ -25322,6 +25364,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _521.MsgTopUpBond;
                     };
+                    withdrawBond(value: _521.MsgWithdrawBond): {
+                        typeUrl: string;
+                        value: _521.MsgWithdrawBond;
+                    };
                     reportOperator(value: _521.MsgReportOperator): {
                         typeUrl: string;
                         value: _521.MsgReportOperator;
@@ -25380,6 +25426,10 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _521.MsgTopUpBond;
                     };
+                    withdrawBond(value: _521.MsgWithdrawBond): {
+                        typeUrl: string;
+                        value: _521.MsgWithdrawBond;
+                    };
                     reportOperator(value: _521.MsgReportOperator): {
                         typeUrl: string;
                         value: _521.MsgReportOperator;
@@ -25446,6 +25496,11 @@ export declare namespace sparkdream {
                     toAmino: (message: _521.MsgTopUpBond) => _521.MsgTopUpBondAmino;
                     fromAmino: (object: _521.MsgTopUpBondAmino) => _521.MsgTopUpBond;
                 };
+                "/sparkdream.service.v1.MsgWithdrawBond": {
+                    aminoType: string;
+                    toAmino: (message: _521.MsgWithdrawBond) => _521.MsgWithdrawBondAmino;
+                    fromAmino: (object: _521.MsgWithdrawBondAmino) => _521.MsgWithdrawBond;
+                };
                 "/sparkdream.service.v1.MsgReportOperator": {
                     aminoType: string;
                     toAmino: (message: _521.MsgReportOperator) => _521.MsgReportOperatorAmino;
@@ -25692,6 +25747,32 @@ export declare namespace sparkdream {
                 toProto(message: _521.MsgTopUpBondResponse): Uint8Array;
                 toProtoMsg(message: _521.MsgTopUpBondResponse): _521.MsgTopUpBondResponseProtoMsg;
             };
+            MsgWithdrawBond: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _521.MsgWithdrawBond, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _521.MsgWithdrawBond;
+                fromPartial(object: import("../helpers").DeepPartial<_521.MsgWithdrawBond>): _521.MsgWithdrawBond;
+                fromAmino(object: _521.MsgWithdrawBondAmino): _521.MsgWithdrawBond;
+                toAmino(message: _521.MsgWithdrawBond): _521.MsgWithdrawBondAmino;
+                fromAminoMsg(object: _521.MsgWithdrawBondAminoMsg): _521.MsgWithdrawBond;
+                toAminoMsg(message: _521.MsgWithdrawBond): _521.MsgWithdrawBondAminoMsg;
+                fromProtoMsg(message: _521.MsgWithdrawBondProtoMsg): _521.MsgWithdrawBond;
+                toProto(message: _521.MsgWithdrawBond): Uint8Array;
+                toProtoMsg(message: _521.MsgWithdrawBond): _521.MsgWithdrawBondProtoMsg;
+            };
+            MsgWithdrawBondResponse: {
+                typeUrl: string;
+                encode(_: _521.MsgWithdrawBondResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _521.MsgWithdrawBondResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_521.MsgWithdrawBondResponse>): _521.MsgWithdrawBondResponse;
+                fromAmino(_: _521.MsgWithdrawBondResponseAmino): _521.MsgWithdrawBondResponse;
+                toAmino(_: _521.MsgWithdrawBondResponse): _521.MsgWithdrawBondResponseAmino;
+                fromAminoMsg(object: _521.MsgWithdrawBondResponseAminoMsg): _521.MsgWithdrawBondResponse;
+                fromProtoMsg(message: _521.MsgWithdrawBondResponseProtoMsg): _521.MsgWithdrawBondResponse;
+                toProto(message: _521.MsgWithdrawBondResponse): Uint8Array;
+                toProtoMsg(message: _521.MsgWithdrawBondResponse): _521.MsgWithdrawBondResponseProtoMsg;
+            };
             MsgReportOperator: {
                 typeUrl: string;
                 aminoType: string;
@@ -27207,6 +27288,18 @@ export declare namespace sparkdream {
                 toProto(message: _525.OneshotExec): Uint8Array;
                 toProtoMsg(message: _525.OneshotExec): _525.OneshotExecProtoMsg;
             };
+            SignInPayload: {
+                typeUrl: string;
+                encode(message: _525.SignInPayload, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _525.SignInPayload;
+                fromPartial(object: import("../helpers").DeepPartial<_525.SignInPayload>): _525.SignInPayload;
+                fromAmino(object: _525.SignInPayloadAmino): _525.SignInPayload;
+                toAmino(message: _525.SignInPayload): _525.SignInPayloadAmino;
+                fromAminoMsg(object: _525.SignInPayloadAminoMsg): _525.SignInPayload;
+                fromProtoMsg(message: _525.SignInPayloadProtoMsg): _525.SignInPayload;
+                toProto(message: _525.SignInPayload): Uint8Array;
+                toProtoMsg(message: _525.SignInPayload): _525.SignInPayloadProtoMsg;
+            };
             GenesisState: {
                 typeUrl: string;
                 encode(message: _524.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
@@ -27563,6 +27656,30 @@ export declare namespace sparkdream {
                 toProto(message: _535.DKGVoteExtension): Uint8Array;
                 toProtoMsg(message: _535.DKGVoteExtension): _535.DKGVoteExtensionProtoMsg;
             };
+            DKGJustification: {
+                typeUrl: string;
+                encode(message: _535.DKGJustification, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _535.DKGJustification;
+                fromPartial(object: import("../helpers").DeepPartial<_535.DKGJustification>): _535.DKGJustification;
+                fromAmino(object: _535.DKGJustificationAmino): _535.DKGJustification;
+                toAmino(message: _535.DKGJustification): _535.DKGJustificationAmino;
+                fromAminoMsg(object: _535.DKGJustificationAminoMsg): _535.DKGJustification;
+                fromProtoMsg(message: _535.DKGJustificationProtoMsg): _535.DKGJustification;
+                toProto(message: _535.DKGJustification): Uint8Array;
+                toProtoMsg(message: _535.DKGJustification): _535.DKGJustificationProtoMsg;
+            };
+            DKGComplaint: {
+                typeUrl: string;
+                encode(message: _535.DKGComplaint, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _535.DKGComplaint;
+                fromPartial(object: import("../helpers").DeepPartial<_535.DKGComplaint>): _535.DKGComplaint;
+                fromAmino(object: _535.DKGComplaintAmino): _535.DKGComplaint;
+                toAmino(message: _535.DKGComplaint): _535.DKGComplaintAmino;
+                fromAminoMsg(object: _535.DKGComplaintAminoMsg): _535.DKGComplaint;
+                fromProtoMsg(message: _535.DKGComplaintProtoMsg): _535.DKGComplaint;
+                toProto(message: _535.DKGComplaint): Uint8Array;
+                toProtoMsg(message: _535.DKGComplaint): _535.DKGComplaintProtoMsg;
+            };
             InjectedDKGData: {
                 typeUrl: string;
                 encode(message: _535.InjectedDKGData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
@@ -27635,6 +27752,18 @@ export declare namespace sparkdream {
                 toProto(message: _535.TLEMissCounterEntry): Uint8Array;
                 toProtoMsg(message: _535.TLEMissCounterEntry): _535.TLEMissCounterEntryProtoMsg;
             };
+            DecryptionDemandEntry: {
+                typeUrl: string;
+                encode(message: _535.DecryptionDemandEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _535.DecryptionDemandEntry;
+                fromPartial(object: import("../helpers").DeepPartial<_535.DecryptionDemandEntry>): _535.DecryptionDemandEntry;
+                fromAmino(object: _535.DecryptionDemandEntryAmino): _535.DecryptionDemandEntry;
+                toAmino(message: _535.DecryptionDemandEntry): _535.DecryptionDemandEntryAmino;
+                fromAminoMsg(object: _535.DecryptionDemandEntryAminoMsg): _535.DecryptionDemandEntry;
+                fromProtoMsg(message: _535.DecryptionDemandEntryProtoMsg): _535.DecryptionDemandEntry;
+                toProto(message: _535.DecryptionDemandEntry): Uint8Array;
+                toProtoMsg(message: _535.DecryptionDemandEntry): _535.DecryptionDemandEntryProtoMsg;
+            };
             MsgUpdateParams: {
                 typeUrl: string;
                 aminoType: string;

package/sparkdream/client.d.ts

@@ -161,6 +161,11 @@ export declare const sparkdreamAminoConverters: {
         toAmino: (message: import("./service/v1/tx").MsgTopUpBond) => import("./service/v1/tx").MsgTopUpBondAmino;
         fromAmino: (object: import("./service/v1/tx").MsgTopUpBondAmino) => import("./service/v1/tx").MsgTopUpBond;
     };
+    "/sparkdream.service.v1.MsgWithdrawBond": {
+        aminoType: string;
+        toAmino: (message: import("./service/v1/tx").MsgWithdrawBond) => import("./service/v1/tx").MsgWithdrawBondAmino;
+        fromAmino: (object: import("./service/v1/tx").MsgWithdrawBondAmino) => import("./service/v1/tx").MsgWithdrawBond;
+    };
     "/sparkdream.service.v1.MsgReportOperator": {
         aminoType: string;
         toAmino: (message: import("./service/v1/tx").MsgReportOperator) => import("./service/v1/tx").MsgReportOperatorAmino;

package/sparkdream/name/v1/genesis.d.ts

@@ -1,7 +1,7 @@
 import { Params, ParamsAmino } from "./params";
 import { NameRecord, NameRecordAmino } from "./name_record";
 import { OwnerInfo, OwnerInfoAmino } from "./owner_info";
-import { Dispute, DisputeAmino } from "./dispute";
+import { Dispute, DisputeAmino, DisputeStake, DisputeStakeAmino, ContestStake, ContestStakeAmino } from "./dispute";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 import { DeepPartial } from "../../../helpers";
 /**
@@ -18,6 +18,17 @@ export interface GenesisState {
     nameRecords: NameRecord[];
     ownerInfos: OwnerInfo[];
     disputeMap: Dispute[];
+    /**
+     * dispute_stakes are the claimants' locked DREAM stakes for open disputes,
+     * keyed by challenge_id. Exported so a chain export/import does not strand
+     * locked funds.
+     */
+    disputeStakes: DisputeStake[];
+    /**
+     * contest_stakes are the owners' locked DREAM stakes for contested disputes,
+     * keyed by challenge_id.
+     */
+    contestStakes: ContestStake[];
 }
 export interface GenesisStateProtoMsg {
     typeUrl: "/sparkdream.name.v1.GenesisState";
@@ -37,6 +48,17 @@ export interface GenesisStateAmino {
     name_records?: NameRecordAmino[];
     owner_infos?: OwnerInfoAmino[];
     dispute_map?: DisputeAmino[];
+    /**
+     * dispute_stakes are the claimants' locked DREAM stakes for open disputes,
+     * keyed by challenge_id. Exported so a chain export/import does not strand
+     * locked funds.
+     */
+    dispute_stakes?: DisputeStakeAmino[];
+    /**
+     * contest_stakes are the owners' locked DREAM stakes for contested disputes,
+     * keyed by challenge_id.
+     */
+    contest_stakes?: ContestStakeAmino[];
 }
 export interface GenesisStateAminoMsg {
     type: "/sparkdream.name.v1.GenesisState";

package/sparkdream/name/v1/genesis.js

@@ -12,7 +12,9 @@ function createBaseGenesisState() {
         params: params_1.Params.fromPartial({}),
         nameRecords: [],
         ownerInfos: [],
-        disputeMap: []
+        disputeMap: [],
+        disputeStakes: [],
+        contestStakes: []
     };
 }
 /**
@@ -36,6 +38,12 @@ exports.GenesisState = {
         for (const v of message.disputeMap) {
             dispute_1.Dispute.encode(v, writer.uint32(34).fork()).ldelim();
         }
+        for (const v of message.disputeStakes) {
+            dispute_1.DisputeStake.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.contestStakes) {
+            dispute_1.ContestStake.encode(v, writer.uint32(50).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -57,6 +65,12 @@ exports.GenesisState = {
                 case 4:
                     message.disputeMap.push(dispute_1.Dispute.decode(reader, reader.uint32()));
                     break;
+                case 5:
+                    message.disputeStakes.push(dispute_1.DisputeStake.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.contestStakes.push(dispute_1.ContestStake.decode(reader, reader.uint32()));
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -70,6 +84,8 @@ exports.GenesisState = {
         message.nameRecords = object.nameRecords?.map(e => name_record_1.NameRecord.fromPartial(e)) || [];
         message.ownerInfos = object.ownerInfos?.map(e => owner_info_1.OwnerInfo.fromPartial(e)) || [];
         message.disputeMap = object.disputeMap?.map(e => dispute_1.Dispute.fromPartial(e)) || [];
+        message.disputeStakes = object.disputeStakes?.map(e => dispute_1.DisputeStake.fromPartial(e)) || [];
+        message.contestStakes = object.contestStakes?.map(e => dispute_1.ContestStake.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
@@ -80,6 +96,8 @@ exports.GenesisState = {
         message.nameRecords = object.name_records?.map(e => name_record_1.NameRecord.fromAmino(e)) || [];
         message.ownerInfos = object.owner_infos?.map(e => owner_info_1.OwnerInfo.fromAmino(e)) || [];
         message.disputeMap = object.dispute_map?.map(e => dispute_1.Dispute.fromAmino(e)) || [];
+        message.disputeStakes = object.dispute_stakes?.map(e => dispute_1.DisputeStake.fromAmino(e)) || [];
+        message.contestStakes = object.contest_stakes?.map(e => dispute_1.ContestStake.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
@@ -103,6 +121,18 @@ exports.GenesisState = {
         else {
             obj.dispute_map = message.disputeMap;
         }
+        if (message.disputeStakes) {
+            obj.dispute_stakes = message.disputeStakes.map(e => e ? dispute_1.DisputeStake.toAmino(e) : undefined);
+        }
+        else {
+            obj.dispute_stakes = message.disputeStakes;
+        }
+        if (message.contestStakes) {
+            obj.contest_stakes = message.contestStakes.map(e => e ? dispute_1.ContestStake.toAmino(e) : undefined);
+        }
+        else {
+            obj.contest_stakes = message.contestStakes;
+        }
         return obj;
     },
     fromAminoMsg(object) {

package/sparkdream/rep/v1/params.d.ts

@@ -860,6 +860,14 @@ export interface Params {
     minInitiativeBountyContribution: string;
     maxInitiativeBountyContributions: number;
     initiativeBountyReclaimDelay: bigint;
+    /**
+     * invitation_acceptance_epochs is how many epochs a PENDING invitation
+     * stays open. Once it passes, the epoch-end sweep marks it EXPIRED,
+     * unlocks the inviter's staked DREAM, restores the spent invitation
+     * credit and frees the invitee address for a new invitation. 0 disables
+     * expiry.
+     */
+    invitationAcceptanceEpochs: bigint;
 }
 export interface ParamsProtoMsg {
     typeUrl: "/sparkdream.rep.v1.Params";
@@ -1635,6 +1643,14 @@ export interface ParamsAmino {
     min_initiative_bounty_contribution?: string;
     max_initiative_bounty_contributions?: number;
     initiative_bounty_reclaim_delay?: string;
+    /**
+     * invitation_acceptance_epochs is how many epochs a PENDING invitation
+     * stays open. Once it passes, the epoch-end sweep marks it EXPIRED,
+     * unlocks the inviter's staked DREAM, restores the spent invitation
+     * credit and frees the invitee address for a new invitation. 0 disables
+     * expiry.
+     */
+    invitation_acceptance_epochs?: string;
 }
 export interface ParamsAminoMsg {
     type: "sparkdream/x/rep/Params";

package/sparkdream/rep/v1/params.js

@@ -471,7 +471,8 @@ function createBaseParams() {
         maxInitiativeBountyPerFunderEpoch: "",
         minInitiativeBountyContribution: "",
         maxInitiativeBountyContributions: 0,
-        initiativeBountyReclaimDelay: BigInt(0)
+        initiativeBountyReclaimDelay: BigInt(0),
+        invitationAcceptanceEpochs: BigInt(0)
     };
 }
 /**
@@ -928,6 +929,9 @@ exports.Params = {
         if (message.initiativeBountyReclaimDelay !== BigInt(0)) {
             writer.uint32(1184).uint64(message.initiativeBountyReclaimDelay);
         }
+        if (message.invitationAcceptanceEpochs !== BigInt(0)) {
+            writer.uint32(1192).int64(message.invitationAcceptanceEpochs);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1381,6 +1385,9 @@ exports.Params = {
                 case 148:
                     message.initiativeBountyReclaimDelay = reader.uint64();
                     break;
+                case 149:
+                    message.invitationAcceptanceEpochs = reader.int64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -1538,6 +1545,7 @@ exports.Params = {
         message.minInitiativeBountyContribution = object.minInitiativeBountyContribution ?? "";
         message.maxInitiativeBountyContributions = object.maxInitiativeBountyContributions ?? 0;
         message.initiativeBountyReclaimDelay = object.initiativeBountyReclaimDelay !== undefined && object.initiativeBountyReclaimDelay !== null ? BigInt(object.initiativeBountyReclaimDelay.toString()) : BigInt(0);
+        message.invitationAcceptanceEpochs = object.invitationAcceptanceEpochs !== undefined && object.invitationAcceptanceEpochs !== null ? BigInt(object.invitationAcceptanceEpochs.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -1986,6 +1994,9 @@ exports.Params = {
         if (object.initiative_bounty_reclaim_delay !== undefined && object.initiative_bounty_reclaim_delay !== null) {
             message.initiativeBountyReclaimDelay = BigInt(object.initiative_bounty_reclaim_delay);
         }
+        if (object.invitation_acceptance_epochs !== undefined && object.invitation_acceptance_epochs !== null) {
+            message.invitationAcceptanceEpochs = BigInt(object.invitation_acceptance_epochs);
+        }
         return message;
     },
     toAmino(message) {
@@ -2138,6 +2149,7 @@ exports.Params = {
         obj.min_initiative_bounty_contribution = message.minInitiativeBountyContribution === "" ? undefined : message.minInitiativeBountyContribution;
         obj.max_initiative_bounty_contributions = message.maxInitiativeBountyContributions === 0 ? undefined : message.maxInitiativeBountyContributions;
         obj.initiative_bounty_reclaim_delay = message.initiativeBountyReclaimDelay !== BigInt(0) ? message.initiativeBountyReclaimDelay?.toString() : undefined;
+        obj.invitation_acceptance_epochs = message.invitationAcceptanceEpochs !== BigInt(0) ? message.invitationAcceptanceEpochs?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {

package/sparkdream/rep/v1/tx.d.ts

@@ -3520,6 +3520,60 @@ export interface MsgReclaimInitiativeBountyResponseAminoMsg {
     type: "/sparkdream.rep.v1.MsgReclaimInitiativeBountyResponse";
     value: MsgReclaimInitiativeBountyResponseAmino;
 }
+/**
+ * MsgRevokeInvitation withdraws a PENDING invitation. Only the inviter may
+ * revoke; an accepted, expired or already-revoked invitation is rejected.
+ * @name MsgRevokeInvitation
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitation
+ */
+export interface MsgRevokeInvitation {
+    inviter: string;
+    invitationId: bigint;
+}
+export interface MsgRevokeInvitationProtoMsg {
+    typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitation";
+    value: Uint8Array;
+}
+/**
+ * MsgRevokeInvitation withdraws a PENDING invitation. Only the inviter may
+ * revoke; an accepted, expired or already-revoked invitation is rejected.
+ * @name MsgRevokeInvitationAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitation
+ */
+export interface MsgRevokeInvitationAmino {
+    inviter?: string;
+    invitation_id?: string;
+}
+export interface MsgRevokeInvitationAminoMsg {
+    type: "sparkdream/x/rep/MsgRevokeInvitation";
+    value: MsgRevokeInvitationAmino;
+}
+/**
+ * MsgRevokeInvitationResponse defines the MsgRevokeInvitationResponse message.
+ * @name MsgRevokeInvitationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitationResponse
+ */
+export interface MsgRevokeInvitationResponse {
+}
+export interface MsgRevokeInvitationResponseProtoMsg {
+    typeUrl: "/sparkdream.rep.v1.MsgRevokeInvitationResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgRevokeInvitationResponse defines the MsgRevokeInvitationResponse message.
+ * @name MsgRevokeInvitationResponseAmino
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitationResponse
+ */
+export interface MsgRevokeInvitationResponseAmino {
+}
+export interface MsgRevokeInvitationResponseAminoMsg {
+    type: "/sparkdream.rep.v1.MsgRevokeInvitationResponse";
+    value: MsgRevokeInvitationResponseAmino;
+}
 /**
  * MsgUpdateParams is the Msg/UpdateParams request type.
  * @name MsgUpdateParams
@@ -5807,3 +5861,42 @@ export declare const MsgReclaimInitiativeBountyResponse: {
     toProto(message: MsgReclaimInitiativeBountyResponse): Uint8Array;
     toProtoMsg(message: MsgReclaimInitiativeBountyResponse): MsgReclaimInitiativeBountyResponseProtoMsg;
 };
+/**
+ * MsgRevokeInvitation withdraws a PENDING invitation. Only the inviter may
+ * revoke; an accepted, expired or already-revoked invitation is rejected.
+ * @name MsgRevokeInvitation
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitation
+ */
+export declare const MsgRevokeInvitation: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: MsgRevokeInvitation, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeInvitation;
+    fromPartial(object: DeepPartial<MsgRevokeInvitation>): MsgRevokeInvitation;
+    fromAmino(object: MsgRevokeInvitationAmino): MsgRevokeInvitation;
+    toAmino(message: MsgRevokeInvitation): MsgRevokeInvitationAmino;
+    fromAminoMsg(object: MsgRevokeInvitationAminoMsg): MsgRevokeInvitation;
+    toAminoMsg(message: MsgRevokeInvitation): MsgRevokeInvitationAminoMsg;
+    fromProtoMsg(message: MsgRevokeInvitationProtoMsg): MsgRevokeInvitation;
+    toProto(message: MsgRevokeInvitation): Uint8Array;
+    toProtoMsg(message: MsgRevokeInvitation): MsgRevokeInvitationProtoMsg;
+};
+/**
+ * MsgRevokeInvitationResponse defines the MsgRevokeInvitationResponse message.
+ * @name MsgRevokeInvitationResponse
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.MsgRevokeInvitationResponse
+ */
+export declare const MsgRevokeInvitationResponse: {
+    typeUrl: string;
+    encode(_: MsgRevokeInvitationResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeInvitationResponse;
+    fromPartial(_: DeepPartial<MsgRevokeInvitationResponse>): MsgRevokeInvitationResponse;
+    fromAmino(_: MsgRevokeInvitationResponseAmino): MsgRevokeInvitationResponse;
+    toAmino(_: MsgRevokeInvitationResponse): MsgRevokeInvitationResponseAmino;
+    fromAminoMsg(object: MsgRevokeInvitationResponseAminoMsg): MsgRevokeInvitationResponse;
+    fromProtoMsg(message: MsgRevokeInvitationResponseProtoMsg): MsgRevokeInvitationResponse;
+    toProto(message: MsgRevokeInvitationResponse): Uint8Array;
+    toProtoMsg(message: MsgRevokeInvitationResponse): MsgRevokeInvitationResponseProtoMsg;
+};