@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/client/accounts.d.ts

@@ -0,0 +1,318 @@
+/** 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;
+    Item: 3;
+    LootBox: 4;
+    Order: 5;
+    Schedule: 6;
+    Lottery: 7;
+    Recipe: 8;
+    Hold: 9;
+    Contest: 10;
+    Sheet: 12;
+    Traits: 13;
+    LotteryRound: 16;
+    Farm: 17;
+    Seat: 18;
+    Proven: 19;
+    Auction: 20;
+    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, 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): {
+    kind: string;
+    value: any;
+} | null;
+/**
+ * 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 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;
+};
+/** 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.
+ */
+export declare function decodeSheet(data: any): {
+    project: string;
+    nft: string;
+    attributes: {
+        key: string;
+        value: string;
+    }[];
+} | null;
+/** 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,
+ * collection (or null), flags, nonce, root (hex: the tree's root it holds for), payer }. Routes read it only while the
+ * tree's root is still `root`; after that anyone may close it (`closeLeafIx`).
+ */
+export declare function decodeProven(data: any): {
+    asset: string;
+    tree: string;
+    owner: any;
+    delegate: any;
+    collection: any;
+    flags: number;
+    nonce: bigint;
+    root: string;
+    payer: string;
+};
+/** The traits a project vouches for (`["traits", project, key]`): { project, key, root (hex) }. */
+export declare function decodeTraits(data: any): {
+    project: string;
+    key: string;
+    root: string;
+};
+/**
+ * A Token Metadata account (`MetadataV1`), read as far as a farm needs: { mint, collection (the one it is verified
+ * in, or null), programmable (a pNFT), ruleSet (a pNFT's, or null) }. Null for anything else. Older accounts end
+ * early: what is not there reads as none.
+ */
+export declare function decodeTokenMetadata(data: any): {
+    mint: string;
+    collection: string | null;
+    programmable: boolean;
+    ruleSet: string | null;
+} | 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;
+/**
+ * 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 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). 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;
+/**
+ * The receipts (Anchor events) of a transaction that succeeded: [{ name, data }]. Pass what getTransaction returns
+ * (`{ meta: { err, logMessages } }`), or the logs and the transaction's `meta.err`. Success is `meta.err === null` and
+ * nothing else: a transaction can fail after every instruction logged success (the runtime's rent check, for one),
+ * and its logs still hold every receipt, so a transaction with an error gives none. A backend delivers from a
+ * finalized transaction's receipts, once per order or reference.
+ */
+export declare function receipts(tx: any, err: any): {
+    name: any;
+    data: any;
+}[];
+/** The program's errors by code: { code: { name, msg } }. */
+export declare const ERRORS: Readonly<{
+    [k: string]: {
+        name: string;
+        msg: string;
+    };
+}>;
+/**
+ * The loot error in a failed transaction's logs ("custom program error: 0x…", or Anchor's "Error Code: …" line), or
+ * 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.
+ */
+export declare function lootError(logs: any): {
+    name: string;
+    msg: string;
+    code: number;
+} | null;

package/types/client/compressed.d.ts

@@ -0,0 +1,29 @@
+/**
+ * How many of a proof's nodes a transaction passes for this tree: the levels its canopy does not keep. `treeData` is
+ * the tree account's bytes.
+ */
+export declare function proofLength(treeData: any): number;
+/**
+ * A compressed NFT from an indexer's answers: `asset` (DAS `getAsset`), `proof` (DAS `getAssetProof`) and the tree
+ * account's bytes (`treeData`, for how much of the proof to pass). Returns { id, tree, nonce, owner, delegate,
+ * collection (or null), dataHash, creatorHash, assetDataHash (or null), flags, root, proof: [node, …] }. The proof
+ * must be against the tree's current root when it lands: fetch it just before sending.
+ */
+export declare function compressedFromDas({ asset, proof, treeData }: {
+    asset: any;
+    proof: any;
+    treeData: any;
+}): {
+    id: any;
+    tree: any;
+    nonce: bigint;
+    owner: any;
+    delegate: any;
+    collection: any;
+    dataHash: Uint8Array<ArrayBuffer> | null;
+    creatorHash: Uint8Array<ArrayBuffer> | null;
+    assetDataHash: Uint8Array<ArrayBuffer> | null;
+    flags: number;
+    root: Uint8Array<ArrayBuffer> | null;
+    proof: any;
+};

package/types/client/grant.d.ts

@@ -0,0 +1,170 @@
+export declare const VOUCHER_DOMAIN = "loot-grant-v5";
+export declare const LIST_DOMAIN = "loot-list-v3";
+export declare const KEY_DOMAIN = "loot-key-v1";
+/** 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 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>;
+/** 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;
+    incarnation: any;
+    personHash: any;
+    program?: string | undefined;
+    round: any;
+    rounds: any;
+    wallet: any;
+}): Uint8Array<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>;
+    expires: 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>;
+/** A list entry's round as the leaf names it: a number (a spec's `round`) in the first 8 of 16 bytes; 0 is zeros. */
+export declare const listRound: (n?: number) => Uint8Array<ArrayBuffer>;
+/**
+ * A leaf of an approved list: `wallet` won `round` (16 bytes or 32 hex characters; zeros when not given). A round is
+ * paid once, so a list can name the winners of many rounds, and a wallet's earlier wins stay claimable when a new
+ * list adds later ones.
+ */
+export declare const listLeaf: (wallet: any, personHash: any, round: any, amount?: bigint) => Uint8Array<ArrayBuffer>;
+/** The prefix of a wallet's leaf in a list gate (`gateListLeaf`). */
+export declare const GATE_LIST_DOMAIN = "loot-list-v1";
+/** A wallet's leaf in a list gate (`Gate::List`): sha256("loot-list-v1" | wallet). Its tree is a list's
+ * (`merkleRoot`, `merkleProof`), and its proof's nodes go where an NFT shown would (`gateAccounts`'s `listProof`). */
+export declare const gateListLeaf: (wallet: any) => Uint8Array<ArrayBuffer>;
+/** The parent of two nodes: sha256 of the smaller then the larger. */
+export declare const parentOf: (a: any, b: any) => Uint8Array<ArrayBuffer>;
+/** The root of the leaves, in the order given. Whoever builds the list keeps that order. */
+export declare const merkleRoot: (leaves: any) => any;
+/** The siblings of leaf `index`, from the bottom up. */
+export declare function merkleProof(leaves: any, index: any): any[];
+/**
+ * A list gate's tree (`Gate::List`) for `wallets`, in the order given: its `root`, its `depth`, and `proofOf(wallet)`.
+ * The gate reads exactly `depth` nodes, so the leaves are filled up to a power of two with a leaf no wallet has (all
+ * zeros): every wallet's proof is then `depth` nodes long.
+ */
+export declare function gateList(wallets: any): {
+    root: any;
+    depth: number;
+    proofOf: (wallet: any) => any[];
+};
+/** Whether `proof` leads from `leaf` to `root`. */
+export declare function verifyProof(leaf: any, proof: any, root: any): boolean;
+/**
+ * The Ed25519 precompile instruction for one signature, everything in its own data: count 1, padding, seven u16
+ * offsets with instruction index 0xffff (this instruction), then the key at 16, the signature at 48, the message at
+ * 112. `claim_grant` reads it through the instructions sysvar, in the instruction right before itself.
+ */
+export declare function ed25519Ix({ publicKey, signature, message }: {
+    message: any;
+    publicKey: any;
+    signature: any;
+}): {
+    programId: string;
+    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 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, rounds, round, expires, personHash, amount, proofs, proof, paidRounds, poolMint, item, nft, shown, listProof, programs, voucherKey, nonce, extra }: {
+    amount?: bigint | undefined;
+    count?: number | undefined;
+    expires: any;
+    extra?: never[] | undefined;
+    grant: any;
+    id: any;
+    item: any;
+    listProof: any;
+    nft: any;
+    nonce: any;
+    paidRounds?: null | undefined;
+    personHash: any;
+    poolMint: any;
+    programs: any;
+    project: any;
+    proof?: never[] | undefined;
+    proofs: any;
+    round: any;
+    rounds: any;
+    shown: any;
+    signer: any;
+    voucherKey: any;
+    wallet: any;
+}): {
+    programId: string;
+    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>;
+};