@xgamesfun/solana 0.25.3 → 0.26.0

package/js/client/accounts.js

@@ -107,6 +107,9 @@ const RECORDS = [
         // The totals, split at each purchase: what each share paid in common takes, the entries that own a part of
         // their own, and the parts owed now.
         ['sold', 'u64'],
+        // In a weighted round (`time_weighted`), the weight sold: each purchase's tickets times the seconds from it
+        // to the close of sales. Null: each ticket weighs one, and the draw is over `sold`.
+        ['weight', { option: 'u128' }],
         ['to_pot', 'u64'],
         ['common', { vec: 'u64' }],
         ['owns', 'u32'],
@@ -117,7 +120,8 @@ const RECORDS = [
         ['first_asked_at', 'i64'],
         ['asked_at', 'i64'],
         ['answer', { array: ['u8', 32] }],
-        ['first', 'u64'],
+        // First place's point: below the draw's total (`roundTotal`), so in a weighted round a point of its weight.
+        ['first', 'u128'],
         ['pot_total', 'u64'],
         ['pot_sent', 'u64'],
         ['pot_arrived', 'u64'],
@@ -506,55 +510,94 @@ export const lotteryPots = lottery =>
 /** A share the buyer chooses (a referrer, a collectible's holder): paid out of the price as they buy, from their own account. */
 export const chosenAtPurchase = share => Boolean(share.to?.Chosen);
 
-/** The bytes of one entry of a round: buyer, word, what arrived (`fee`: a fee mint, or a chosen share), the NFT ticket. */
-export const entryWidth = (fee, nft) => 40 + (fee ? 8 : 0) + (nft ? 32 : 0);
+/** The bytes of one entry of a round: buyer, word, what arrived (`fee`: a fee mint, a chosen share, or a weighted
+ * round of paid tickets), where its weight ends (`weighted`: a round that weighs its tickets by time), the NFT ticket. */
+export const entryWidth = (fee, nft, weighted = false) => 40 + (fee ? 8 : 0) + (weighted ? 16 : 0) + (nft ? 32 : 0);
+
+/** What a round's draw picks a point below: the weight sold in a weighted round, the tickets sold otherwise. */
+export const roundTotal = r => (r.weight != null ? BigInt(r.weight) : BigInt(r.sold));
 
 /**
  * A lottery round (`["round", lottery, incarnation, round]`): its header (`status` 'Open' | 'Drawing' | 'Drawn' |
- * 'Cancelled', the terms it copied, `sold`, `owed`, the draw and the money the ask fixed, `nfts` the NFT of the
- * lottery's own stash each such place got), and `entries`, one a purchase: { buyer, start, end (its tickets), paid (its
- * own part's bit), amount (what reached the round), nft (its NFT ticket) }.
+ * 'Cancelled', the terms it copied, `sold`, `weight` (null in a round that doesn't weigh its tickets), `owed`, the draw
+ * and the money the ask fixed, `nfts` the NFT of the lottery's own stash each such place got), and `entries`, one a
+ * purchase: { buyer, start, end (its slice of the draw: its tickets, or in a weighted round its weight), tickets (how
+ * many it bought), paid (its own part's bit), amount (what reached the round), nft (its NFT ticket) }.
  */
 export function decodeRound(data) {
   const r = decode('LotteryRound', data);
   const at = Number(r.head);
   const width = Number(readUintLE(data, at, 2));
   const count = Number(readUintLE(data, at + 2, 4));
-  if (width !== entryWidth(r.fee, r.terms.nft_ticket != null) || data.length !== at + 6 + width * count)
+  const weighted = r.weight != null;
+  if (width !== entryWidth(r.fee, r.terms.nft_ticket != null, weighted) || data.length !== at + 6 + width * count)
     throw new Error('LotteryRound entries do not match its header');
   let start = 0n;
+  let sold = 0n;
   const entries = Array.from({ length: count }, (_, i) => {
     const e = data.subarray(at + 6 + width * i, at + 6 + width * (i + 1));
     const word = readUintLE(e, 32, 8);
-    const end = word & END_BITS;
+    // Its tickets end at the word's low 48 bits; its slice of the draw ends there too, or at its weight's end.
+    const last = word & END_BITS;
+    const tickets = last - sold;
     let k = 40;
     const take = n => e.subarray((k += n) - n, k);
-    const amount = r.fee ? readUintLE(take(8), 0, 8) : (end - start) * BigInt(r.terms.price);
+    const amount = r.fee ? readUintLE(take(8), 0, 8) : tickets * BigInt(r.terms.price);
+    const end = weighted ? readUintLE(take(16), 0, 16) : last;
     const entry = {
       buyer: encodeBase58(e.subarray(0, 32)),
       start,
       end,
+      tickets,
       paid: word & ~END_BITS,
       amount,
       nft: r.terms.nft_ticket ? encodeBase58(take(32)) : NO_ADDRESS,
     };
     start = end;
+    sold = last;
     return entry;
   });
   return { ...r, entries };
 }
 
+/** When a lottery's sales close (`terms`: a Lottery's or a round's): `closes_before` seconds before its draw. */
+export const salesCloseAt = terms => BigInt(terms.draws_at) - BigInt(terms.closes_before ?? 0);
+
+/**
+ * What a purchase of `count` tickets at `now` (Unix seconds, the chain's clock) weighs in a round's draw: one a ticket,
+ * or in a lottery that weighs tickets by time (`terms.time_weighted`) each ticket the seconds from the purchase to the
+ * close of sales (`salesCloseAt`). 0 once sales have closed: nothing more is sold. The same tickets bought later weigh less.
+ */
+export function ticketWeight(terms, count, now) {
+  const left = salesCloseAt(terms) - BigInt(now);
+  if (left <= 0n) return 0n;
+  return BigInt(count) * (terms.time_weighted ? left : 1n);
+}
+
+/**
+ * A buyer's chance before they buy: { weight, total, share } of a purchase of `count` tickets at `now` into `round` (its
+ * decoded record, null when nobody bought into it yet; `terms` the lottery's then): what it would weigh, the round's
+ * weight with it, and its share of that (a number from 0 to 1). Each place is drawn over the round's whole weight, so a
+ * share is the purchase's chance at one place as things stand: later purchases make it smaller.
+ */
+export function purchaseOdds(round, terms, count, now) {
+  const weight = ticketWeight(round?.terms ?? terms, count, now);
+  const total = (round ? roundTotal(round) : 0n) + weight;
+  return { weight, total, share: total > 0n ? Number((weight * 1_000_000n) / total) / 1_000_000 : 0 };
+}
+
 /** How many places a lottery's (or a round's) `places` are, every run counted (`Place.times`). */
 export const placeCount = places => places.reduce((n, p) => n + Number(p.times ?? 1), 0);
 
 /** The places of a round that have a winner: every place, but no more than tickets. */
 export const roundWinners = r => Math.min(placeCount(r.terms.places), Number(r.sold));
 
-/** The ticket that wins `place` of a drawn round: even steps around the list from first place's ticket. */
+/** The point that wins `place` of a drawn round: even steps of the draw's total around the list from first place's
+ * (a ticket's number, or in a weighted round a point of its weight). */
 export function ticketOfPlace(r, place) {
-  const sold = BigInt(r.sold);
-  const ahead = BigInt(place) * (sold / BigInt(roundWinners(r) || 1));
-  const toEnd = sold - BigInt(r.first);
+  const total = roundTotal(r);
+  const ahead = BigInt(place) * (total / BigInt(roundWinners(r) || 1));
+  const toEnd = total - BigInt(r.first);
   return ahead < toEnd ? BigInt(r.first) + ahead : ahead - toEnd;
 }
 
@@ -575,18 +618,18 @@ export function runPlaces(r, run) {
   return [Math.min(first, w), Math.min(first + Number(r.terms.places[run].times), w)];
 }
 
-/** The places of run `run` whose ticket is in `start..end` (an entry's), in order. */
+/** The places of run `run` whose point is in `start..end` (an entry's slice of the draw), in order. */
 export function placesIn(r, run, start, end) {
   const [from, to] = runPlaces(r, run);
   const out = [];
   if (from >= to || BigInt(start) >= BigInt(end)) return out;
-  const sold = BigInt(r.sold);
-  const step = sold / BigInt(roundWinners(r));
-  const d = (BigInt(start) + sold - BigInt(r.first)) % sold;
+  const total = roundTotal(r);
+  const step = total / BigInt(roundWinners(r));
+  const d = (BigInt(start) + total - BigInt(r.first)) % total;
   const len = BigInt(end) - BigInt(start);
   for (const [a, b] of [
-    [d, d + len < sold ? d + len : sold],
-    [0n, d + len > sold ? d + len - sold : 0n],
+    [d, d + len < total ? d + len : total],
+    [0n, d + len > total ? d + len - total : 0n],
   ]) {
     let p = Number((a + step - 1n) / step);
     for (p = Math.max(p, from); p < to && BigInt(p) * step < b; p++) out.push(p);
@@ -761,14 +804,13 @@ export const placeSet = place => Number(place.bps) > 0 || place.prize != null;
 /** The address of a lottery's current round's record (there or not). */
 export const roundAddress = (lotteryAddress, lottery) => pda.round(lotteryAddress, lottery.incarnation, lottery.round);
 
-/** Whether a lottery (decoded) drew once and has ended. */
-export const lotteryEnded = lottery => Number(lottery.every) === 0 && Number(lottery.round) > 0;
+/** Whether a lottery (decoded) drew its last round and has ended: it draws once (`every` 0) and is past round `last`. */
+export const lotteryEnded = lottery => Number(lottery.every) === 0 && Number(lottery.round) > Number(lottery.last ?? 0);
 
-/** The round a lottery's close, its write again and its own stash's moves name (`lottery::check_idle`): its current
- * round's, or once a lottery that draws once has ended, round 0's (which keeps its stash's NFTs until its places took
- * them out). */
+/** The round a lottery's close, its write again and its own stash's moves name (`Lottery::waits_on`): its current
+ * round's, or once it has ended, its last round's (which keeps its stash's NFTs until its places took them out). */
 export const idleRound = (lotteryAddress, lottery) =>
-  pda.round(lotteryAddress, lottery.incarnation, lotteryEnded(lottery) ? 0 : lottery.round);
+  pda.round(lotteryAddress, lottery.incarnation, lotteryEnded(lottery) ? lottery.last : lottery.round);
 
 /**
  * Who rents a listed NFT at `now` (Unix seconds), from its decoded Listing (or null for none): the renter's wallet while

package/js/client/grant.js

@@ -19,7 +19,7 @@ import { compareBytes, concat, fromHex, intLE, readUintLE, toBigInt, uintLE, utf
 import { meta } from '../chain/programs.js';
 import { sha256 } from '../chain/sha256.js';
 import { recordKey16 } from './accounts.js';
-import { ASSOCIATED_TOKEN_PROGRAM, gateAccounts, lootIx, prizeMetas, prizeNonce, tailOf } from './ix.js';
+import { ASSOCIATED_TOKEN_PROGRAM, gateAccounts, lootIx, prizeMetas, prizeNonce, shownFor, tailOf } from './ix.js';
 import { LOOT_PROGRAM, pda } from './pda.js';
 import IDL from './idl/loot.js';
 
@@ -400,7 +400,12 @@ export function claimGrantIx({
     },
     {
       remaining: [
-        ...gateAccounts(project, { gate: grant.gate, wallet, shown, listProof }),
+        ...gateAccounts(project, {
+          gate: grant.gate,
+          wallet,
+          shown: shownFor(project, grant.gate, wallet, shown),
+          listProof,
+        }),
         ...shards,
         ...prizes,
         ...tailOf(extra),