bubblerumble3.gno
33.66 Kb · 1049 lines
1// Package bubblerumble3 is the third Bubble Rumble realm. v2's money stays:
2// of every bid 55% goes to the pot, 30% is paid at once to the pool's earlier
3// bidders pro-rata to what they paid in, 10% to whoever invited the bidder,
4// 5% to the pool's creator. What v3 adds:
5//
6// - A last day. Every pool has a life (creator-set, 1h..30d) that starts at
7// its first bid. The pool closes when its clock runs out OR its life does,
8// whichever comes first. While the life runs out, the winner's share slides
9// toward nothing and that part of the pot is instead split among all the
10// pool's bidders pro-rata to what they paid in. A pool still contested on
11// its last day ends as a shared pot, so nobody is stuck in a loop and bots
12// gain nothing by outlasting people.
13// - Flag war. At the close, TeamShare of the pot goes to the OTHER bidders
14// who flew the winner's flag, pro-rata by paid-in; the winner never takes
15// it. A winner whose flag nobody else flew hands it to all the other
16// bidders instead, so a private flag buys nothing. A flag is locked per
17// pool at the first bid there. The winner's own part is what slides.
18// - Rebidding on yourself is allowed (it pays the others as any bid does).
19// - Earnings are credited, not pushed: dividends, team shares and the
20// close split accrue to each address and Withdraw sends them, so no bid or
21// close ever loops over a hundred transfers, and nothing can brick a pool.
22// - A bid's clock can be shortened by paying more, but never under MinClock,
23// so paying up is never a way to close a pool before anyone can answer.
24// - Shots. A bid may carry extra money as a shot at the bubble: a chance to
25// pop it at once. The chance is 0.8 × shot / prize, at most 1% a shot,
26// where the prize is the pot or ShotCap, whichever is smaller; a pot over
27// ShotCap pays a ShotCap slice instead of popping. The shot goes into the
28// pot, hit or miss, and every miss is counted on the bubble.
29//
30// The draw is the chain's block time, which on tm2 is the median of the
31// validators' vote timestamps for the block before: public one block
32// ahead, and nudgeable by a validator who is the median vote. Two things
33// follow. A shot is drawn only in the blocks ShotDelay to ShotDelay+
34// ShotWindow after it was paid for, by whoever touches the pool then, and
35// is void after that: a shooter cannot wait for a block whose time suits
36// them, and the two blocks of leeway are worth less than the bid a shot
37// must ride on. And the prize is capped at ShotCap, small enough that a
38// validator grinding a timestamp is stealing lunch money, with SetShots as
39// the switch if one does. Raise the cap when gno.land has real randomness.
40package bubblerumble3
41
42import (
43 "chain"
44 "chain/banker"
45 "chain/runtime"
46 "chain/runtime/unsafe"
47 "crypto/sha256"
48 "encoding/binary"
49 "math"
50 "math/bits"
51 "strconv"
52 "strings"
53 "time"
54)
55
56const (
57 MinWindow int64 = 10 // seconds
58 MaxWindow int64 = 30 * 24 * 3600 // 30 days
59 MinLife int64 = 3600 // an hour
60 MaxLife int64 = 30 * 24 * 3600 // 30 days
61 MinBasePrice int64 = 1_000 // ugnot, 0.001 GNOT
62 MaxBasePrice int64 = 1_000_000_000_000 // ugnot, 1,000,000 GNOT
63 MaxNameLen = 40
64 HistoryLen = 50 // bids kept per pool for the feed
65 RosterMax = 100 // distinct bidders a pool pays dividends, team shares and the close split to
66 MaxBoost int64 = 10 // the shortest clock a bid can buy is window/MaxBoost...
67 MinClock int64 = 300 // ...and never under five minutes: people must be able to answer
68
69 // where every bid goes, in percent
70 PotShare int64 = 55
71 DivShare int64 = 30 // to earlier bidders of the pool, pro-rata by weight
72 RefShare int64 = 10 // to the bidder's inviter
73 CreatorShare int64 = 5
74 // of the pot at the close, to the other bidders under the winner's flag
75 TeamShare int64 = 35
76
77 ShotCap int64 = 10_000_000 // ugnot: the most a shot can take, 10 GNOT
78 ShotMaxBps int64 = 100 // 1% a shot, whatever is paid
79 ShotFair int64 = 8000 // chance in bps = ShotFair × shot / prize (0.8 of fair odds)
80 ShotDelay int64 = 3 // blocks after the shot was paid for before it can be drawn...
81 ShotWindow int64 = 2 // ...and how many more blocks it may still be drawn in
82)
83
84// admin is the realm's deployer: the only address that may turn shots off.
85const admin = address("g1leu8d2vsplhehcfkjg50mwgdpxdkt8tztu95wr")
86
87// pkgPath must match gnomod.toml: the realm's own address derives from it.
88const pkgPath = "gno.land/r/g1leu8d2vsplhehcfkjg50mwgdpxdkt8tztu95wr/bubblerumble3"
89
90type Entry struct {
91 N int64
92 Bidder address
93 Flag string
94 Price int64 // what was paid for the bid itself; at least the price at the time
95 Shot int64 // extra paid for a chance to pop the bubble
96 Clock int64 // seconds this bid had to stand
97 Pot int64 // pot right after this bid
98 At time.Time
99}
100
101// Member is a distinct bidder of a pool: dividends, team shares and the close
102// split go to the roster. The flag is the one flown at the first bid here.
103type Member struct {
104 Addr address
105 Flag string
106 Paid int64 // gross paid into this pool (bids and shots)
107 Earned int64 // dividends received from this pool
108}
109
110// Shot is a shot at the bubble waiting to be drawn, or drawn.
111type Shot struct {
112 N int64 // 1-based within the pool
113 Bidder address
114 Paid int64 // ugnot paid for it
115 Prize int64 // what it plays for: the pot then, or ShotCap
116 Bps int64 // chance, in basis points
117 CommitH int64 // block height when paid
118 Resolved bool
119 Won bool
120 DrawH int64
121}
122
123type Pool struct {
124 ID int64
125 Name string
126 Creator address
127 Window int64 // seconds the last bid must stand to win
128 Life int64 // seconds from the first bid to the last day
129 BasePrice int64 // ugnot; the Nth bid costs BasePrice·√N
130 Seed int64
131 Pot int64
132 Bids int64
133 LastBidder address
134 LastBidAt time.Time
135 FirstBidAt time.Time
136 Clock int64 // seconds the current top bid has to stand
137 CreatedAt time.Time
138 Paid bool // the pot went out, or the seed back to the creator
139 Cancelled bool
140 Popped bool // a shot ended it
141 PoppedAt time.Time
142 DivPaid int64 // dividends paid out of this pool so far
143 RefPaid int64
144 CreatorPaid int64
145 ShotPaid int64 // slices paid to hits while the pool went on
146 Misses int64 // shots drawn and lost: the scars on the bubble
147 WinnerFlag string
148 TeamPaid int64 // what the winner's team received at the close
149 SharedPaid int64 // the pro-rata part of the close
150 WinnerPaid int64
151 History []Entry
152 Roster []*Member
153 Shots []*Shot
154}
155
156// Player is what the realm remembers about an address across pools.
157type Player struct {
158 Referrer address // set by the first bid, permanent
159 Recruits int64
160 Flag string
161 Bids int64
162 Paid int64
163 DivEarned int64
164 RefEarned int64
165 Won int64 // pots, team shares, close splits and shot slices received
166 Shots int64
167 Hits int64
168 Owed int64 // credited and not yet withdrawn
169 Withdrawn int64
170}
171
172var (
173 shotsOn = true
174 pools []*Pool
175 players = map[address]*Player{}
176 teamPaid = map[string]int64{} // flag -> gross bid volume under it
177 teamWon = map[string]int64{} // flag -> pots closed under it
178 teamSize = map[string]int64{} // flag -> players flying it
179 realmAddr = chain.PackageAddress(pkgPath)
180)
181
182// Price of the next bid in a pool with the given base price and n bids so far.
183func Price(base, n int64) int64 {
184 return int64(math.Ceil(float64(base) * math.Sqrt(float64(n+1))))
185}
186
187// LastDay is when the pool's life runs out; zero before the first bid.
188func (p *Pool) LastDay() time.Time {
189 if p.FirstBidAt.IsZero() {
190 return time.Time{}
191 }
192 return p.FirstBidAt.Add(time.Duration(p.Life) * time.Second)
193}
194
195// Deadline is when the pool closes if nothing changes: the clock or the last
196// day, whichever comes first; the pop, if a shot ended it.
197func (p *Pool) Deadline() time.Time {
198 if p.Popped {
199 return p.PoppedAt
200 }
201 d := p.LastBidAt.Add(time.Duration(p.Clock) * time.Second)
202 if last := p.LastDay(); !last.IsZero() && last.Before(d) {
203 return last
204 }
205 return d
206}
207
208func (p *Pool) Over() bool { return p.Bids > 0 && (p.Popped || !time.Now().Before(p.Deadline())) }
209func (p *Pool) NextPrice() int64 { return Price(p.BasePrice, p.Bids) }
210
211// LiveBps is how much of the pot still goes the winner's way, in basis points
212// of the pot: 10000 at the first bid, sliding to 0 on the last day. Frozen at
213// the close.
214func (p *Pool) LiveBps() int64 {
215 if p.FirstBidAt.IsZero() || p.Life <= 0 {
216 return 10000
217 }
218 at := time.Now()
219 if p.Over() {
220 at = p.Deadline()
221 }
222 elapsed := at.Unix() - p.FirstBidAt.Unix()
223 if elapsed <= 0 {
224 return 10000
225 }
226 if elapsed >= p.Life {
227 return 0
228 }
229 return 10000 * (p.Life - elapsed) / p.Life
230}
231
232// ClockFor is the clock a bid buys by paying sent against a price: the window
233// divided by the multiple paid, never below window/MaxBoost.
234func ClockFor(window, price, sent int64) int64 {
235 c := int64(float64(window) * float64(price) / float64(sent))
236 if c < window/MaxBoost {
237 c = window / MaxBoost
238 }
239 if c < MinClock {
240 c = MinClock
241 }
242 if c > window {
243 c = window
244 }
245 return c
246}
247
248// mulDiv is a×b/c without overflowing on the way: pots and paid-ins are both
249// in ugnot and their product passes int64 at a few thousand GNOT each.
250func mulDiv(a, b, c int64) int64 {
251 if a < 0 || b < 0 || c <= 0 {
252 panic("mulDiv: negative")
253 }
254 hi, lo := bits.Mul64(uint64(a), uint64(b))
255 if hi >= uint64(c) {
256 panic("mulDiv: overflow")
257 }
258 q, _ := bits.Div64(hi, lo, uint64(c))
259 return int64(q)
260}
261
262// ShotBps is the chance a shot buys against a prize, in basis points.
263func ShotBps(shot, prize int64) int64 {
264 if shot <= 0 || prize <= 0 {
265 return 0
266 }
267 bps := ShotFair * shot / prize
268 if bps > ShotMaxBps {
269 bps = ShotMaxBps
270 }
271 return bps
272}
273
274// CreatePool opens a pool. Any ugnot sent with the call seeds its pot. The
275// creator earns CreatorShare of every bid. life is the pool's life in seconds
276// from its first bid; 0 means ten windows (at least an hour, at most 30 days).
277func CreatePool(cur realm, name string, window int64, basePrice int64, life int64) int64 {
278 creator := userCaller(cur)
279 name = cleanName(name)
280 if window < MinWindow || window > MaxWindow {
281 panic("window must be between 10s and 30d")
282 }
283 if basePrice < MinBasePrice || basePrice > MaxBasePrice {
284 panic("base price must be between 0.001 and 1,000,000 GNOT")
285 }
286 if life == 0 { // ten windows of fighting, within the bounds
287 life = 10 * window
288 if life < MinLife {
289 life = MinLife
290 }
291 if life > MaxLife {
292 life = MaxLife
293 }
294 }
295 if life < MinLife || life > MaxLife {
296 panic("life must be between 1h and 30d")
297 }
298 if life < window {
299 panic("life must be at least the window")
300 }
301 seed := ugnotSent()
302 p := newPool(name, creator, window, basePrice, life, seed)
303 chain.Emit("PoolCreated", "id", itoa(p.ID), "creator", creator.String(), "seed", itoa(seed))
304 return p.ID
305}
306
307func newPool(name string, creator address, window, basePrice, life, seed int64) *Pool {
308 p := &Pool{
309 ID: int64(len(pools)) + 1, Name: name, Creator: creator, Window: window, Life: life,
310 BasePrice: basePrice, Seed: seed, Pot: seed, CreatedAt: time.Now(),
311 }
312 pools = append(pools, p)
313 return p
314}
315
316// Bid pays at least the current price and resets the clock. ref is the address
317// that invited the bidder ("" for none; only the first bid ever sets it), flag
318// a two-letter country to play under ("" keeps the last one; the flag is locked
319// per pool at the first bid there), shot how much of the money sent is a shot
320// at popping the bubble (0 for none): the rest must cover the price, and paying
321// more than the price shortens the clock.
322func Bid(cur realm, id int64, ref string, flag string, shot int64) {
323 bidder := userCaller(cur)
324 p := pool(id)
325 sent := ugnotSent()
326 if p.Cancelled {
327 panic("pool was cancelled")
328 }
329 // shots paid for earlier are drawn first; if one of them pops the bubble,
330 // this bid has nothing to bid on and its money goes back
331 p.drawShots(cur)
332 if p.Over() {
333 if sent > 0 {
334 send(cur, bidder, sent)
335 chain.Emit("Refund", "id", itoa(id), "to", bidder.String(), "ugnot", itoa(sent))
336 }
337 if p.Popped {
338 return
339 }
340 panic("pool is closed")
341 }
342 if shot < 0 || shot > sent {
343 panic("shot must be between 0 and the amount sent")
344 }
345 if shot > 0 && !shotsOn {
346 panic("shots are off")
347 }
348 price := p.NextPrice()
349 bid := sent - shot
350 if bid < price {
351 panic("send at least " + itoa(price) + "ugnot for the bid, got " + itoa(bid) + "ugnot")
352 }
353 if shot > 0 {
354 // checked against the most the pot can be after this bid, so a shot that
355 // passes here has a chance against the real pot too; nothing has changed yet
356 most := p.Pot + bid + shot
357 if most > ShotCap {
358 most = ShotCap
359 }
360 if ShotBps(shot, most) == 0 {
361 panic("that shot is too small for any chance at " + GNOT(most) + ": send at least " + itoa(most/ShotFair+1) + "ugnot as the shot")
362 }
363 }
364 pl := player(bidder)
365 if f := cleanFlag(flag); f != "" && f != pl.Flag {
366 if pl.Flag != "" {
367 teamSize[pl.Flag]--
368 }
369 pl.Flag = f
370 teamSize[f]++
371 }
372 if pl.Referrer == "" && ref != "" {
373 r := address(ref)
374 if r.IsValid() && r != bidder {
375 pl.Referrer = r
376 player(r).Recruits++
377 }
378 }
379
380 // where the bid goes
381 div, refCut, creatorCut := bid*DivShare/100, bid*RefShare/100, bid*CreatorShare/100
382 toPot := bid - div - refCut - creatorCut
383 if creatorCut > 0 {
384 send(cur, p.Creator, creatorCut)
385 p.CreatorPaid += creatorCut
386 }
387 if pl.Referrer != "" && refCut > 0 {
388 send(cur, pl.Referrer, refCut)
389 p.RefPaid += refCut
390 player(pl.Referrer).RefEarned += refCut
391 } else {
392 toPot += refCut
393 }
394 divPaid := div - p.payDividends(cur, bidder, div)
395 toPot += div - divPaid
396 // the shot goes into the pot whole, hit or miss: it is what it plays for
397 p.Pot += toPot + shot
398
399 m := p.member(bidder, pl.Flag)
400 if m.Flag == "" { // a flagless first bid does not lock "no flag": the first flag flown here does
401 m.Flag = pl.Flag
402 }
403 m.Paid += sent
404 pl.Bids++
405 pl.Paid += sent
406 if pl.Flag != "" {
407 teamPaid[pl.Flag] += sent
408 }
409 p.Bids++
410 if p.FirstBidAt.IsZero() {
411 p.FirstBidAt = time.Now()
412 }
413 p.LastBidder = bidder
414 p.LastBidAt = time.Now()
415 p.Clock = ClockFor(p.Window, price, bid)
416 p.History = append(p.History, Entry{N: p.Bids, Bidder: bidder, Flag: m.Flag, Price: bid, Shot: shot, Clock: p.Clock, Pot: p.Pot, At: p.LastBidAt})
417 if len(p.History) > HistoryLen {
418 p.History = p.History[len(p.History)-HistoryLen:]
419 }
420 chain.Emit("Bid", "id", itoa(id), "n", itoa(p.Bids), "bidder", bidder.String(), "paid", itoa(bid), "shot", itoa(shot), "pot", itoa(p.Pot), "div", itoa(divPaid))
421
422 if shot > 0 {
423 prize := p.Pot
424 if prize > ShotCap {
425 prize = ShotCap
426 }
427 bps := ShotBps(shot, prize)
428 t := &Shot{N: int64(len(p.Shots)) + 1, Bidder: bidder, Paid: shot, Prize: prize, Bps: bps, CommitH: runtime.ChainHeight()}
429 p.Shots = append(p.Shots, t)
430 pl.Shots++
431 chain.Emit("Shot", "id", itoa(id), "shot", itoa(t.N), "bidder", bidder.String(), "paid", itoa(shot), "prize", itoa(prize), "bps", itoa(bps), "drawAt", itoa(t.CommitH+ShotDelay))
432 }
433}
434
435// SetShots turns shots off (or on again); only the deployer may.
436func SetShots(cur realm, on bool) {
437 if userCaller(cur) != admin {
438 panic("only the deployer")
439 }
440 shotsOn = on
441 chain.Emit("Shots", "on", jbool(on))
442}
443
444// Draw draws the shots at a pool that are due. Anyone may call it; every bid
445// and claim on the pool does the same first.
446func Draw(cur realm, id int64) {
447 pool(id).drawShots(cur)
448}
449
450// drawShots resolves every shot that is due, oldest first. A shot is drawn in
451// the blocks ShotDelay to ShotDelay+ShotWindow after it was paid for, from the
452// block's time and height, the shot and its shooter, and the address that sent
453// the drawing transaction; a shot those blocks passed by undrawn is void, its
454// money stays in the pot, and it counts as a miss. A hit takes ShotCap from a
455// pot larger than that and the pool goes on; a pot at or under ShotCap pops:
456// the pool closes now with the shooter as its winner, settled at Claim.
457func (p *Pool) drawShots(cur realm) {
458 h := runtime.ChainHeight()
459 for _, t := range p.Shots {
460 if t.Resolved || t.CommitH+ShotDelay > h {
461 continue
462 }
463 t.Resolved, t.DrawH = true, h
464 if t.CommitH+ShotDelay+ShotWindow < h || p.Over() {
465 // too late, or the pool closed first: void
466 p.Misses++
467 chain.Emit("Drawn", "id", itoa(p.ID), "shot", itoa(t.N), "bidder", t.Bidder.String(), "hit", "false", "void", "true")
468 continue
469 }
470 t.Won = shotHits(seedFor(p.ID, t, h), t.Bps)
471 chain.Emit("Drawn", "id", itoa(p.ID), "shot", itoa(t.N), "bidder", t.Bidder.String(), "hit", jbool(t.Won), "bps", itoa(t.Bps))
472 if !t.Won {
473 p.Misses++
474 continue
475 }
476 player(t.Bidder).Hits++
477 if p.Pot > ShotCap {
478 credit(t.Bidder, ShotCap)
479 p.Pot -= ShotCap
480 p.ShotPaid += ShotCap
481 player(t.Bidder).Won += ShotCap
482 chain.Emit("Slice", "id", itoa(p.ID), "to", t.Bidder.String(), "ugnot", itoa(ShotCap))
483 continue
484 }
485 p.Popped, p.PoppedAt, p.LastBidder = true, time.Now(), t.Bidder
486 chain.Emit("Popped", "id", itoa(p.ID), "by", t.Bidder.String(), "pot", itoa(p.Pot))
487 }
488}
489
490func seedFor(poolID int64, t *Shot, h int64) uint64 {
491 var b []byte
492 b = append(b, pkgPath...)
493 b = binary.BigEndian.AppendUint64(b, uint64(poolID))
494 b = binary.BigEndian.AppendUint64(b, uint64(t.N))
495 b = append(b, t.Bidder.String()...)
496 b = binary.BigEndian.AppendUint64(b, uint64(t.CommitH))
497 b = binary.BigEndian.AppendUint64(b, uint64(h))
498 b = binary.BigEndian.AppendUint64(b, uint64(time.Now().UnixNano()))
499 b = append(b, unsafe.OriginCaller().String()...)
500 sum := sha256.Sum256(b)
501 return binary.BigEndian.Uint64(sum[:8])
502}
503
504// shotHits is the draw: a uniform number in [0, 10000) under the chance.
505func shotHits(seed uint64, bps int64) bool {
506 return int64(seed%10000) < bps
507}
508
509// payDividends credits div to the pool's earlier bidders, pro-rata to what
510// each has paid in, skipping the bidder; whatever cannot be placed (no earlier
511// bidders, rounding) is returned to go into the pot.
512func (p *Pool) payDividends(cur realm, bidder address, div int64) int64 {
513 var total int64
514 for _, m := range p.Roster {
515 if m.Addr != bidder {
516 total += m.Paid
517 }
518 }
519 if total == 0 || div == 0 {
520 return div
521 }
522 var paid int64
523 for _, m := range p.Roster {
524 if m.Addr == bidder {
525 continue
526 }
527 amt := mulDiv(div, m.Paid, total)
528 if amt > 0 {
529 credit(m.Addr, amt)
530 m.Earned += amt
531 player(m.Addr).DivEarned += amt
532 paid += amt
533 }
534 }
535 p.DivPaid += paid
536 return div - paid
537}
538
539// member finds or adds a bidder on the roster; a full roster drops its oldest.
540// A new member's flag is the one given; once set it is locked for this pool.
541func (p *Pool) member(a address, flag string) *Member {
542 for _, m := range p.Roster {
543 if m.Addr == a {
544 return m
545 }
546 }
547 if len(p.Roster) >= RosterMax {
548 p.Roster = p.Roster[1:]
549 }
550 m := &Member{Addr: a, Flag: flag}
551 p.Roster = append(p.Roster, m)
552 return m
553}
554
555// Claim settles a finished pool: everything is credited, and Withdraw sends
556// it. TeamShare of the pot goes to the OTHER roster members flying the
557// winner's flag, pro-rata by paid-in — or, when nobody else flew it, to all
558// the other roster members. Of the rest, the live part (LiveBps) is the
559// winner's and the shared part is split among the whole roster pro-rata by
560// paid-in. A pool with a single bidder credits them everything. Rounding goes
561// to the winner. Anyone may call it.
562func Claim(cur realm, id int64) {
563 p := pool(id)
564 if p.Cancelled {
565 panic("pool was cancelled")
566 }
567 p.drawShots(cur)
568 if !p.Over() {
569 panic("clock still running")
570 }
571 if p.Paid {
572 panic("already paid out")
573 }
574 p.Paid = true
575 winner := p.LastBidder
576 flag := ""
577 if m := p.find(winner); m != nil {
578 flag = m.Flag
579 }
580 p.WinnerFlag = flag
581 pot := p.Pot
582
583 // the team: the others under the winner's flag, else all the others
584 var team int64
585 for _, m := range p.Roster {
586 if m.Addr != winner && m.Flag == flag && flag != "" {
587 team += m.Paid
588 }
589 }
590 teamFlag := flag
591 if team == 0 {
592 teamFlag = "" // nobody else flew it: every other bidder is the team
593 for _, m := range p.Roster {
594 if m.Addr != winner {
595 team += m.Paid
596 }
597 }
598 }
599 toWinner := pot
600 if team > 0 {
601 cut := pot * TeamShare / 100
602 for _, m := range p.Roster {
603 if m.Addr == winner || (teamFlag != "" && m.Flag != teamFlag) {
604 continue
605 }
606 amt := mulDiv(cut, m.Paid, team)
607 if amt > 0 {
608 credit(m.Addr, amt)
609 player(m.Addr).Won += amt
610 toWinner -= amt
611 p.TeamPaid += amt
612 }
613 }
614 // the rest slides: the live part stays the winner's, the shared part is everyone's by paid-in
615 rest := pot - cut
616 shared := rest - mulDiv(rest, p.LiveBps(), 10000)
617 if shared > 0 {
618 var total int64
619 for _, m := range p.Roster {
620 total += m.Paid
621 }
622 for _, m := range p.Roster {
623 amt := mulDiv(shared, m.Paid, total)
624 if amt > 0 && m.Addr != winner {
625 credit(m.Addr, amt)
626 player(m.Addr).Won += amt
627 toWinner -= amt
628 p.SharedPaid += amt
629 }
630 }
631 }
632 }
633 if toWinner > 0 {
634 credit(winner, toWinner)
635 player(winner).Won += toWinner
636 }
637 p.WinnerPaid = toWinner
638 if flag != "" {
639 teamWon[flag] += p.Pot
640 }
641 chain.Emit("Paid", "id", itoa(id), "winner", winner.String(), "pot", itoa(p.Pot), "winnerPaid", itoa(toWinner), "team", itoa(p.TeamPaid), "shared", itoa(p.SharedPaid), "liveBps", itoa(p.LiveBps()))
642}
643
644// Cancel lets the creator take the seed back from a pool nobody has bid on.
645func Cancel(cur realm, id int64) {
646 caller := userCaller(cur)
647 p := pool(id)
648 if p.Creator != caller {
649 panic("only the creator can cancel")
650 }
651 if p.Bids > 0 {
652 panic("pool already has bids")
653 }
654 if p.Cancelled {
655 panic("already cancelled")
656 }
657 p.Cancelled = true
658 p.Paid = true
659 if p.Pot > 0 {
660 send(cur, caller, p.Pot)
661 }
662 chain.Emit("Cancelled", "id", itoa(id))
663}
664
665func (p *Pool) find(a address) *Member {
666 for _, m := range p.Roster {
667 if m.Addr == a {
668 return m
669 }
670 }
671 return nil
672}
673
674func player(a address) *Player {
675 pl := players[a]
676 if pl == nil {
677 pl = &Player{}
678 players[a] = pl
679 }
680 return pl
681}
682
683func send(cur realm, to address, ugnot int64) {
684 banker.NewBanker(banker.BankerTypeRealmSend, cur).SendCoins(realmAddr, to, chain.Coins{{"ugnot", ugnot}})
685}
686
687// credit books ugnot to an address; Withdraw pays it out.
688func credit(to address, ugnot int64) {
689 player(to).Owed += ugnot
690}
691
692// Withdraw sends the caller everything credited to them: dividends, team
693// shares, close splits, slices and won pots.
694func Withdraw(cur realm) int64 {
695 who := userCaller(cur)
696 pl := player(who)
697 amt := pl.Owed
698 if amt <= 0 {
699 panic("nothing to withdraw")
700 }
701 pl.Owed = 0
702 pl.Withdrawn += amt
703 send(cur, who, amt)
704 chain.Emit("Withdrawn", "to", who.String(), "ugnot", itoa(amt))
705 return amt
706}
707
708// Owed is what an address could withdraw right now.
709func Owed(a address) int64 { return player(a).Owed }
710
711func pool(id int64) *Pool {
712 if id < 1 || id > int64(len(pools)) {
713 panic("no such pool")
714 }
715 return pools[id-1]
716}
717
718// userCaller is the signer of the transaction, refusing calls relayed through
719// another realm so nobody can bid on someone else's behalf, and so no realm can
720// pay for a shot and revert on a miss.
721func userCaller(cur realm) address {
722 prev := cur.Previous()
723 if !prev.IsUserCall() {
724 panic("must be a direct user call")
725 }
726 return prev.Address()
727}
728
729func ugnotSent() int64 {
730 sent := unsafe.OriginSend()
731 for _, c := range sent {
732 if c.Denom != "ugnot" {
733 panic("only ugnot is accepted")
734 }
735 }
736 return sent.AmountOf("ugnot")
737}
738
739func cleanName(s string) string {
740 s = strings.TrimSpace(s)
741 if s == "" || len(s) > MaxNameLen {
742 panic("name must be 1-40 characters")
743 }
744 for _, c := range s {
745 if c < 0x20 || c == 0x7f {
746 panic("name has control characters")
747 }
748 }
749 return s
750}
751
752// cleanFlag accepts a two-letter country code, upper-cased; anything else is "".
753func cleanFlag(s string) string {
754 s = strings.ToUpper(strings.TrimSpace(s))
755 if len(s) != 2 || s[0] < 'A' || s[0] > 'Z' || s[1] < 'A' || s[1] > 'Z' {
756 return ""
757 }
758 return s
759}
760
761func itoa(n int64) string { return strconv.FormatInt(n, 10) }
762
763func parseID(s string) int64 {
764 n, err := strconv.ParseInt(s, 10, 64)
765 if err != nil {
766 panic("bad pool id")
767 }
768 return n
769}
770
771// GNOT formats ugnot as GNOT with the trailing zeros trimmed.
772func GNOT(ugnot int64) string {
773 whole, frac := ugnot/1_000_000, ugnot%1_000_000
774 if frac == 0 {
775 return itoa(whole) + " GNOT"
776 }
777 f := strconv.FormatInt(1_000_000+frac, 10)[1:]
778 return itoa(whole) + "." + strings.TrimRight(f, "0") + " GNOT"
779}
780
781func short(a address) string {
782 s := a.String()
783 if len(s) < 12 {
784 return s
785 }
786 return s[:8] + "…" + s[len(s)-4:]
787}
788
789func dur(sec int64) string {
790 if sec <= 0 {
791 return "0s"
792 }
793 d, h, m, s := sec/86400, sec%86400/3600, sec%3600/60, sec%60
794 out := ""
795 if d > 0 {
796 out += itoa(d) + "d "
797 }
798 if d > 0 || h > 0 {
799 out += itoa(h) + "h "
800 }
801 if d > 0 || h > 0 || m > 0 {
802 out += itoa(m) + "m "
803 }
804 return out + itoa(s) + "s"
805}
806
807// --- rendering ---------------------------------------------------------------
808
809// Render serves gnoweb ("" and "<id>") and the page ("json", "json/<id>",
810// "me/<address>", "teams").
811func Render(path string) string {
812 path = strings.Trim(path, "/")
813 switch {
814 case path == "json":
815 return jsonAll()
816 case strings.HasPrefix(path, "json/"):
817 return pool(parseID(path[5:])).json(true)
818 case strings.HasPrefix(path, "me/"):
819 return jsonMe(address(path[3:]))
820 case path == "teams":
821 return jsonTeams()
822 case path == "":
823 return markdownAll()
824 default:
825 return pool(parseID(path)).markdown()
826 }
827}
828
829func unix(t time.Time) string {
830 if t.IsZero() {
831 return "0"
832 }
833 return itoa(t.Unix())
834}
835
836func jbool(b bool) string {
837 if b {
838 return "true"
839 }
840 return "false"
841}
842
843func (p *Pool) json(detail bool) string {
844 var b strings.Builder
845 b.WriteString("{\"id\":" + itoa(p.ID))
846 b.WriteString(",\"name\":" + strconv.Quote(p.Name))
847 b.WriteString(",\"creator\":\"" + p.Creator.String() + "\"")
848 b.WriteString(",\"window\":" + itoa(p.Window))
849 b.WriteString(",\"life\":" + itoa(p.Life))
850 b.WriteString(",\"basePrice\":" + itoa(p.BasePrice))
851 b.WriteString(",\"seed\":" + itoa(p.Seed))
852 b.WriteString(",\"pot\":" + itoa(p.Pot))
853 b.WriteString(",\"bids\":" + itoa(p.Bids))
854 b.WriteString(",\"nextPrice\":" + itoa(p.NextPrice()))
855 b.WriteString(",\"lastBidder\":\"" + p.LastBidder.String() + "\"")
856 b.WriteString(",\"lastBidAt\":" + unix(p.LastBidAt))
857 b.WriteString(",\"firstBidAt\":" + unix(p.FirstBidAt))
858 b.WriteString(",\"deadline\":" + unix(p.Deadline()))
859 b.WriteString(",\"lastDay\":" + unix(p.LastDay()))
860 b.WriteString(",\"liveBps\":" + itoa(p.LiveBps()))
861 b.WriteString(",\"clock\":" + itoa(p.Clock))
862 b.WriteString(",\"createdAt\":" + unix(p.CreatedAt))
863 b.WriteString(",\"over\":" + jbool(p.Over()))
864 b.WriteString(",\"popped\":" + jbool(p.Popped))
865 b.WriteString(",\"paid\":" + jbool(p.Paid))
866 b.WriteString(",\"cancelled\":" + jbool(p.Cancelled))
867 b.WriteString(",\"bidders\":" + itoa(int64(len(p.Roster))))
868 b.WriteString(",\"divPaid\":" + itoa(p.DivPaid))
869 b.WriteString(",\"refPaid\":" + itoa(p.RefPaid))
870 b.WriteString(",\"creatorPaid\":" + itoa(p.CreatorPaid))
871 b.WriteString(",\"shotPaid\":" + itoa(p.ShotPaid))
872 b.WriteString(",\"teamPaid\":" + itoa(p.TeamPaid))
873 b.WriteString(",\"sharedPaid\":" + itoa(p.SharedPaid))
874 b.WriteString(",\"winnerPaid\":" + itoa(p.WinnerPaid))
875 pending := int64(0)
876 for _, t := range p.Shots {
877 if !t.Resolved {
878 pending++
879 }
880 }
881 b.WriteString(",\"shots\":" + itoa(int64(len(p.Shots))) + ",\"misses\":" + itoa(p.Misses) + ",\"pending\":" + itoa(pending))
882 flag := p.WinnerFlag
883 if m := p.find(p.LastBidder); m != nil && flag == "" {
884 flag = m.Flag
885 }
886 b.WriteString(",\"flag\":\"" + flag + "\"")
887 // what each flag has paid into this pool
888 b.WriteString(",\"teams\":{")
889 seen := map[string]int64{}
890 order := []string{}
891 for _, m := range p.Roster {
892 if m.Flag == "" {
893 continue
894 }
895 if _, ok := seen[m.Flag]; !ok {
896 order = append(order, m.Flag)
897 }
898 seen[m.Flag] += m.Paid
899 }
900 for i, f := range order {
901 if i > 0 {
902 b.WriteString(",")
903 }
904 b.WriteString("\"" + f + "\":" + itoa(seen[f]))
905 }
906 b.WriteString("}")
907 if detail {
908 b.WriteString(",\"history\":[")
909 for i := len(p.History) - 1; i >= 0; i-- { // newest first
910 h := p.History[i]
911 if i < len(p.History)-1 {
912 b.WriteString(",")
913 }
914 b.WriteString("{\"n\":" + itoa(h.N) + ",\"bidder\":\"" + h.Bidder.String() + "\",\"flag\":\"" + h.Flag + "\",\"price\":" + itoa(h.Price) + ",\"shot\":" + itoa(h.Shot) + ",\"clock\":" + itoa(h.Clock) + ",\"pot\":" + itoa(h.Pot) + ",\"at\":" + unix(h.At) + "}")
915 }
916 b.WriteString("],\"roster\":[")
917 for i, m := range p.Roster {
918 if i > 0 {
919 b.WriteString(",")
920 }
921 b.WriteString("{\"addr\":\"" + m.Addr.String() + "\",\"flag\":\"" + m.Flag + "\",\"paid\":" + itoa(m.Paid) + ",\"earned\":" + itoa(m.Earned) + "}")
922 }
923 b.WriteString("],\"shotlog\":[")
924 for i := len(p.Shots) - 1; i >= 0; i-- { // newest first
925 t := p.Shots[i]
926 if i < len(p.Shots)-1 {
927 b.WriteString(",")
928 }
929 b.WriteString("{\"n\":" + itoa(t.N) + ",\"bidder\":\"" + t.Bidder.String() + "\",\"paid\":" + itoa(t.Paid) + ",\"prize\":" + itoa(t.Prize) + ",\"bps\":" + itoa(t.Bps) + ",\"drawAt\":" + itoa(t.CommitH+ShotDelay) + ",\"resolved\":" + jbool(t.Resolved) + ",\"hit\":" + jbool(t.Won) + "}")
930 }
931 b.WriteString("]")
932 }
933 b.WriteString("}")
934 return b.String()
935}
936
937func jsonAll() string {
938 var b strings.Builder
939 b.WriteString("{\"now\":" + itoa(time.Now().Unix()) + ",\"height\":" + itoa(runtime.ChainHeight()) + ",\"realm\":\"" + pkgPath + "\"")
940 b.WriteString(",\"split\":{\"pot\":" + itoa(PotShare) + ",\"div\":" + itoa(DivShare) + ",\"ref\":" + itoa(RefShare) + ",\"creator\":" + itoa(CreatorShare) + ",\"team\":" + itoa(TeamShare) + ",\"roster\":" + itoa(int64(RosterMax)) +
941 ",\"shotCap\":" + itoa(ShotCap) + ",\"shotMaxBps\":" + itoa(ShotMaxBps) + ",\"shotFair\":" + itoa(ShotFair) + ",\"shotDelay\":" + itoa(ShotDelay) + ",\"shotWindow\":" + itoa(ShotWindow) + ",\"minClock\":" + itoa(MinClock) + "}")
942 b.WriteString(",\"shotsOn\":" + jbool(shotsOn))
943 b.WriteString(",\"pools\":[")
944 for i, p := range pools {
945 if i > 0 {
946 b.WriteString(",")
947 }
948 b.WriteString(p.json(false))
949 }
950 b.WriteString("],\"teams\":" + jsonTeams() + "}")
951 return b.String()
952}
953
954// jsonTeams is the country leaderboard: paid in, won, and players per flag.
955func jsonTeams() string {
956 var b strings.Builder
957 b.WriteString("{")
958 i := 0
959 for f, paid := range teamPaid {
960 if i > 0 {
961 b.WriteString(",")
962 }
963 i++
964 b.WriteString("\"" + f + "\":{\"paid\":" + itoa(paid) + ",\"won\":" + itoa(teamWon[f]) + ",\"players\":" + itoa(teamSize[f]) + "}")
965 }
966 b.WriteString("}")
967 return b.String()
968}
969
970// jsonMe is what the page shows a connected wallet about itself.
971func jsonMe(a address) string {
972 pl := players[a]
973 if pl == nil {
974 pl = &Player{}
975 }
976 return "{\"addr\":\"" + a.String() + "\",\"referrer\":\"" + pl.Referrer.String() + "\",\"recruits\":" + itoa(pl.Recruits) +
977 ",\"flag\":\"" + pl.Flag + "\",\"bids\":" + itoa(pl.Bids) + ",\"paid\":" + itoa(pl.Paid) +
978 ",\"divEarned\":" + itoa(pl.DivEarned) + ",\"refEarned\":" + itoa(pl.RefEarned) + ",\"won\":" + itoa(pl.Won) +
979 ",\"shots\":" + itoa(pl.Shots) + ",\"hits\":" + itoa(pl.Hits) + ",\"owed\":" + itoa(pl.Owed) + ",\"withdrawn\":" + itoa(pl.Withdrawn) + "}"
980}
981
982func (p *Pool) status() string {
983 switch {
984 case p.Cancelled:
985 return "cancelled"
986 case p.Over():
987 s := "won by " + short(p.LastBidder)
988 if p.Popped {
989 s = "popped by " + short(p.LastBidder)
990 }
991 if !p.Paid {
992 s += " (unclaimed)"
993 }
994 return s
995 case p.Bids == 0:
996 return "no bids yet · " + dur(p.Window) + " window · next " + GNOT(p.NextPrice())
997 default:
998 left := p.Deadline().Unix() - time.Now().Unix()
999 s := dur(left) + " left"
1000 if p.Clock < p.Window {
1001 s += " (⚡ " + dur(p.Clock) + " clock)"
1002 }
1003 return s + " · " + short(p.LastBidder) + " on top · next " + GNOT(p.NextPrice()) + " · winner's share " + itoa(p.LiveBps()/100) + "%"
1004 }
1005}
1006
1007func markdownAll() string {
1008 var b strings.Builder
1009 b.WriteString("# Bubble Rumble v3\n\n")
1010 b.WriteString("Last bid standing takes the pot. Of every bid, 55% goes into the pot, 30% is paid at once to the pool's earlier bidders, 10% to whoever invited the bidder and 5% to the pool's creator. ")
1011 b.WriteString("Earnings are credited and withdrawn with Withdraw. At the close " + itoa(TeamShare) + "% of the pot goes to the other bidders who flew the winner's flag. Every pool has a last day: as it nears, the winner's own share slides toward a split of the pot among all its bidders. A bid may carry a shot at the bubble: a chance of at most " + itoa(ShotMaxBps/100) + "% to pop it, or to take a " + GNOT(ShotCap) + " slice of a bigger one; every miss is counted on the bubble.\n\n")
1012 b.WriteString("Play at [bubblerumble.net](https://bubblerumble.net).\n\n## Pools\n\n")
1013 if len(pools) == 0 {
1014 b.WriteString("_none yet_\n")
1015 }
1016 for _, p := range pools {
1017 b.WriteString("- [#" + itoa(p.ID) + " " + p.Name + "](/r/g1leu8d2vsplhehcfkjg50mwgdpxdkt8tztu95wr/bubblerumble3:" + itoa(p.ID) + ") · " + GNOT(p.Pot) + " · " + p.status() + "\n")
1018 }
1019 return b.String()
1020}
1021
1022func (p *Pool) markdown() string {
1023 var b strings.Builder
1024 b.WriteString("# " + p.Name + "\n\n")
1025 b.WriteString("- pot: **" + GNOT(p.Pot) + "**\n- status: " + p.status() + "\n- window: " + dur(p.Window) + " · life: " + dur(p.Life) + "\n- base price: " + GNOT(p.BasePrice) + " · next bid: " + GNOT(p.NextPrice()) + "\n- bids: " + itoa(p.Bids) + " · creator: " + short(p.Creator) + "\n")
1026 if !p.LastDay().IsZero() {
1027 b.WriteString("- last day: " + p.LastDay().UTC().Format("2006-01-02 15:04 UTC") + " · winner's share now " + itoa(p.LiveBps()/100) + "%\n")
1028 }
1029 if len(p.Shots) > 0 {
1030 b.WriteString("- shots: " + itoa(int64(len(p.Shots))) + " · misses: " + itoa(p.Misses) + "\n")
1031 }
1032 b.WriteString("\n## Bids\n\n")
1033 if len(p.History) == 0 {
1034 b.WriteString("_none yet_\n")
1035 }
1036 for i := len(p.History) - 1; i >= 0; i-- {
1037 h := p.History[i]
1038 line := "- #" + itoa(h.N) + " " + short(h.Bidder)
1039 if h.Flag != "" {
1040 line += " (" + h.Flag + ")"
1041 }
1042 line += " paid " + GNOT(h.Price)
1043 if h.Shot > 0 {
1044 line += " + a " + GNOT(h.Shot) + " shot"
1045 }
1046 b.WriteString(line + " · pot " + GNOT(h.Pot) + "\n")
1047 }
1048 return b.String()
1049}
