@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/client/accounts.d.ts

@@ -0,0 +1,178 @@
+export { MAX_RECEIPT_ROUNDS } from './sizes.js';
+/** Account tags: each account's first byte, as the program writes it. */
+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;
+    Entry: 11;
+    Sheet: 12;
+    Traits: 13;
+    Grant: 14;
+    Receipt: 15;
+    LotteryContribution: 16;
+    Farm: 17;
+    Seat: 18;
+    Proven: 19;
+    Auction: 20;
+    Stash: 21;
+    Offer: 22;
+    Listing: 23;
+}>;
+/** 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. */
+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 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.
+ */
+export declare function decodeReceipt(data: any): {
+    count: number;
+    window: number;
+    inWindow: number;
+    rounds: Uint8Array<ArrayBuffer>[];
+    claimed: (round: any) => 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 stash (`["stash", project, id]`): { project, id, nfts }, the NFTs the project holds to give away, in no order. */
+export declare function decodeStash(data: any): {
+    project: string;
+    id: number;
+    nfts: string[];
+} | 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;
+/** 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;
+/**
+ * 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.
+ */
+export declare function lotteryStep(lottery: any, contribution: any): "finish" | "pay" | "prizes" | "refund" | null;
+/**
+ * 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;
+/**
+ * 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.
+ */
+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. 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,125 @@
+export declare const VOUCHER_DOMAIN = "loot-grant-v4";
+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;
+export declare const ZERO_HASH: Uint8Array<ArrayBuffer>;
+export declare const ED25519_PROGRAM = "Ed25519SigVerify111111111111111111111111111";
+/** The day the program counts `per_day` in. */
+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 }: {
+    amount?: bigint | undefined;
+    expires: any;
+    grant: any;
+    incarnation: any;
+    personHash: any;
+    program?: string | undefined;
+    round: any;
+    wallet: any;
+}): Uint8Array<any>;
+/** The fields back from voucher bytes (addresses as bytes). */
+export declare function readVoucher(bytes: any): {
+    program: Uint8Array<ArrayBuffer>;
+    grant: Uint8Array<ArrayBuffer>;
+    incarnation: bigint;
+    wallet: Uint8Array<ArrayBuffer>;
+    personHash: Uint8Array<ArrayBuffer>;
+    round: Uint8Array<ArrayBuffer>;
+    expires: bigint;
+    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 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.
+ */
+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 }: {
+    amount?: bigint | undefined;
+    boxes?: {} | undefined;
+    count?: number | undefined;
+    expires: any;
+    extra?: never[] | undefined;
+    grant: any;
+    id: any;
+    item: any;
+    listProof: any;
+    nft: any;
+    nonce: any;
+    personHash: any;
+    poolMint: any;
+    programs: any;
+    project: any;
+    proof?: never[] | undefined;
+    rollPools?: {} | undefined;
+    round: any;
+    shown: any;
+    signer: any;
+    voucherKey: any;
+    wallet: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};