@xgamesfun/solana 0.20.1 → 0.24.0

package/types/client/accounts.d.ts

@@ -1,5 +1,8 @@
-export { MAX_RECEIPT_ROUNDS } from './sizes.js';
-/** Account tags: each account's first byte, as the program writes it. */
+/** The bytes of one time in a farm's record of ends (`decodeEnds`): rent its writer pays, not refunded when a seat leaves. */
+export declare const END_BYTES = 44;
+/** The bytes of a farm's record of ends with no time in it, its owner's rent at `open_farm`. */
+export declare const ENDS_HEAD_BYTES = 7;
+/** Account tags: each account's first byte, as the program writes it; every list of records (`decodeList`) is 26. */
 export declare const TAGS: Readonly<{
     Platform: 1;
     Project: 2;
@@ -11,23 +14,24 @@ export declare const TAGS: Readonly<{
     Recipe: 8;
     Hold: 9;
     Contest: 10;
-    Entry: 11;
     Sheet: 12;
     Traits: 13;
-    Grant: 14;
-    Receipt: 15;
-    LotteryContribution: 16;
+    LotteryRound: 16;
     Farm: 17;
     Seat: 18;
     Proven: 19;
     Auction: 20;
-    Stash: 21;
     Offer: 22;
     Listing: 23;
+    Profile: 24;
+    Grant: 27;
+    Table: 25;
+    List: 26;
+    Ends: 29;
 }>;
 /** The kind of a loot account from its first byte, or null. */
 export declare const accountKind: (data: any) => string | null;
-/** A loot account of the named kind (one the IDL describes). Throws when the data is not one. */
+/** A loot account of the named kind (one the IDL describes, or a `LotteryRound`). Throws when the data is not one. */
 export declare const decode: (name: any, data: any) => any;
 /** Any loot account: { kind, value }, or null for data that is no loot account. */
 export declare function decodeAny(data: any): {
@@ -35,18 +39,56 @@ export declare function decodeAny(data: any): {
     value: any;
 } | null;
 /**
- * A counter (a Receipt): a wallet's on a box, a lottery, a recipe or a grant, a person's or a key's on
- * a grant. { count (lifetime where tracked), window (the window `inWindow` counts), inWindow, rounds (the first 8
- * bytes of sha256 of each round a grant paid it, by voucher or list, in order), claimed(round) }. A round it holds
- * was paid once and can never be paid again.
+ * A list of records (tag 26, `list.rs`): { width, records } in their order: a wallet's counts
+ * (`["counts", project, wallet]`) and a grant's claims are limit records (28 bytes, `readLimit`), a grant's rounds 16
+ * bytes, a contest's entries 43 or 83 (`decodeEntries`).
  */
-export declare function decodeReceipt(data: any): {
+export declare function decodeList(data: any): {
+    width: number;
+    records: Uint8Array<ArrayBufferLike>[];
+};
+/**
+ * A farm's record of when its seats stop earning (`["ends", farm]`, tag 29; `Farm.keeps_ends`): its times in order, each
+ * `{ at, rewardPerWeight, weight, seats }`: the time (Unix seconds), `reward_per_weight` there once the farm has walked past
+ * it, the weight that stops earning then, and the seats that still need the record.
+ */
+export declare function decodeEnds(data: any): {
+    at: bigint;
+    rewardPerWeight: bigint;
+    weight: bigint;
+    seats: number;
+}[];
+/** The first 16 bytes of the sha256 of `parts` (addresses, bytes or u64s): a record's key in a list. */
+export declare const recordKey16: (...parts: any[]) => Uint8Array<ArrayBuffer>;
+/** The key of a wallet's count for a box, a recipe (incarnation 0) or a lottery (its incarnation), in its counts. */
+export declare const countKey: (record: any, incarnation?: number) => Uint8Array<ArrayBuffer>;
+/** What the limit record at `key` counts in a decoded list (`decodeList`, or null for none): { count, window, inWindow }. */
+export declare function readLimit(list: any, key: any): {
     count: number;
     window: number;
     inWindow: number;
-    rounds: Uint8Array<ArrayBuffer>[];
-    claimed: (round: any) => boolean;
 };
+/** A fetched list account, or null for none (or an empty System account someone sent SOL to, which the program opens
+ * as the list). Any other owner or layout is refused. */
+export declare function readListAccount(account: any): {
+    width: number;
+    records: Uint8Array<ArrayBufferLike>[];
+} | null;
+/**
+ * A contest's entries (`["entries", contest, incarnation, 0]`), in the list's order (by player): [{ player, side,
+ * amount (0 once paid or refunded; 1 while a contest of NFTs holds its NFT), bits (`CLAIMED`, `ENDED`), nft, place (how
+ * many entered its side before it), taken (the losers' NFTs a winner took) }]. A claim names an entry by its index here.
+ */
+export declare function decodeEntries(data: any): any[];
+/** A winner's first claim came (its prize given or forgone); a winner ended its picks early. */
+export declare const CLAIMED = 1;
+export declare const ENDED = 2;
+/** How many losers' NFTs a winner of a contest of NFTs takes: the share fixed at the decision, one more for an early
+ * place on its side. */
+export declare const shareOf: (contest: any, entry: any) => number;
+/** What a count allows `n` more of at `now` under `limit` ({ total, per_window, window }, 0 is no limit; a lottery's
+ * window is its round plus one, given as `window`). */
+export declare function countAllows(count: any, limit: any, now: any, n?: number, window?: number): boolean;
 /**
  * A Sheet (`["sheet", project, nft]`): what the project wrote about an NFT it has no authority over. Returns { project, nft,
  * attributes: [{ key, value }] }. A Sheet never written reads as none: pass `null` data for no account.
@@ -59,11 +101,49 @@ export declare function decodeSheet(data: any): {
         value: string;
     }[];
 } | null;
-/** A stash (`["stash", project, id]`): { project, id, nfts }, the NFTs the project holds to give away, in no order. */
+/** A player's profile (`["profile", project, wallet]`): { project, wallet, attributes }, what the project keeps about
+ * the wallet (its XP, level, rank). Its layout is a Sheet's, under its own tag. */
+export declare function decodeProfile(data: any): {
+    project: string;
+    wallet: string;
+    attributes: {
+        key: string;
+        value: string;
+    }[];
+} | null;
+/** What a table's rows carry (its payload byte). */
+export declare const PAYLOAD: Readonly<{
+    Number: 0;
+    Label: 1;
+    Nft: 2;
+}>;
+/** Where row `r` of a table of `len`-byte rows is: groups of 64 blocks of 64 rows, each led by its weight in stock. */
+export declare function tableRowAt(len: any, r: any): number;
+/**
+ * A table (`["table", project, id]`, `table.rs`): { project, id, payload ('Number' | 'Label'), sealed, count, total
+ * (the weight in stock), rows: [{ weight, left, label }] }. A row's `left` is `NO_LIMIT` (4294967295) for a stock that
+ * never runs out.
+ */
+export declare function decodeTable(data: any): {
+    project: string;
+    id: number;
+    payload: string;
+    sealed: boolean;
+    count: number;
+    total: bigint;
+    rows: {
+        weight: number;
+        left: number;
+        label: string;
+    }[];
+} | null;
+/** A stash (`["stash", project, id]`, or a lottery's own): { project, id, nfts, weights }, the NFTs the project holds to
+ * give away and the weight each is drawn by, as a table of NFTs keeps them (a row: its weight, then the NFT). */
 export declare function decodeStash(data: any): {
     project: string;
     id: number;
     nfts: string[];
+    weights: number[];
 } | null;
 /**
  * A compressed NFT's record (`["leaf", asset]`, `prove_leaf`): { asset, tree, owner (null once burned), delegate,
@@ -98,52 +178,111 @@ export declare function decodeTokenMetadata(data: any): {
     programmable: boolean;
     ruleSet: string | null;
 } | null;
-/** A fetched receipt, or null for a missing/prefunded empty System account. Other owners/layouts are refused. */
-export declare function readReceiptAccount(account: any): {
-    count: number;
-    window: number;
-    inWindow: number;
-    rounds: Uint8Array<ArrayBuffer>[];
-    claimed: (round: any) => boolean;
-} | null;
-/** What a counter allows `n` more of at `now` under `limit` ({ total, per_window, window }, 0 is no limit). */
-export declare function receiptAllows(receipt: any, limit: any, now: any, n?: number): boolean;
-/** The contribution among `contributions` ([{ address, value }], decoded LotteryContributions) that holds `ticket`. */
-export declare const contributionOf: (contributions: any, ticket: any) => any;
-/** Whether a lottery's place wins something: a share of the pot, a roll, or both (as the program counts a place set). */
-export declare const placeSet: (place: any) => boolean;
-/** The places of a lottery that have a winner this round: as many as are set, but no more than tickets. */
-export declare function lotteryWinners(lottery: any): number;
-/** The ticket that wins `place` of a drawn lottery: even steps around the list from first place's ticket. */
-export declare function ticketOfPlace(lottery: any, place: any): bigint;
-/** The places of a drawn lottery whose winning ticket is in `first..end` (a contribution's), in order. */
-export declare function placesWon(lottery: any, first: any, end: any): number[];
-/** The places of a drawn round that have a winner and a prize, in order: what it gives before its money moves. */
-export declare const prizePlaces: (lottery: any) => number[];
-/** The places a contribution won whose prize is not given yet (`Lottery.given`): its next step gives them. */
-export declare function lotteryOwed(lottery: any, contribution: any): number[];
-/** Whether every place's prize of a drawn round is given, so its money may move (`PrizesFirst`). */
-export declare const prizesGiven: (lottery: any) => boolean;
-/** The lowest place of a drawn round whose prize is not given yet, or null: prizes go in place order (`PlacesInOrder`). */
-export declare const nextPrizePlace: (lottery: any) => number | null;
+export declare const OWN_PAID: bigint;
+/** The mint a lottery's tickets are paid in (`terms`: a Lottery's or a round's): its ticket mint, burned, or its pot's. */
+export declare const paymentMint: (terms: any) => any;
+/** Whether a lottery's tickets are burned: they are paid in a ticket mint of its own. */
+export declare const ticketsBurn: (terms: any) => boolean;
+/** A share the buyer chooses (a referrer, a collectible's holder): paid out of the price as they buy, from their own account. */
+export declare const chosenAtPurchase: (share: any) => boolean;
+/** The bytes of one entry of a round: buyer, word, what arrived (`fee`: a fee mint, or a chosen share), the NFT ticket. */
+export declare const entryWidth: (fee: any, nft: any) => number;
 /**
- * What a contribution's next `finish_lottery_contribution` does, or null for nothing yet:
- *   'prizes'  give the prize of the next place it won, one place a call (a drawn round gives every prize before any money moves);
- *   'refund'  its tickets back to its buyer (a cancelled round, or a lottery that returns them);
- *   'finish'  its money through the shares into the pot, its tickets burned, or its NFT ticket spent (only once every
- *             prize of the round is given);
- *   'pay'     its places' shares of the pot, once every contribution of the round is finished.
+ * 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) }.
  */
-export declare function lotteryStep(lottery: any, contribution: any): "finish" | "pay" | "prizes" | "refund" | null;
+export declare function decodeRound(data: any): any;
+/** How many places a lottery's (or a round's) `places` are, every run counted (`Place.times`). */
+export declare const placeCount: (places: any) => any;
+/** The places of a round that have a winner: every place, but no more than tickets. */
+export declare const roundWinners: (r: any) => number;
+/** The ticket that wins `place` of a drawn round: even steps around the list from first place's ticket. */
+export declare function ticketOfPlace(r: any, place: any): bigint;
+/** The run of places that holds `place`, and its first place. */
+export declare function runOf(r: any, place: any): any[];
+/** The places of run `run` with a winner: [first, end). */
+export declare function runPlaces(r: any, run: any): number[];
+/** The places of run `run` whose ticket is in `start..end` (an entry's), in order. */
+export declare function placesIn(r: any, run: any, start: any, end: any): any[];
+/**
+ * What place `place` (counted from the first place of `runs`) takes of a pass-through amount, as the program splits it:
+ * runs of `[a, n]` (n places taking `a` each), `sent` what the places are owed and `arrived` what the round holds for
+ * them; the last place with a part takes what the others leave.
+ */
+export declare function splitPart(runs: any, sent: any, arrived: any, place: any): number | bigint;
+/** Whether place `place`'s part is paid: its pot part's bit (every place's first), or with `prize` its prize's (after
+ * every place's pot bit). */
+export declare const placePaid: (r: any, place: any, prize: any) => boolean;
+/** What entry `i`'s places in run `run` take and are not paid yet, of its pot part or (`prize`) its token prize. */
+export declare const placesOwed: (r: any, i: any, run: any, prize: any) => bigint;
+/** How many of the round's owed parts a pull of `{ Pot: [run] }` or a token `{ Prize: [run] }` for entry `i` settles:
+ * its places there that take more than nothing (one pull pays them all). */
+export declare const placesPulled: (r: any, i: any, run: any, prize: any) => number;
+/** Whether run `run` of a round's places gives tokens (its prize is fixed at the ask, a `TokenPrize`). */
+export declare const tokenRun: (r: any, run: any) => boolean;
+/** A place whose prize is an NFT of the lottery's own stash (`Held`, `Raffled`): assigned by the pulls, in place order. */
+export declare const ownStash: (place: any) => boolean;
+/** Entry `i`'s places in run `run` whose prize (not tokens) is not given yet, lowest first. */
+export declare const prizePlacesOwed: (r: any, i: any, run: any) => any[];
+/** Where in `r.nfts` the NFT of `place` is (a place of a run that holds or draws one of the lottery's own stash). */
+export declare function nftSlot(r: any, place: any): number;
+/** How many places of a round win an NFT of the lottery's own stash (every such place with a winner). */
+export declare function stashPlacesWon(r: any): number;
+/** Whether entry `i`'s places in run `run` (an NFT of the lottery's own stash) wait for their NFTs to be taken out
+ * (`LotteryRound::assign`): a pull with the stash alone does it, and `r.nfts` then names each. */
+export declare function awaitsNfts(r: any, i: any, run: any): boolean;
+/**
+ * The parts entry `i` of a round is owed now, in the order a keeper pulls them (`pullIx`'s `part`): its own ('Own': a
+ * refund, a no-loss ticket's price, its NFT ticket back or where its price sends it), and with `places`, its places'
+ * parts of the pot ({ Pot: [run] }) and prizes ({ Prize: [run] }). Parts owed in common (a share, the pot's, a pool's
+ * prize back) are no entry's: `commonOwed`.
+ */
+export declare function partsOwed(r: any, i: any, { places }?: {
+    places?: boolean | undefined;
+}): (string | {
+    Pot: number[];
+    Prize?: undefined;
+} | {
+    Pot?: undefined;
+    Prize: number[];
+})[];
+/**
+ * The parts of a round owed in common, of no entry (`{ Common: [i] }`): each share paid in common once drawn (one that
+ * burns is burned at the close), then what the round owes the lottery's pot (`i` = the shares' count), then after a
+ * cancel each pool's token prize back to its pool (past it).
+ */
+export declare function commonOwed(r: any): {
+    Common: any[];
+}[];
+/** The entry of a round holding `ticket`. */
+export declare const entryOf: (r: any, ticket: any) => any;
+/** Whether a round is done and owes nothing: the next pull closes it, given its close's accounts. */
+export declare const roundFinished: (r: any) => boolean;
+/** Whether a lottery's place wins something: a share of the pot, a prize, or both. */
+export declare const placeSet: (place: any) => boolean;
+/** The address of a lottery's current round's record (there or not). */
+export declare const roundAddress: (lotteryAddress: any, lottery: any) => any;
+/** Whether a lottery (decoded) drew once and has ended. */
+export declare const lotteryEnded: (lottery: any) => boolean;
+/** 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). */
+export declare const idleRound: (lotteryAddress: any, lottery: any) => any;
 /**
  * Who rents a listed NFT at `now` (Unix seconds), from its decoded Listing (or null for none): the renter's wallet while
  * a rental runs, else null (a sale listing, or a rental that is over).
  */
 export declare function renterOf(listing: any, now: any): any;
+/** Whether a schedule pays every run due when it is sent late (`schedule::catches_up`): only a sealed fixed amount. */
+export declare const scheduleCatchesUp: (schedule: any) => boolean;
 /**
- * How many runs of a schedule are due at `now` (Unix seconds, the chain's clock, never the computer's): each its own
- * `run_schedule`, several in one transaction to catch up; one too many fails the whole transaction. A sealed schedule
- * past its last run is due once whenever its vault holds something (`vaultBalance`), which goes where it always went.
+ * How many runs of a schedule are due at `now` (Unix seconds, the chain's clock, never the computer's). One `run_schedule`
+ * makes them all. A sealed schedule's fixed amount pays each of them (`scheduleCatchesUp`; up to its `upto`, the runs made
+ * after it: `schedule.runs` plus these, and a long backlog takes a few calls). Any other run pays once, for the latest
+ * run due, and those before it lapse. A sealed schedule past its last run is due once whenever its vault holds something
+ * (`vaultBalance`), which goes where it always went.
  */
 export declare function runsDue(schedule: any, now: any, vaultBalance?: bigint): number;
 /**
@@ -166,7 +305,8 @@ export declare const ERRORS: Readonly<{
 }>;
 /**
  * The loot error in a failed transaction's logs ("custom program error: 0x…", or Anchor's "Error Code: …" line), or
- * null. Only loot's own: another program the transaction calls (Bubblegum, the VRF program, …) has codes of its own
+ * null: { code, name, msg }, `msg` the IDL's sentence (the program's own log names the error only: its text is
+ * compiled out). Only loot's own: another program the transaction calls (Bubblegum, the VRF program, …) has codes of its own
  * that may be the same numbers, so an error is loot's only when loot is the program that logged it or failed with it.
  * The first program that fails is where the error came from; the programs that called it fail after it with the same
  * code.

package/types/client/grant.d.ts

@@ -1,19 +1,18 @@
-export declare const VOUCHER_DOMAIN = "loot-grant-v4";
+export declare const VOUCHER_DOMAIN = "loot-grant-v5";
 export declare const LIST_DOMAIN = "loot-list-v3";
 export declare const KEY_DOMAIN = "loot-key-v1";
-/** 13 + 32 × 4 + 8 + 16 + 8. */
-export declare const VOUCHER_BYTES = 181;
+/** What a voucher key signs: the prefix (13 bytes), then the sha256 of the voucher's body. */
+export declare const VOUCHER_BYTES = 45;
+/** A grant claim's compute limit: its rounds' records and prizes can pass the 200,000 a transaction has by default. */
+export declare const CLAIM_COMPUTE_UNITS = 400000;
 export declare const ZERO_HASH: Uint8Array<ArrayBuffer>;
 export declare const ED25519_PROGRAM = "Ed25519SigVerify111111111111111111111111111";
-/** The day the program counts `per_day` in. */
+/** The day a window of `DAY_SECONDS` counts in, from the unix epoch. */
 export declare const dayOf: (unixSeconds: any) => number;
 /** An i64 little-endian (two's complement), as the program reads `expires`. */
 export declare const i64LE: (value: any) => Uint8Array<any>;
-/**
- * The 181 bytes a voucher key signs and `claim_grant` rebuilds from its own accounts and arguments. `round` names the
- * win (the project round, draw or giveaway it was won in): the program pays a wallet each round once per grant incarnation.
- */
-export declare function voucherBytes({ program, grant, incarnation, wallet, personHash, round, expires, amount }: {
+/** A voucher's body, which its key signs the sha256 of (`voucherBytes`). */
+export declare function voucherBody({ program, grant, incarnation, wallet, personHash, expires, rounds, round, amount }: {
     amount?: bigint | undefined;
     expires: any;
     grant: any;
@@ -21,18 +20,28 @@ export declare function voucherBytes({ program, grant, incarnation, wallet, pers
     personHash: any;
     program?: string | undefined;
     round: any;
+    rounds: any;
     wallet: any;
 }): Uint8Array<any>;
-/** The fields back from voucher bytes (addresses as bytes). */
-export declare function readVoucher(bytes: any): {
+/**
+ * The 45 bytes a voucher key signs and `claim_grant` rebuilds from its own accounts and arguments: the prefix, then the
+ * sha256 of the voucher's body (`voucherBody`), so a voucher of many rounds is as short to check as one of one. `rounds`
+ * ([{ id, amount }], or one `round` and its `amount`) names the wins (the project round, draw or giveaway each was won
+ * in): the program pays a wallet each round once per grant incarnation.
+ */
+export declare const voucherBytes: (fields: any) => Uint8Array<any>;
+/** The fields back from a voucher's body (`voucherBody`; addresses as bytes, rounds as [{ id, amount }]). */
+export declare function readVoucher(body: any): {
     program: Uint8Array<ArrayBuffer>;
     grant: Uint8Array<ArrayBuffer>;
     incarnation: bigint;
     wallet: Uint8Array<ArrayBuffer>;
     personHash: Uint8Array<ArrayBuffer>;
-    round: Uint8Array<ArrayBuffer>;
     expires: bigint;
-    amount: bigint;
+    rounds: {
+        id: Uint8Array<ArrayBuffer>;
+        amount: bigint;
+    }[];
 };
 /** A voucher key's leaf under a grant's `key_root`. */
 export declare const keyLeaf: (key: any) => Uint8Array<ArrayBuffer>;
@@ -81,23 +90,41 @@ export declare function ed25519Ix({ publicKey, signature, message }: {
     keys: never[];
     data: Uint8Array<any>;
 };
+/** The key of a grant's limit record of `kind` ('wallet', 'person', 'badge', 'code') for `subject` (an address or 32
+ * bytes): sha256(kind | subject)[..16]. */
+export declare const limitKey: (kind: any, subject: any) => Uint8Array<ArrayBuffer>;
+/** The key of a wallet's record of a round a grant paid it: sha256(round | wallet)[..16]. */
+export declare const roundKey: (round: any, wallet: any) => Uint8Array<ArrayBuffer>;
+/** The shard a record's key falls in, of a grant's `2^bits`: the top `bits` bits of its first byte. */
+export declare const shardOf: (key: any, bits: any) => number;
+/** The rounds shard a wallet's paid rounds are kept in: its own limit record's. */
+export declare const walletShard: (grant: any, wallet: any) => number;
+/** Whether a grant paid `wallet` for `round`, from the wallet's decoded rounds shard (`decodeList`, null for none). */
+export declare const roundPaid: (list: any, wallet: any, round: any) => boolean;
+/**
+ * The fewest shard bits (0 to 8) that keep each of a grant's lists under ~100,000 records over its life: `wallets` ×
+ * the rounds each may claim (`rounds`). A 10,000-wallet airdrop takes 0 (one shard).
+ */
+export declare function shardBitsFor(wallets: any, rounds?: number): number;
 /**
  * The claim of grant `id` for `wallet`, sent and signed by `signer` (anyone: the play host, the owner's server, the
- * player). The grant's funds pay its rent through the signer; what they can't cover, the signer pays. The signer pays
- * the player fee with its own SOL. `grant` is the decoded Grant; `count` the wallet's receipt count before this claim (0 for a
- * first claim); `poolMint` the mint of a Payout's pool, read from the pool.
- * A voucher claim goes right after `ed25519Ix` in the same transaction, `voucherKey` the key that signed it (its
- * counter is passed when the grant limits keys; a key under the key root carries its `proof`); a list claim carries
- * its `proof`; an open grant (no keys, no key root, no list) needs neither. What passes its gate (`shown`, or
- * `listProof` for a list gate) comes first. Its prize (`grant.gives`, `prizeMetas`)
- * follows: `poolMint` for tokens from a pool, `item` (the decoded Item) for a collectible or a compressed NFT of one, `nft` for an NFT of a stash;
- * a roll's order at `nonce` (`prizeNonce(grant, round, count)` by default), then the rolled box's prize mints
- * (`rollMints`: `boxes` maps the box's id to its decoded LootBox, null for one never written; `rollPools` each pool its
- * prizes name to its mint, null for one never opened). The grant's funds pay what it opens.
+ * player). The grant's funds pay its records through the signer; what they can't cover, the signer pays. The signer pays
+ * the player fee, and a roll's order, with its own SOL. `grant` is the decoded Grant.
+ *
+ * A voucher claim goes right after `ed25519Ix` in the same transaction, `voucherKey` the key that signed it (a key under
+ * the key root carries its proof as `proofs[0]`); a list claim carries a proof for each round (`proofs`); an open grant
+ * (no keys, no key root, no list) names no round and pays one prize (`count`: the wallet's claims before it, for its
+ * roll's nonce). `rounds` ([{ id, amount }], or one `round` and its `amount`) are the wins it names: each paid once, so
+ * one already paid is skipped (`paidRounds`: the wallet's decoded rounds shard, `decodeList`, to leave out its prize's
+ * accounts). What passes its gate (`shown`, or `listProof` for a list gate) comes first, then each shard of the grant's
+ * claims it counts in, then each round's prize (`grant.gives`, `prizeMetas`): `poolMint` for tokens from a pool, `item`
+ * (the decoded Item) for a collectible or a compressed NFT of one, `nft` for an NFT of a stash; round `i`'s roll at
+ * `prizeRollNonce(nonce + i)` (`nonce`: `prizeNonce` of the grant, the wallet and its rounds by default), its box and
+ * order only (`askRollIx` then asks for it, in the same transaction when it fits). Send it with a compute limit of
+ * `CLAIM_COMPUTE_UNITS`.
  */
-export declare function claimGrantIx({ project, id, grant, wallet, signer, count, round, expires, personHash, amount, proof, poolMint, item, nft, boxes, rollPools, shown, listProof, programs, voucherKey, nonce, extra }: {
+export declare function claimGrantIx({ project, id, grant, wallet, signer, count, rounds, round, expires, personHash, amount, proofs, proof, paidRounds, poolMint, item, nft, shown, listProof, programs, voucherKey, nonce, extra }: {
     amount?: bigint | undefined;
-    boxes?: {} | undefined;
     count?: number | undefined;
     expires: any;
     extra?: never[] | undefined;
@@ -107,13 +134,15 @@ export declare function claimGrantIx({ project, id, grant, wallet, signer, count
     listProof: any;
     nft: any;
     nonce: any;
+    paidRounds?: null | undefined;
     personHash: any;
     poolMint: any;
     programs: any;
     project: any;
     proof?: never[] | undefined;
-    rollPools?: {} | undefined;
+    proofs: any;
     round: any;
+    rounds: any;
     shown: any;
     signer: any;
     voucherKey: any;
@@ -123,3 +152,19 @@ export declare function claimGrantIx({ project, id, grant, wallet, signer, count
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * Anyone closes shard `shard` of a grant's rounds (`rounds`) or claims once the grant is closed or made again
+ * (`incarnation` the one the shard is of): its rent goes to the project's `owner`.
+ */
+export declare const closeShardIx: ({ project, id, incarnation, rounds, shard, owner }: {
+    id: any;
+    incarnation: any;
+    owner: any;
+    project: any;
+    rounds?: boolean | undefined;
+    shard: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};