@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/mcp/tools.d.mts

@@ -0,0 +1,635 @@
+export declare const VERSION: string;
+/** This package's exact version: every command the tools hand a person names it, so npx runs this very release. */
+export declare const PACKAGE_VERSION: any;
+/**
+ * A file name relative to the project folder as the approve command carries it: its folders split by / on every
+ * system (Windows' economy\xsolana.json too), or null when it is not plain by xsolana_save's rule. A name is never quoted
+ * (a quoted word is a POSIX shell's rule; PowerShell, cmd.exe and fish read the same quotes another way and would run
+ * the code planted in the name), so a plain one is one word, the same in every shell, and never an option.
+ */
+export declare function plainName(rel: any, paths?: any): string | null;
+/**
+ * The command an owner runs to approve going live in their own wallet, pinned to this package's exact version, with
+ * the spec's file (relative to the project folder, by `paths`' rules: the system's own unless given) as one plain
+ * word. A name that is not plain throws.
+ */
+export declare function approveCommand(file?: string, paths?: any): string;
+export declare const CLUSTER = "devnet";
+export declare const DEVNET_RPC = "https://api.devnet.solana.com";
+/** What every answer carries, so an agent never has to remember the program's address. */
+export declare const PROGRAM_INFO: Readonly<{
+    program: string;
+    cluster: "devnet";
+    version: string;
+    idl: "@xgamesfun/solana/idl.json";
+    package: `@xgamesfun/solana@${any}`;
+}>;
+export declare const DEFAULT_FILE = "xsolana.json";
+/**
+ * The spec file `rel` names, inside the project folder: a `.json` file there or in a folder below it. Anything else (an
+ * absolute path elsewhere, `..`, a link out of the folder, another kind of file) is refused.
+ */
+export declare function projectFile(rel: any, ctx: any): any;
+/**
+ * Whether a file's JSON is an economy spec, so xsolana_save may write over it: version 2 with its tokens (every spec that
+ * checks has them), a currency if it names one (a spec of one token checks without: that token is its currency)
+ * and nothing but the spec's keys, as it is or as the only key of a file, `economy` (a file with other keys beside it
+ * would lose them). Every spec xsolana_save writes passes.
+ */
+export declare function isSpec(value: any): boolean;
+/**
+ * Carries the program numbers of a live spec's parts (by key) into a new version of it, and its `live` section. Only
+ * the file on disk can have a `live` section (`xsolana approve` writes it as the setup lands): one the new version brings
+ * is dropped when the file had none, and replaced by the file's when it had one.
+ */
+export declare function carryIds(previous: any, next: any): any;
+/** In words: the spec changes the project's own settings, which publishing never writes. */
+export declare const settingsNote: (settings: any, live: any) => string;
+export declare const tools: ({
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            file?: undefined;
+            part: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            query?: undefined;
+            name?: undefined;
+            fit?: undefined;
+            limit?: undefined;
+            spec?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler({ part }?: Readonly<Record<string, any>>): Promise<{
+        program: string;
+        cluster: "devnet";
+        version: string;
+        idl: "@xgamesfun/solana/idl.json";
+        package: `@xgamesfun/solana@${any}`;
+        text: string;
+        parts: {
+            part: string;
+            type: any;
+            says: string;
+            atPlayTime?: any;
+            fields: {
+                name: string;
+                type: any;
+                required?: boolean | undefined;
+                default?: any;
+                says?: any;
+            }[];
+            nested?: any;
+        }[];
+        cannot?: {
+            what: string;
+            words: string;
+            why: string;
+            nearest: string[];
+        }[] | undefined;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            file?: undefined;
+            part?: undefined;
+            query: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            fit: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            spec?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler({ query, name, fit, limit }: Readonly<Record<string, any>> | undefined, ctx: any): Promise<{
+        name: any;
+        spec: any;
+        checks: string | any[];
+        text: string;
+        examples?: undefined;
+        ideas?: undefined;
+        hows?: undefined;
+        limits?: undefined;
+    } | {
+        name?: undefined;
+        checks?: undefined;
+        examples: any;
+        ideas: {
+            count: any;
+        };
+        text: string;
+        hows?: undefined;
+        limits?: undefined;
+        spec?: undefined;
+    } | {
+        name?: undefined;
+        checks?: undefined;
+        examples: any;
+        ideas: any;
+        hows: any;
+        limits: any;
+        text: string;
+        spec?: undefined;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+            example: {
+                type: string;
+                description: string;
+            };
+            part?: undefined;
+            query?: undefined;
+            name?: undefined;
+            fit?: undefined;
+            limit?: undefined;
+            scenario: {
+                type: string;
+                description: string;
+            };
+            json: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        from: any;
+        refusals: any;
+        warnings: any;
+        text: string;
+    } | {
+        ok: boolean;
+        from: any;
+        summary: {
+            boxes: {
+                key: any;
+                returnPercent: any;
+                houseEdgePercent: any;
+            }[];
+            pools: {
+                key: any;
+                lasts: any;
+                lastsDays: any;
+                settlesAt: any;
+            }[];
+            farms: any;
+            platformSolPerDay: any;
+        };
+        simulation?: {
+            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[];
+        } | undefined;
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+            example: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        from: any;
+        refusals: any;
+        warnings: any;
+        text: string;
+    } | {
+        ok: boolean;
+        from: any;
+        setup: any;
+        actions: any;
+        fees: any;
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+            example: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        refusals: any[];
+        warnings: any[];
+        needsAuthority?: undefined;
+        chance?: undefined;
+        from: any;
+        text: string;
+        setupSol?: undefined;
+    } | {
+        refusals?: undefined;
+        ok: boolean;
+        warnings: any[];
+        needsAuthority: boolean;
+        chance: boolean;
+        setupSol: any;
+        from: any;
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            part?: undefined;
+            query?: undefined;
+            name?: undefined;
+            fit?: undefined;
+            limit?: undefined;
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    handler(input: any, ctx: any): Promise<{
+        file?: undefined;
+        ok: boolean;
+        isError: boolean;
+        text: string;
+        warnings?: undefined;
+    } | {
+        file?: undefined;
+        ok: boolean;
+        from: any;
+        refusals: any;
+        warnings: any;
+        isError: boolean;
+        text: string;
+    } | {
+        isError?: undefined;
+        ok: boolean;
+        file: any;
+        warnings: any[];
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+        readOnlyHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {
+            spec: {
+                type: string;
+                description: string;
+            };
+            file: {
+                type: string;
+                description: string;
+            };
+            example: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        from: any;
+        refusals: any;
+        warnings: any;
+        text: string;
+    } | {
+        ok: boolean;
+        transactions: number;
+        approvals: number;
+        steps: never[];
+        text: string;
+        command?: undefined;
+        setupSol?: undefined;
+    } | {
+        ok: boolean;
+        command: string;
+        transactions: number;
+        approvals: number | undefined;
+        setupSol: any;
+        steps: any[];
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {
+            part?: undefined;
+            query?: undefined;
+            name?: undefined;
+            fit?: undefined;
+            limit?: undefined;
+            spec?: undefined;
+            file: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    handler(input: any, ctx: any): Promise<{
+        ok: boolean;
+        text: string;
+        rows?: undefined;
+    } | {
+        ok: boolean;
+        rows: ({
+            part: any;
+            address: any;
+            found: boolean;
+            kind: string;
+            sol: number;
+        } | {
+            sol?: undefined;
+            part: any;
+            address: any;
+            found: boolean;
+            amount?: number | undefined;
+            nfts?: any;
+            kind?: string | undefined;
+        })[];
+        text: string;
+    }>;
+} | {
+    name: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {
+            file?: undefined;
+            part?: undefined;
+            query?: undefined;
+            name?: undefined;
+            fit?: undefined;
+            limit?: undefined;
+            spec?: undefined;
+        };
+        additionalProperties: boolean;
+    };
+    handler(): Promise<{
+        program: string;
+        cluster: "devnet";
+        version: string;
+        idl: "@xgamesfun/solana/idl.json";
+        package: `@xgamesfun/solana@${any}`;
+        text: string;
+    }>;
+})[];