boardmod.gno

  1package kourtv3
  2import "strconv"
  3const (
  4	freezeMaxBlocks = int64(17_280) / 2
  5	freezeGapBlocks = freezeMaxBlocks
  6)
  7func mustBoardModInvariants() {
  8	if freezeMaxBlocks >= 17_280 {
  9		panic("kourtv3: a board freeze must expire inside the nomination window")
 10	}
 11	if freezeGapBlocks < freezeMaxBlocks {
 12		panic("kourtv3: the gap between freezes must be at least one freeze long, " +
 13			"or the ceiling is a formality")
 14	}
 15}
 16func init() { mustBoardModInvariants() }
 17func speechM(cm *courtMod) int {
 18	m := cm.m
 19	if m < 2 {
 20		m = 2
 21	}
 22	if m > cm.n {
 23		m = cm.n
 24	}
 25	return m
 26}
 27func SpeechThreshold(courtSlug string) int {
 28	c := mustCourt(courtSlug)
 29	if c.mod == nil {
 30		return 0
 31	}
 32	return speechM(c.mod)
 33}
 34func boardSanctionEpochOf(c *Court) int64 {
 35	if c.mod == nil {
 36		return 0
 37	}
 38	return c.mod.boardSanctionEpoch
 39}
 40func boardFreezeActive(r *standingRow) bool {
 41	passed, known := pastDeadline(r.frozenUntilTime, 0)
 42	return (known && !passed) || (!known && heightNow() < r.frozenUntil)
 43}
 44func boardFreezeGapOpen(r *standingRow) bool {
 45	passed, known := pastDeadline(r.frozenGapUntilTime, 0)
 46	return (known && !passed) || (!known && heightNow() < r.frozenGapUntil)
 47}
 48func boardFrozen(c *Court, who address) bool {
 49	r := lookupStanding(c, who)
 50	if r == nil || r.frozenUntil == 0 {
 51		return false
 52	}
 53	if r.frozenEpoch != boardSanctionEpochOf(c) {
 54		return false
 55	}
 56	return boardFreezeActive(r)
 57}
 58func boardFrozenAt(c *Court, who address) (at, atHeight int64) {
 59	if !boardFrozen(c, who) {
 60		return 0, 0
 61	}
 62	r := lookupStanding(c, who)
 63	return r.frozenUntilTime, r.frozenUntil
 64}
 65func BoardFrozenUntil(courtSlug string, who address) (at, atHeight int64) {
 66	return boardFrozenAt(mustCourt(courtSlug), who)
 67}
 68func claimFreezeActive(clm *claimMod) bool {
 69	passed, known := pastDeadline(clm.boardFrozenUntilTime, 0)
 70	return (known && !passed) || (!known && heightNow() < clm.boardFrozenUntil)
 71}
 72func claimFreezeGapOpen(clm *claimMod) bool {
 73	passed, known := pastDeadline(clm.boardFrozenGapUntilTime, 0)
 74	return (known && !passed) || (!known && heightNow() < clm.boardFrozenGapUntil)
 75}
 76func claimBoardFrozen(c *Court, claimID uint64) bool {
 77	if c.mod == nil {
 78		return false
 79	}
 80	clm := lookupClaimMod(c.mod, claimID)
 81	if clm == nil || clm.boardFrozenUntil == 0 {
 82		return false
 83	}
 84	if clm.boardFrozenEpoch != c.mod.boardSanctionEpoch {
 85		return false
 86	}
 87	return claimFreezeActive(clm)
 88}
 89func claimBoardFrozenAt(c *Court, claimID uint64) (at, atHeight int64) {
 90	if !claimBoardFrozen(c, claimID) {
 91		return 0, 0
 92	}
 93	clm := lookupClaimMod(c.mod, claimID)
 94	return clm.boardFrozenUntilTime, clm.boardFrozenUntil
 95}
 96func ClaimBoardFrozenUntil(courtSlug string, claimID uint64) (at, atHeight int64) {
 97	return claimBoardFrozenAt(mustCourt(courtSlug), claimID)
 98}
 99func HideBoardRow(cur realm, courtSlug string, claimID, rowID uint64, code string) {
100	if !cur.IsCurrent() {
101		panic(errStaleRealm)
102	}
103	who := cur.Previous().Address()
104	c := mustCourt(courtSlug)
105	cm := ensureMod(c)
106	requireActiveMod(cm, who)
107	mustBoardCode(code)
108	cs := mustClaim(c, claimID)
109	r := mustBoardRow(cs, rowID)
110	if r.hiddenByMod {
111		panic("kourtv3: that comment is already hidden")
112	}
113	fire, _ := approveAction(cm.pending,
114		"boardhide:"+strconv.FormatUint(claimID, 10)+":"+strconv.FormatUint(rowID, 10),
115		who, code, speechM(cm))
116	if !fire {
117		return
118	}
119	r.hiddenByMod = true
120	scoreIndexDrop(cs, r)
121	ensureClaimMod(c, cm, claimID).
122		appendLog(who, boardActCode("board-hide", rowID, code), "")
123	emitModAct(c.id, claimID, "board-hide", who)
124}
125func UnhideBoardRow(cur realm, courtSlug string, claimID, rowID uint64) {
126	if !cur.IsCurrent() {
127		panic(errStaleRealm)
128	}
129	who := cur.Previous().Address()
130	c := mustCourt(courtSlug)
131	cm := ensureMod(c)
132	requireMod(cm, who)
133	cs := mustClaim(c, claimID)
134	r := mustBoardRow(cs, rowID)
135	if !r.hiddenByMod {
136		panic("kourtv3: that comment is not hidden")
137	}
138	fire, _ := approveAction(cm.pending,
139		"boardunhide:"+strconv.FormatUint(claimID, 10)+":"+strconv.FormatUint(rowID, 10),
140		who, "", speechM(cm))
141	if !fire {
142		return
143	}
144	r.hiddenByMod = false
145	scoreIndexPut(cs, r)
146	ensureClaimMod(c, cm, claimID).
147		appendLog(who, boardActCode("board-unhide", rowID, ""), "")
148	emitModAct(c.id, claimID, "board-unhide", who)
149}
150func SlashStanding(cur realm, courtSlug string, who address, levels int64, code string) {
151	if !cur.IsCurrent() {
152		panic(errStaleRealm)
153	}
154	actor := cur.Previous().Address()
155	if levels < 1 || levels > 3 {
156		panic("kourtv3: a slash is 1, 2 or 3 whole levels")
157	}
158	c := mustCourt(courtSlug)
159	cm := ensureMod(c)
160	requireActiveMod(cm, actor)
161	mustBoardCode(code)
162	if who == "" {
163		panic("kourtv3: no such address")
164	}
165	fire, voted := approveAction(cm.pending,
166		"slash:"+who.String()+":"+strconv.FormatInt(levels, 10),
167		actor, code, speechM(cm))
168	if !fire {
169		return
170	}
171	r := getStanding(c, who)
172	target := postLevel(c, who) - levels
173	if target < 0 {
174		target = 0
175	}
176	if want := levelFloor(c, target); r.score > want {
177		r.score = want
178	}
179	if target == 0 {
180		r.passHeld = false
181	}
182	cm.appendCourtLog(actor, "slash:"+strconv.FormatInt(levels, 10), voted)
183	emitModAct(c.id, 0, "slash", actor)
184}
185func levelFloor(c *Court, lv int64) int64 {
186	if lv <= 0 {
187		return 0
188	}
189	l := ladderFor(c)
190	sup, _ := boardSupply(c)
191	switch lv {
192	case 1:
193		return sup * l.t1Bps / 10_000
194	case 2:
195		return sup * l.t2Bps / 10_000
196	}
197	return sup * l.t3Bps / 10_000
198}
199func RestoreStanding(cur realm, courtSlug string, who address) int64 {
200	if !cur.IsCurrent() {
201		panic(errStaleRealm)
202	}
203	actor := cur.Previous().Address()
204	c := mustCourt(courtSlug)
205	cm := ensureMod(c)
206	requireMod(cm, actor)
207	r := lookupStanding(c, who)
208	if r == nil || r.score >= r.highWater {
209		panic("kourtv3: that address has nothing to restore")
210	}
211	fire, _ := approveAction(cm.pending, "restore:"+who.String(), actor, "",
212		speechM(cm))
213	if !fire {
214		return 0
215	}
216	r.score = r.highWater
217	cm.appendCourtLog(actor, "restore", "")
218	emitModAct(c.id, 0, "restore", actor)
219	return r.score
220}
221func FreezeBoard(cur realm, courtSlug string, who address, blocks int64, code string) {
222	if !cur.IsCurrent() {
223		panic(errStaleRealm)
224	}
225	actor := cur.Previous().Address()
226	if blocks < 1 || blocks > freezeMaxBlocks {
227		panic("kourtv3: a board freeze is at most freezeMaxBlocks long")
228	}
229	c := mustCourt(courtSlug)
230	cm := ensureMod(c)
231	requireActiveMod(cm, actor)
232	mustBoardCode(code)
233	if who == "" {
234		panic("kourtv3: no such address")
235	}
236	now := heightNow()
237	if r := lookupStanding(c, who); r != nil && boardFreezeGapOpen(r) {
238		panic("kourtv3: this address was frozen too recently; the ceiling is not a formality")
239	}
240	fire, voted := approveAction(cm.pending, "freeze:"+who.String(), actor, code,
241		speechM(cm))
242	if !fire {
243		return
244	}
245	r := getStanding(c, who)
246	r.frozenUntil = now + blocks
247	r.frozenUntilTime = nowTime() + blocksToSecs(blocks)
248	r.frozenEpoch = boardSanctionEpochOf(c)
249	r.frozenGapUntil = now + freezeMaxBlocks + freezeGapBlocks
250	r.frozenGapUntilTime = nowTime() + blocksToSecs(freezeMaxBlocks+freezeGapBlocks)
251	cm.appendCourtLog(actor, "freeze:"+strconv.FormatInt(blocks, 10), voted)
252	emitModAct(c.id, 0, "freeze", actor)
253}
254func UnfreezeBoard(cur realm, courtSlug string, who address) {
255	if !cur.IsCurrent() {
256		panic(errStaleRealm)
257	}
258	actor := cur.Previous().Address()
259	c := mustCourt(courtSlug)
260	cm := ensureMod(c)
261	requireMod(cm, actor)
262	if !boardFrozen(c, who) {
263		panic("kourtv3: that address is not frozen")
264	}
265	fire, _ := approveAction(cm.pending, "unfreeze:"+who.String(), actor, "",
266		speechM(cm))
267	if !fire {
268		return
269	}
270	lifted := lookupStanding(c, who)
271	lifted.frozenUntil = 0
272	lifted.frozenUntilTime = 0
273	cm.appendCourtLog(actor, "unfreeze", "")
274	emitModAct(c.id, 0, "unfreeze", actor)
275}
276func FreezeClaimBoard(cur realm, courtSlug string, claimID uint64, blocks int64, code string) {
277	if !cur.IsCurrent() {
278		panic(errStaleRealm)
279	}
280	actor := cur.Previous().Address()
281	if blocks < 1 || blocks > freezeMaxBlocks {
282		panic("kourtv3: a board freeze is at most freezeMaxBlocks long")
283	}
284	c := mustCourt(courtSlug)
285	cm := ensureMod(c)
286	requireActiveMod(cm, actor)
287	mustBoardCode(code)
288	_ = mustClaim(c, claimID)
289	now := heightNow()
290	if prev := lookupClaimMod(cm, claimID); prev != nil && claimFreezeGapOpen(prev) {
291		panic("kourtv3: this board was frozen too recently; the ceiling is not a formality")
292	}
293	fire, _ := approveAction(cm.pending,
294		"freezeboard:"+strconv.FormatUint(claimID, 10), actor, code, speechM(cm))
295	if !fire {
296		return
297	}
298	clm := ensureClaimMod(c, cm, claimID)
299	clm.boardFrozenUntil = now + blocks
300	clm.boardFrozenUntilTime = nowTime() + blocksToSecs(blocks)
301	clm.boardFrozenEpoch = cm.boardSanctionEpoch
302	clm.boardFrozenGapUntil = now + freezeMaxBlocks + freezeGapBlocks
303	clm.boardFrozenGapUntilTime = nowTime() + blocksToSecs(freezeMaxBlocks+freezeGapBlocks)
304	clm.appendLog(actor, "freezeboard:"+strconv.FormatInt(blocks, 10)+":"+code, "")
305	emitModAct(c.id, claimID, "freezeboard", actor)
306}
307func ThawClaimBoard(cur realm, courtSlug string, claimID uint64) {
308	if !cur.IsCurrent() {
309		panic(errStaleRealm)
310	}
311	actor := cur.Previous().Address()
312	c := mustCourt(courtSlug)
313	cm := ensureMod(c)
314	requireMod(cm, actor)
315	if !claimBoardFrozen(c, claimID) {
316		panic("kourtv3: that board is not frozen")
317	}
318	fire, _ := approveAction(cm.pending,
319		"thawboard:"+strconv.FormatUint(claimID, 10), actor, "", speechM(cm))
320	if !fire {
321		return
322	}
323	thawed := lookupClaimMod(cm, claimID)
324	thawed.boardFrozenUntil = 0
325	thawed.boardFrozenUntilTime = 0
326	ensureClaimMod(c, cm, claimID).appendLog(actor, "thawboard", "")
327	emitModAct(c.id, claimID, "thawboard", actor)
328}
329func GlobalClearBoardBits(cur realm, courtSlug string) int64 {
330	if !cur.IsCurrent() {
331		panic(errStaleRealm)
332	}
333	who := cur.Previous().Address()
334	if !isGlobalMod(who) {
335		panic("kourtv3: only a global DAO member may clear board bits (recovery)")
336	}
337	c := mustCourt(courtSlug)
338	cm := ensureMod(c)
339	cm.boardSanctionEpoch++
340	cm.appendCourtLog(who, "global-clear-board-bits", "")
341	emitGlobalAct(c.id, 0, "clear-board-bits", who)
342	return cm.boardSanctionEpoch
343}
344func GlobalRestoreStanding(cur realm, courtSlug string, who address) int64 {
345	if !cur.IsCurrent() {
346		panic(errStaleRealm)
347	}
348	actor := cur.Previous().Address()
349	if !isGlobalMod(actor) {
350		panic("kourtv3: only a global DAO member may restore standing (recovery)")
351	}
352	c := mustCourt(courtSlug)
353	r := lookupStanding(c, who)
354	if r == nil || r.score >= r.highWater {
355		panic("kourtv3: that address has nothing to restore")
356	}
357	r.score = r.highWater
358	ensureMod(c).appendCourtLog(actor, "global-restore-standing", "")
359	emitGlobalAct(c.id, 0, "restore-standing", actor)
360	return r.score
361}
362func mustBoardWritable(c *Court, cs *claimState, who address) {
363	if claimBoardFrozen(c, cs.id) {
364		panic("kourtv3: this claim's board is frozen by moderators")
365	}
366	if boardFrozen(c, who) {
367		panic("kourtv3: you are frozen out of this court's boards")
368	}
369}
370func PurgeCourtLogRow(cur realm, courtSlug string, rowID uint64, categoryCode string) {
371	if !cur.IsCurrent() {
372		panic(errStaleRealm)
373	}
374	who := cur.Previous().Address()
375	d := ensureGlobalDAO()
376	if !d.members.Has(who.String()) {
377		panic("kourtv3: only a global DAO member may purge")
378	}
379	mustCategoryCode(categoryCode)
380	c := mustCourt(courtSlug)
381	cm := ensureMod(c)
382	idx := -1
383	for i := range cm.log {
384		if cm.log[i].rowID == rowID {
385			idx = i
386			break
387		}
388	}
389	if idx < 0 {
390		panic("kourtv3: no such court log row")
391	}
392	if cm.log[idx].purged {
393		return
394	}
395	fire, code := approveAction(d.pending,
396		"purgecourtrow:"+c.id+":"+strconv.FormatUint(rowID, 10),
397		who, categoryCode, d.purgeM)
398	if !fire {
399		return
400	}
401	cm.log[idx].purged = true
402	cm.log[idx].reason = ""
403	cm.appendCourtLog(who, "purgecourtrow:"+code, "")
404	emitPurge(c.id, 0, code, who)
405}
406func GlobalClearCourtParams(cur realm, courtSlug string) {
407	if !cur.IsCurrent() {
408		panic(errStaleRealm)
409	}
410	who := cur.Previous().Address()
411	if !isGlobalMod(who) {
412		panic("kourtv3: only a global DAO member may clear court parameters (recovery)")
413	}
414	c := mustCourt(courtSlug)
415	if c.ladder == nil && c.creditRates == nil {
416		panic("kourtv3: this court has no parameter overrides")
417	}
418	c.ladder, c.creditRates = nil, nil
419	ensureMod(c).appendCourtLog(who, "global-clear-params", "")
420	emitGlobalAct(c.id, 0, "clear-court-params", who)
421}