@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/results/wire.d.ts

@@ -0,0 +1,122 @@
+export declare const RESULT_DOMAIN = "loot-result-v1";
+export declare const NO_GRANT = 65535;
+export declare const CLUSTERS: Readonly<{
+    devnet: 0;
+    mainnet: 1;
+}>;
+/** Each certificate's first line, and the lines that follow it, in order. */
+export declare const CERT_KINDS: Readonly<{
+    host: {
+        title: string;
+        fields: string[];
+    };
+    revoke: {
+        title: string;
+        fields: string[];
+    };
+    draw: {
+        title: string;
+        fields: string[];
+    };
+    lock: {
+        title: string;
+        fields: string[];
+    };
+    entry: {
+        title: string;
+        fields: string[];
+    };
+    giveaway: {
+        title: string;
+        fields: string[];
+    };
+    revokeGiveaway: {
+        title: string;
+        fields: string[];
+    };
+}>;
+/** The text the owner signs to let `host` report `game`'s results until `until` (unix seconds). */
+export declare const hostCertText: ({ cluster, game, host, until }: {
+    cluster?: string | undefined;
+    game: any;
+    host: any;
+    until: any;
+}) => string;
+/** The text the owner signs to take `host` back. */
+export declare const revokeText: ({ cluster, game, host }: {
+    cluster?: string | undefined;
+    game: any;
+    host: any;
+}) => string;
+/**
+ * The text the organizer (the game's owner or authority, or a host key they certified) signs to open a draw: a round
+ * whose winners an engine computes from the locked players and a future beacon value. `prizes`: [{ place, grant }];
+ * `payout`: 'vouchers' (the server vouches for each winner) or 'list' (the owner writes the winners' list on the grant);
+ * `identity`: 'linked' (a play-host sign-in linked to X, one entry a person) or 'wallet' (a wallet's own signature);
+ * `slug`: the game's play-host name (its tokens' audience), or '-'; `rates`: the sha256 of the engine's rates (canonical
+ * JSON), or 'default'.
+ */
+export declare const drawText: ({ cluster, game, draw, engine, winners, prizes, payout, identity, slug, rates }: {
+    cluster?: string | undefined;
+    draw: any;
+    engine: any;
+    game: any;
+    identity?: string | undefined;
+    payout?: string | undefined;
+    prizes?: never[] | undefined;
+    rates?: string | undefined;
+    slug?: string | undefined;
+    winners: any;
+}) => string;
+/** The text the organizer signs to lock a draw's players (`roster`: rosterHash) to a beacon round still to come. */
+export declare const lockText: ({ cluster, game, draw, roster, players, beacon, net }: {
+    beacon: any;
+    cluster?: string | undefined;
+    draw: any;
+    game: any;
+    net?: string | undefined;
+    players: any;
+    roster: any;
+}) => string;
+/** The text a player's wallet signs to enter a draw (identity 'wallet'). */
+export declare const entryText: ({ cluster, game, draw }: {
+    cluster?: string | undefined;
+    draw: any;
+    game: any;
+}) => string;
+/**
+ * The text the owner (or authority) signs to appoint a giveaway host: `who` is "x:<X account id>" (the host signs in
+ * with that X account through the play host) or a wallet address; their giveaways pay from grant `grant` alone.
+ */
+export declare const giveawayHostText: ({ cluster, game, who, slug, grant, until }: {
+    cluster?: string | undefined;
+    game: any;
+    grant: any;
+    slug: any;
+    until: any;
+    who: any;
+}) => string;
+/** The text the owner (or authority) signs to take a giveaway host back. */
+export declare const revokeGiveawayText: ({ cluster, game, who }: {
+    cluster?: string | undefined;
+    game: any;
+    who: any;
+}) => string;
+/** A draw's players, as one hash: each `id<TAB>wallet`, sorted by id, one a line; sha256, hex. */
+export declare function rosterHash(entries: any): Promise<string>;
+/** JSON with every object's keys sorted: one text for one value, so its hash means one thing. */
+export declare function canonicalJson(value: any): any;
+/**
+ * The bytes a result's signers sign:
+ *   "loot-result-v1" | cluster (1) | game (32) | round (16) | endedAt (u64 LE)
+ *   | winners (u8 count; each wallet (32) | place (u8) | grant id (u16 LE, 0xffff: none))
+ * Every field has one length, so one set of bytes means one result: an unknown cluster, a round that is not 16 bytes, a
+ * place past 255 and more than 255 winners are refused, never written as something else.
+ */
+export declare function resultBytes({ cluster, game, round, endedAt, winners }: {
+    cluster?: string | undefined;
+    endedAt: any;
+    game: any;
+    round: any;
+    winners: any;
+}): Uint8Array<any>;