@xgamesfun/solana 0.20.1 → 0.25.0

package/types/play/keys.d.ts

@@ -0,0 +1,51 @@
+/** An Ed25519 key from its 32-byte seed: { address, sign(message) }. */
+export declare function keyFromSeed(seed: any, name?: null): Promise<{
+    address: string;
+    name: null;
+    sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The text a wallet signs once a session for its settle keys. It moves nothing and says so. */
+export declare const settleKeysText: (project: any, wallet: any) => string;
+/**
+ * The page's storage of keys that can't be made again (`localStorage`), and a device key that encrypts them, kept in
+ * IndexedDB as a non-extractable AES-GCM key. Null where either is missing (then keys live in memory only).
+ */
+export declare function browserStore(): {
+    get: (k: any) => string | null;
+    set: (k: any, v: any) => void;
+    remove: (k: any) => void;
+    keys: () => (string | null)[];
+    cryptoKey: () => any;
+} | null;
+/**
+ * The keys of `wallet` ({ address, signMessage? }) in `project`. `store`: `browserStore()`'s shape ({ get, set, remove,
+ * keys, cryptoKey }), or null. `key(name)` makes the key named by an address (asking the wallet for its signature the
+ * first time in a session); `again(name)` makes it again for a job left unfinished, or finds it stored, or null;
+ * `stored()` lists the names of keys stored; `forget(name)` drops a stored key once its job is done and it is empty.
+ * `how()` says how keys are made: 'derived', 'stored' or 'memory'.
+ */
+export declare function keyring({ wallet, project, store }: {
+    project: any;
+    store?: null | undefined;
+    wallet: any;
+}): {
+    how(): Promise<"derived" | "memory" | "stored">;
+    /** The key named `name` (an address) for a new job. */
+    key(name: any): Promise<{
+        address: string;
+        name: null;
+        sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+    }>;
+    /** The key named `name` again, for a job left unfinished: made again from the wallet's signature, or read from
+     * storage; null when neither can. `ask`: false to make it only from a signature already given this session. */
+    again(name: any, { ask }?: {
+        ask?: boolean | undefined;
+    }): Promise<{
+        address: string;
+        name: null;
+        sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+    } | null>;
+    /** The names of the keys this page stored for the wallet (none when keys are made from its signature). */
+    stored(): any;
+    forget(name: any): void;
+};

package/types/results/index.d.ts

@@ -1,4 +1,4 @@
-export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, rosterHash } from './wire.js';
+export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, rosterHash, } from './wire.js';
 /** games.fun's results server, on its play host (devnet until the program's audit). */
 export declare const RESULTS_SERVER = "https://play.xgames.fun/xsolana";
 /** A fresh round id: 16 random bytes, in hex. Make it when the round starts. */
@@ -28,7 +28,7 @@ export declare function signResult(signer: any, result: any, cluster?: string):
  * with the same result is safe: it is the same answer. Returns the server's answer, { result, vouchers }, or throws its
  * { code, why }.
  */
-export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl }: {
+export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl, }: {
     cert: any;
     cluster?: string | undefined;
     endedAt: any;
@@ -58,7 +58,7 @@ export declare function fetchVouchers({ server, game, round, wallet, fetchImpl }
  * Returns { wallet, grant, incarnation, publicKey, signature, round, expires, personHash, amount } for js/play claimGrant,
  * plain JSON (`incarnation` and `amount` as decimal text), so a server can send it as it is.
  */
-export declare function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds, personHash, amount }: {
+export declare function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds, personHash, amount, }: {
     amount?: bigint | undefined;
     game: any;
     grant: any;
@@ -95,7 +95,7 @@ export declare const draws: {
         signMessage: any;
     }) => Promise<any>;
     /** A player enters with their play-host token, or with their wallet's signature (`wallet`, `signMessage`). */
-    enter: ({ server, game, draw, token, wallet, signMessage, cluster, fetchImpl }: {
+    enter: ({ server, game, draw, token, wallet, signMessage, cluster, fetchImpl, }: {
         cluster?: string | undefined;
         draw: any;
         fetchImpl?: typeof fetch | undefined;
@@ -106,7 +106,7 @@ export declare const draws: {
         wallet?: null | undefined;
     }) => Promise<any>;
     /** Locks the players the server holds now to `beacon`, a drand round still to come. Checks their hash itself. */
-    lock: ({ server, game, draw, beacon, signMessage, by, cert, cluster, net, fetchImpl }: {
+    lock: ({ server, game, draw, beacon, signMessage, by, cert, cluster, net, fetchImpl, }: {
         beacon: any;
         by: any;
         cert?: null | undefined;
@@ -141,7 +141,7 @@ export declare const giveaways: {
         winners: any;
     }) => Promise<any>;
     /** Reports its result, signed by its session key. `grant`: the host's grant (each winner is paid from it). */
-    report: ({ server, game, giveaway, session, endedAt, winners, grant, cluster, fetchImpl }: {
+    report: ({ server, game, giveaway, session, endedAt, winners, grant, cluster, fetchImpl, }: {
         cluster?: string | undefined;
         endedAt: any;
         fetchImpl?: typeof fetch | undefined;
@@ -153,3 +153,4 @@ export declare const giveaways: {
         winners: any;
     }) => Promise<any>;
 };
+export { codeAddresses, codeKey, codeVoucher, collectiblesOf, holds, makeCodes, normalizeCode, proofRequest, proofText, readProof, verifyProof, } from './server.js';

package/types/results/server.d.ts

@@ -0,0 +1,126 @@
+/**
+ * The game's collectibles `wallet` holds now, read from the chain (Metaplex Core assets of the live spec's collection
+ * and of the collections it names): [{ asset, item (its key in the spec, or null), itemId, name, uri, attributes,
+ * frozen }]. `rpc`: an RPC link or a `rpcClient`. Token Metadata and compressed NFTs are not read here.
+ */
+export declare function collectiblesOf({ rpc, spec, wallet }: {
+    rpc: any;
+    spec: any;
+    wallet: any;
+}): Promise<{
+    owner: string;
+    collection: string | null;
+    name: string;
+    uri: string;
+    attributes: {};
+    frozen: boolean;
+    soulbound: boolean;
+    asset: any;
+    itemId: number | null;
+    item: any;
+}[]>;
+/**
+ * Whether `wallet` holds at least `atLeast` of the game's collectible `item` (its key in the spec), or of any of the
+ * game's collectibles when `item` is left out. With `attribute`, only those whose number under it is at least
+ * `minimum` count (a level, a rarity). → the count it holds when that is enough, else 0.
+ */
+export declare function holds({ rpc, spec, wallet, item, atLeast, attribute, minimum }: {
+    atLeast?: number | undefined;
+    attribute?: null | undefined;
+    item?: null | undefined;
+    minimum?: number | undefined;
+    rpc: any;
+    spec: any;
+    wallet: any;
+}): Promise<number>;
+/** The exact text a wallet signs to prove it is its owner's: fixed lines, so nothing else can be passed off as it. */
+export declare const proofText: ({ cluster, game, wallet, purpose, nonce, expires }: {
+    cluster?: string | undefined;
+    expires: any;
+    game: any;
+    nonce: any;
+    purpose: any;
+    wallet: any;
+}) => string;
+/**
+ * A proof to ask of `wallet`, made by the server: { text, nonce, expires }. The server keeps `nonce` until `expires`
+ * (unix seconds, `seconds` from now) and takes each nonce once, so a signed proof can't be replayed.
+ */
+export declare function proofRequest({ cluster, game, wallet, purpose, seconds, now, }: {
+    cluster?: string | undefined;
+    game: any;
+    now?: number | undefined;
+    purpose?: string | undefined;
+    seconds?: number | undefined;
+    wallet: any;
+}): {
+    text: string;
+    nonce: string;
+    expires: number;
+};
+/** A proof text's fields, or null when it is not one. */
+export declare function readProof(text: any): {
+    expires: any;
+} | null;
+/**
+ * Checks a wallet's signed proof: the text is a proof for this `game` (and `purpose`, when given), for `wallet`, not
+ * expired at `now`, and `signature` (base58, or 64 bytes) is that wallet's Ed25519 signature of it. → the proof's
+ * fields ({ wallet, nonce, expires, … }), or throws in words. Taking each nonce once is the caller's: check
+ * `fields.nonce` against the ones the server handed out and not yet used.
+ */
+export declare function verifyProof({ text, signature, wallet, game, purpose, cluster, now, }: {
+    cluster?: string | undefined;
+    game: any;
+    now?: number | undefined;
+    purpose?: null | undefined;
+    signature: any;
+    text: any;
+    wallet: any;
+}): Promise<{
+    expires: any;
+}>;
+/**
+ * `n` fresh promo codes, each `bits` of randomness (80 by default, 16 characters of Crockford base32, in groups of 4).
+ * A code's key is in the spec for anyone to read, so a short code can be found by trying them all offline: fewer than
+ * 64 bits is refused.
+ */
+export declare function makeCodes(n: any, { bits, group }?: {
+    bits?: number | undefined;
+    group?: number | undefined;
+}): string[];
+/** A code as typed, read the forgiving way (Crockford): case, spaces and dashes don't matter, O reads 0, I and L read 1. */
+export declare const normalizeCode: (code: any) => string;
+/** The key a code stands for: { address, sign } (Ed25519, its seed sha256 of the domain and the code). */
+export declare function codeKey(code: any, { domain }?: {
+    domain?: string | undefined;
+}): Promise<{
+    address: string;
+    sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The public keys for a grant's `keys`, one per code, in order. */
+export declare const codeAddresses: (codes: any, options: any) => Promise<any[]>;
+/**
+ * A voucher a typed code signs for `wallet` (the page, or a server, makes it): the grant pays it once per code with
+ * `limits.perKey: 1`. Its round is the code's own, so one wallet can't use one code twice either. `incarnation` is the
+ * grant's, read from the chain; `now` the cluster's clock.
+ */
+export declare function codeVoucher({ code, game, grant, incarnation, wallet, now, seconds, domain, }: {
+    code: any;
+    domain?: string | undefined;
+    game: any;
+    grant: any;
+    incarnation: any;
+    now: any;
+    seconds?: number | undefined;
+    wallet: any;
+}): Promise<{
+    wallet: any;
+    grant: any;
+    incarnation: string;
+    publicKey: any;
+    signature: string;
+    round: any;
+    expires: number;
+    personHash: string;
+    amount: string;
+}>;

package/types/results/wire.d.ts

@@ -56,7 +56,7 @@ export declare const revokeText: ({ cluster, game, host }: {
  * `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 }: {
+export declare const drawText: ({ cluster, game, draw, engine, winners, prizes, payout, identity, slug, rates, }: {
     cluster?: string | undefined;
     draw: any;
     engine: any;