@sparkdreamnft/sparkdreamjs 0.0.35 → 0.0.37

package/sparkdream/rep/v1/review_bounty.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewBountyContribution = exports.ReviewBounty = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseReviewBounty() {
+    return {
+        initiativeId: BigInt(0),
+        amount: "",
+        contributions: [],
+        committed: false
+    };
+}
+/**
+ * ReviewBounty is DREAM escrowed against one initiative to attract reviewer
+ * attention to it.
+ *
+ * The DREAM review fee pays for the act of reviewing at a rate fixed by the
+ * budget. A bounty is how the people who actually want a particular initiative
+ * looked at — its creator, its stakers, anyone — bid that attention up. Review
+ * is the scarcest input in the system once the completion gate is mandatory,
+ * and a flat fee cannot express "this one matters more".
+ *
+ * Paid out per verdict filed and split across the round's reviewers, exactly
+ * like the fee: outcome-blind. A bounty released on successful completion would
+ * be a straightforward bribe to approve, which is the bias the reviewer role
+ * exists to remove.
+ * @name ReviewBounty
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.ReviewBounty
+ */
+exports.ReviewBounty = {
+    typeUrl: "/sparkdream.rep.v1.ReviewBounty",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.initiativeId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.initiativeId);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        for (const v of message.contributions) {
+            exports.ReviewBountyContribution.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.committed === true) {
+            writer.uint32(32).bool(message.committed);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReviewBounty();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.initiativeId = reader.uint64();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                case 3:
+                    message.contributions.push(exports.ReviewBountyContribution.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.committed = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReviewBounty();
+        message.initiativeId = object.initiativeId !== undefined && object.initiativeId !== null ? BigInt(object.initiativeId.toString()) : BigInt(0);
+        message.amount = object.amount ?? "";
+        message.contributions = object.contributions?.map(e => exports.ReviewBountyContribution.fromPartial(e)) || [];
+        message.committed = object.committed ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReviewBounty();
+        if (object.initiative_id !== undefined && object.initiative_id !== null) {
+            message.initiativeId = BigInt(object.initiative_id);
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        message.contributions = object.contributions?.map(e => exports.ReviewBountyContribution.fromAmino(e)) || [];
+        if (object.committed !== undefined && object.committed !== null) {
+            message.committed = object.committed;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.initiative_id = message.initiativeId !== BigInt(0) ? message.initiativeId?.toString() : undefined;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        if (message.contributions) {
+            obj.contributions = message.contributions.map(e => e ? exports.ReviewBountyContribution.toAmino(e) : undefined);
+        }
+        else {
+            obj.contributions = message.contributions;
+        }
+        obj.committed = message.committed === false ? undefined : message.committed;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ReviewBounty.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ReviewBounty.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ReviewBounty.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.ReviewBounty",
+            value: exports.ReviewBounty.encode(message).finish()
+        };
+    }
+};
+function createBaseReviewBountyContribution() {
+    return {
+        funder: "",
+        amount: "",
+        fundedAt: BigInt(0)
+    };
+}
+/**
+ * ReviewBountyContribution is one funder's stake in a bounty.
+ * @name ReviewBountyContribution
+ * @package sparkdream.rep.v1
+ * @see proto type: sparkdream.rep.v1.ReviewBountyContribution
+ */
+exports.ReviewBountyContribution = {
+    typeUrl: "/sparkdream.rep.v1.ReviewBountyContribution",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.funder !== "") {
+            writer.uint32(10).string(message.funder);
+        }
+        if (message.amount !== "") {
+            writer.uint32(18).string(message.amount);
+        }
+        if (message.fundedAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.fundedAt);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReviewBountyContribution();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.funder = reader.string();
+                    break;
+                case 2:
+                    message.amount = reader.string();
+                    break;
+                case 3:
+                    message.fundedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReviewBountyContribution();
+        message.funder = object.funder ?? "";
+        message.amount = object.amount ?? "";
+        message.fundedAt = object.fundedAt !== undefined && object.fundedAt !== null ? BigInt(object.fundedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReviewBountyContribution();
+        if (object.funder !== undefined && object.funder !== null) {
+            message.funder = object.funder;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        if (object.funded_at !== undefined && object.funded_at !== null) {
+            message.fundedAt = BigInt(object.funded_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.funder = message.funder === "" ? undefined : message.funder;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        obj.funded_at = message.fundedAt !== BigInt(0) ? message.fundedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ReviewBountyContribution.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ReviewBountyContribution.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ReviewBountyContribution.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.rep.v1.ReviewBountyContribution",
+            value: exports.ReviewBountyContribution.encode(message).finish()
+        };
+    }
+};

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

@@ -206,6 +206,19 @@ export interface RoleActivity {
     overturnedActions: {
         [key: string]: bigint;
     };
+    /**
+     * last_slash_epoch is the reward epoch (in the units the role's own
+     * reward distribution reads -- see roleRewardEpoch) in which this role
+     * was most recently slashed. Stamped by SlashBond for every role type.
+     *
+     * Reward distributions may use it as a "no pay in an epoch you were
+     * slashed in" gate; only the federation verifier does today. Stamping it
+     * generically anyway is deliberate: it is a property of the bond, the
+     * stamp is one write on a path that is already writing, and a role that
+     * wants the gate should not have to reintroduce a private counter to get
+     * it. Zero means never slashed under the current accounting.
+     */
+    lastSlashEpoch: bigint;
 }
 export interface RoleActivityProtoMsg {
     typeUrl: "/sparkdream.rep.v1.RoleActivity";
@@ -276,6 +289,19 @@ export interface RoleActivityAmino {
     overturned_actions?: {
         [key: string]: string;
     };
+    /**
+     * last_slash_epoch is the reward epoch (in the units the role's own
+     * reward distribution reads -- see roleRewardEpoch) in which this role
+     * was most recently slashed. Stamped by SlashBond for every role type.
+     *
+     * Reward distributions may use it as a "no pay in an epoch you were
+     * slashed in" gate; only the federation verifier does today. Stamping it
+     * generically anyway is deliberate: it is a property of the bond, the
+     * stamp is one write on a path that is already writing, and a role that
+     * wants the gate should not have to reintroduce a private counter to get
+     * it. Zero means never slashed under the current accounting.
+     */
+    last_slash_epoch?: string;
 }
 export interface RoleActivityAminoMsg {
     type: "/sparkdream.rep.v1.RoleActivity";

package/sparkdream/rep/v1/role_activity.js

@@ -402,7 +402,8 @@ function createBaseRoleActivity() {
         epochActions: {},
         totalActions: {},
         upheldActions: {},
-        overturnedActions: {}
+        overturnedActions: {},
+        lastSlashEpoch: BigInt(0)
     };
 }
 /**
@@ -472,6 +473,9 @@ exports.RoleActivity = {
                 value
             }, writer.uint32(88).fork()).ldelim();
         });
+        if (message.lastSlashEpoch !== BigInt(0)) {
+            writer.uint32(96).int64(message.lastSlashEpoch);
+        }
         return writer;
     },
     decode(input, length) {
@@ -526,6 +530,9 @@ exports.RoleActivity = {
                         message.overturnedActions[entry11.key] = entry11.value;
                     }
                     break;
+                case 12:
+                    message.lastSlashEpoch = reader.int64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -566,6 +573,7 @@ exports.RoleActivity = {
             }
             return acc;
         }, {});
+        message.lastSlashEpoch = object.lastSlashEpoch !== undefined && object.lastSlashEpoch !== null ? BigInt(object.lastSlashEpoch.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -613,6 +621,9 @@ exports.RoleActivity = {
             }
             return acc;
         }, {});
+        if (object.last_slash_epoch !== undefined && object.last_slash_epoch !== null) {
+            message.lastSlashEpoch = BigInt(object.last_slash_epoch);
+        }
         return message;
     },
     toAmino(message) {
@@ -653,6 +664,7 @@ exports.RoleActivity = {
                 obj.overturned_actions[k] = v.toString();
             });
         }
+        obj.last_slash_epoch = message.lastSlashEpoch !== BigInt(0) ? message.lastSlashEpoch?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {

package/sparkdream/rep/v1/tag_report.js

@@ -34,7 +34,7 @@ exports.TagReport = {
             writer.uint32(32).bool(message.underReview);
         }
         for (const v of message.reporters) {
-            writer.uint32(82).string(v);
+            writer.uint32(42).string(v);
         }
         return writer;
     },
@@ -57,7 +57,7 @@ exports.TagReport = {
                 case 4:
                     message.underReview = reader.bool();
                     break;
-                case 10:
+                case 5:
                     message.reporters.push(reader.string());
                     break;
                 default: