@xgamesfun/solana 0.20.1 → 0.25.0

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>;
+};