@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/economy/secrets.d.mts

@@ -0,0 +1,4 @@
+/** Whether a string looks like it carries a key, a token or a keyed RPC URL. */
+export declare const secretLike: (value: any) => boolean;
+/** Every place in `value` that looks like a key, a seed phrase or a keypair file. */
+export declare function findSecrets(value: any, path?: string): any;

package/types/economy/simulate.d.mts

@@ -0,0 +1,164 @@
+export declare const round: (x: any, digits?: number) => any;
+/** A budget of sales to walk, shared by every salePrices call of one simulation. */
+export declare const walkBudget: () => {
+    left: number;
+};
+/**
+ * What `perDay` sales a day over `days` pay, one every 1/perDay of a day (the first half a gap in), with the part's
+ * rise and fall exactly as the program prices them (state.rs `Fall::sell`): each sale pays the price fallen since the
+ * later of the fall's start and the last sale, and the price after it is what was paid plus the rise. A price that stops
+ * moving (at its cap, or at its floor with no rise) is counted at that price for every sale after; a rise by a fixed step
+ * alone (no percent, no fall) is an arithmetic series, summed at once. Every other sale walked comes out of `budget`
+ * (one a simulation, shared by its calls), and the walk throws once it runs out. { count, average, first, last }, in
+ * whole units.
+ */
+export declare function salePrices(part: any, perDay: any, days: any, fallStartsAfter?: number, budget?: {
+    left: number;
+}): {
+    count: number;
+    average: number;
+    first: number | undefined;
+    last: number;
+};
+export declare function simulate(economy: any, { now }?: {
+    now?: number | undefined;
+}): {
+    scenario: {
+        days: any;
+        perDay: any;
+        defaultPerDay: number;
+        defaultBidsPerDay: number;
+        defaultClaimsPerDay: number;
+    };
+    boxes: {
+        key: any;
+        name: any;
+        price: number;
+        averagePrice?: any;
+        token: any;
+        opensPerDay: number;
+        outcomes: any;
+        expectedBack: any;
+        returnPercent: any;
+        houseEdgePercent: any;
+        alsoPays: {};
+        unpriced: any[];
+        playerFee: number;
+        oracleFee: number;
+        realCost: {
+            price: any;
+            token: any;
+            atLeast?: boolean | undefined;
+            priceBack?: boolean | undefined;
+            playerFeeSol: number;
+            oracleSol: number;
+            networkSol: any;
+            rentSol: any;
+            rentIs?: string | undefined;
+            heldSol?: any;
+            heldIs?: string | undefined;
+            extrasSol: any;
+            totalSol?: any;
+            holdSol: any;
+        };
+        limitedStock?: boolean | undefined;
+        whenOut?: string | undefined;
+        stock?: {
+            whenOut: string;
+            stopsSellingInDays: any;
+            by: any;
+        } | {
+            by?: undefined;
+            whenOut: string;
+            runsOut: {
+                inDays: any;
+                outcomes: any;
+                chancesAfter: any;
+            }[];
+            stopsSellingInDays?: any;
+        } | undefined;
+        returnOfRealCostPercent?: any;
+    }[];
+    items: any;
+    payments: any;
+    recipes: any;
+    schedules: any;
+    lotteries: any;
+    farms: any;
+    grants: any;
+    contests: any;
+    auctions: any;
+    stashes: any;
+    pools: {
+        key: any;
+        pot?: any;
+        farm?: any;
+        token: any;
+        seed: any;
+        inPerDay: any;
+        outPerDay: any;
+        ins: any;
+        outs: any[];
+    }[];
+    perDay: {
+        players: {
+            pay: {
+                [k: string]: any;
+            };
+            getBack: {
+                [k: string]: any;
+            };
+            playerFeesSol: any;
+            oracleFeesSol: any;
+            networkFeesSol: any;
+            rentSol: any;
+        };
+        creator: {
+            treasury: {
+                [k: string]: any;
+            };
+            projectFeesSol: any;
+            oracleFeesSol: any;
+            networkFeesSol: any;
+            grantRentSol: any;
+        };
+        oracle: {
+            totalSol: any;
+        };
+        platform: {
+            playerFeesSol: any;
+            projectFeesSol: any;
+            totalSol: any;
+        };
+        burned: {
+            [k: string]: any;
+        };
+        accounts: {
+            [k: string]: any;
+        };
+    };
+    fees: {
+        playerSol: number;
+        projectSol: number;
+        oracleSol: number;
+        networkPerSignatureSol: number;
+        settleRentUnitSol: number;
+        ticketLineRentSol: any;
+        collectibleRentSol: number;
+        burnRefundSol: number;
+    };
+    notes: string[];
+};
+/** What the scenario doesn't name and doesn't count at its default, in words: ["grant claims none", "auction bids 10 a day"]. */
+export declare function unnamedExceptions(sim: any): any[];
+/** What the scenario assumes for what it doesn't name, in words: "100 a day (grant claims none, auction bids 10 a day)". */
+export declare function unnamedWords(sim: any): string;
+/** What becomes of a pool (a row of `simulate`'s pools) over the scenario's `days`, in words: "settles at about 40". */
+export declare function poolFate(p: any, days: any): string;
+/**
+ * A player's real cost of one action in words: the one number to quote. "about 0.0071 SOL in all (the price, the
+ * player fee, …); the wallet needs 0.0151 SOL when it signs, and the rest comes back".
+ */
+export declare function inAll(c: any): string;
+/** The simulation in plain words. */
+export declare function explain(sim: any, economy: any): string;

package/types/economy/txsize.d.mts

@@ -0,0 +1,17 @@
+export declare const MAX_TRANSACTION_BYTES = 1232;
+export declare const WALLET_ROOM = 64;
+export declare const BUDGET: number;
+export declare const compact: (n: any) => 1 | 2 | 3;
+/**
+ * instructions: [{ program: name, accounts: [names], data: bytes }]; signers: [names] (the fee payer first).
+ * Returns the estimated wire size in bytes.
+ */
+export declare function transactionSize({ instructions, signers }: {
+    instructions: any;
+    signers: any;
+}): any;
+/** How many accounts the transaction locks: each account once, its programs and signers included. */
+export declare function transactionLocks({ instructions, signers }: {
+    instructions: any;
+    signers: any;
+}): number;

package/types/economy/validate.d.mts

@@ -0,0 +1,3 @@
+export declare const SCHEMA: any;
+/** Every way `value` breaks `schema`, as { path, message }. An empty list means it is valid. */
+export declare function validate(value: any, schema?: any, root?: any, path?: string): any;

package/types/index.d.ts

@@ -0,0 +1,9 @@
+export { check, describe } from './economy/check.mjs';
+export { simulate, explain } from './economy/simulate.mjs';
+export { plan, setupSteps, playSteps } from './economy/plan.mjs';
+export { cost, explainCost } from './economy/cost.mjs';
+export { explainEconomy } from './economy/explain.mjs';
+export { model } from './economy/model.mjs';
+export { prepare, recordLanded, changedParts } from './economy/live.mjs';
+export { guideText, catalog, CANNOT } from './economy/guide.mjs';
+export { tools, PROGRAM_INFO, VERSION } from './mcp/tools.mjs';