@xgamesfun/solana 0.28.6 → 0.28.7

package/README.md

@@ -77,7 +77,7 @@ codex plugin add xsolana@xgamesfun
 
 **claude.ai, ChatGPT or Claude Desktop:** add `https://xgames.fun/mcp` as a custom connector. Nothing to install.
 
-**Cursor, Cline, opencode or any MCP client:** run `npx -y --package=@xgamesfun/solana@0.28.6 xsolana mcp`.
+**Cursor, Cline, opencode or any MCP client:** run `npx -y --package=@xgamesfun/solana@0.28.7 xsolana mcp`.
 
 **Any agent that reads skills** (Copilot, Gemini CLI, Windsurf…): `npx skills add XGamesFun/solana-kit`.
 
@@ -88,26 +88,26 @@ are in [docs/harnesses.md](docs/harnesses.md).
 
 ```bash
 # find a worked example close to your idea
-npx -y @xgamesfun/solana@0.28.6 examples shop with loot boxes
+npx -y @xgamesfun/solana@0.28.7 examples shop with loot boxes
 
 # using a coin you already launched? read it from the chain into its "tokens" entry
-npx -y @xgamesfun/solana@0.28.6 token <its mint address>
+npx -y @xgamesfun/solana@0.28.7 token <its mint address>
 
 # does it work? where does the money go? what does it cost?
-npx -y @xgamesfun/solana@0.28.6 check xsolana.json
-npx -y @xgamesfun/solana@0.28.6 simulate xsolana.json
-npx -y @xgamesfun/solana@0.28.6 cost xsolana.json
+npx -y @xgamesfun/solana@0.28.7 check xsolana.json
+npx -y @xgamesfun/solana@0.28.7 simulate xsolana.json
+npx -y @xgamesfun/solana@0.28.7 cost xsolana.json
 
 # the whole economy in plain words, and what a cheater could get
-npx -y @xgamesfun/solana@0.28.6 explain xsolana.json
-npx -y @xgamesfun/solana@0.28.6 review xsolana.json
+npx -y @xgamesfun/solana@0.28.7 explain xsolana.json
+npx -y @xgamesfun/solana@0.28.7 review xsolana.json
 
 # go live: a key file for the project (it prints the address to send SOL to, never the key)…
-npx -y @xgamesfun/solana@0.28.6 keygen ~/.config/xsolana/my-game.json
+npx -y @xgamesfun/solana@0.28.7 keygen ~/.config/xsolana/my-game.json
 # …then everything going live would send, and a code; nothing is sent
-npx -y @xgamesfun/solana@0.28.6 approve xsolana.json --keypair ~/.config/xsolana/my-game.json
+npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair ~/.config/xsolana/my-game.json
 # …and with that code, exactly what it listed is sent
-npx -y @xgamesfun/solana@0.28.6 approve xsolana.json --keypair ~/.config/xsolana/my-game.json --yes <code>
+npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair ~/.config/xsolana/my-game.json --yes <code>
 ```
 
 Each command names an exact version, so you always run the release you meant to. `xsolana help` lists them all.

package/js/play/index.js

@@ -3220,7 +3220,9 @@ export function solanaApp({
      * `chosenRecipient`: the wallet (or collectible) the player names for a share the lottery lets them choose (a
      * referrer). A lottery whose ticket costs an NFT (`nft_ticket`) sells one ticket for one of the player's NFTs that
      * passes its rule: `nft`, its address (held by the project until the draw, then burned, given on or stashed; back to
-     * the player if the round is cancelled). `listProof`: for a list gate.
+     * the player if the round is cancelled). `listProof`: for a list gate. `make`: { recipe, times, listing (or
+     * version), assets }, a recipe crafted first in the same transaction, so a player short of what a ticket costs (an
+     * entry a recipe makes) approves once for both; a recipe that rolls can't ride along.
      */
     async buyTickets(
       lotteryKey,
@@ -3233,12 +3235,13 @@ export function solanaApp({
         listing,
         maxPrice,
         acceptLeftover,
+        make,
         ...others
       } = NO_OPTIONS,
     ) {
       only(
         others,
-        ['shown', 'chosenRecipient', 'listProof', 'nft', 'listing', 'maxPrice', 'acceptLeftover'],
+        ['shown', 'chosenRecipient', 'listProof', 'nft', 'listing', 'maxPrice', 'acceptLeftover', 'make'],
         'buyTickets',
       );
       const l = part('lotteries', lotteryKey);
@@ -3368,7 +3371,24 @@ export function solanaApp({
             );
         }
       }
-      const buy = [...before, ...withSolWrap(wallet.address, mint, BigInt(terms.price) * BigInt(count), [ix])];
+      // `make`: { recipe, times, listing (or version), assets }: a recipe crafted first in the same transaction, so a
+      // player short of what a ticket costs (an entry a recipe makes) approves once for both. Its outputs land before
+      // the purchase takes them; if either fails, neither happens.
+      const made = make
+        ? (
+            await this.craft(make.recipe, make.assets ?? [], make.times ?? 1, {
+              listing: make.listing,
+              version: make.version,
+              build: true,
+            })
+          ).instructions.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM)
+        : [];
+      const buy = [
+        ...(made.length ? [computeUnitLimit(1_400_000)] : []),
+        ...made,
+        ...before,
+        ...withSolWrap(wallet.address, mint, BigInt(terms.price) * BigInt(count), [ix]),
+      ];
       return send(
         await closesFirst(
           clears,
@@ -3799,8 +3819,13 @@ export function solanaApp({
      * read now is never signed in its place. `extra`: the tail a Core collection's plugins need when the craft moves or
      * rolls on a Core NFT (sent after the Memo program's account, as on every other Core move).
      */
-    async craft(recipeKey, assets = [], times = 1, { version, listing, extra = [], ...others } = NO_OPTIONS) {
-      only(others, ['version', 'listing', 'extra'], 'craft');
+    async craft(
+      recipeKey,
+      assets = [],
+      times = 1,
+      { version, listing, extra = [], build = false, ...others } = NO_OPTIONS,
+    ) {
+      only(others, ['version', 'listing', 'extra', 'build'], 'craft');
       const r = part('recipes', recipeKey);
       version ??= listing?.version ?? undefined;
       if (version === undefined || version === null)
@@ -3933,6 +3958,13 @@ export function solanaApp({
             rollOn ? loot.namedRollNonce(given.boxes[rollOn.box_id], on, nonce) : loot.prizeRollNonce(nonce),
           )
         : null;
+      // `build`: its instructions, unsent, for a step that rides in another's transaction (buyTickets' `make`). A recipe
+      // that rolls is settled after its transaction, so it can't ride along.
+      if (build) {
+        if (rolls)
+          throw new Error(`“${r.name ?? recipeKey}” rolls: it is crafted on its own (craft), not with another step.`);
+        return { instructions, made };
+      }
       const { signature, rolls: rolled } = await sendRolling(instructions);
       return { signature, made, ...(roll ? { roll } : {}), ...(rolled.length ? { rolled: rolled[0] } : {}) };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.28.6",
+  "version": "0.28.7",
   "mcpName": "io.github.XGamesFun/solana-kit",
   "description": "Loot boxes, gacha, shops, lotteries, auctions, NFT staking, crafting and rewards on Solana without writing a smart contract: one shared program, its JS client, a CLI, and an MCP server and skill so Claude Code, Codex or any AI agent can design, check, simulate and launch an economy.",
   "license": "Apache-2.0",

package/skills/xsolana-economy/SKILL.md

@@ -11,9 +11,9 @@ signed by a key file on the owner's own machine, once they have read what will b
 **devnet**, where nothing is real money, and on **mainnet**, where everything is: an economy is on devnet unless its
 file says `"network": "mainnet"`.
 
-The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.6 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
-`npx -y @xgamesfun/solana@0.28.6 token <mint>` for a coin made elsewhere,
-or `npx -y @xgamesfun/solana@0.28.6 tool <name> '<json>'` for any tool (always with the exact version).
+The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.28.7 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+`npx -y @xgamesfun/solana@0.28.7 token <mint>` for a coin made elsewhere,
+or `npx -y @xgamesfun/solana@0.28.7 tool <name> '<json>'` for any tool (always with the exact version).
 
 ## Rules (always)
 
@@ -141,7 +141,7 @@ or `npx -y @xgamesfun/solana@0.28.6 tool <name> '<json>'` for any tool (always w
 9. **When they say "put it live"**: `xsolana_publish` lists every step and its cost and gives the commands, which you
    run in the project folder exactly as given (they name the exact version; never drop it):
    - **A new economy gets a key file**, unless the project has one:
-     `npx -y @xgamesfun/solana@0.28.6 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
+     `npx -y @xgamesfun/solana@0.28.7 keygen ~/.config/xsolana/<name>.json`. Give the person the address it prints. A
      Solana key file they already have and name themselves (`~/.config/solana/id.json`) works the same; never go
      looking for one.
    - **Say what the key file is** before anything is sent: the project's owner, and, unless the spec says otherwise,
@@ -156,7 +156,7 @@ or `npx -y @xgamesfun/solana@0.28.6 tool <name> '<json>'` for any tool (always w
      devnet SOL for an economy on devnet, real SOL for one on mainnet), any seed in a coin that already exists, and every NFT a stash, a raffle or an auction names. A
      collection they already have needs the key's address as its update authority. If they would rather not move
      those, offer the browser wallet.
-   - **Show it**: `npx -y @xgamesfun/solana@0.28.6 approve xsolana.json --keypair <key file>` prints every step with
+   - **Show it**: `npx -y @xgamesfun/solana@0.28.7 approve xsolana.json --keypair <key file>` prints every step with
      what it pays and trusts, the warnings, the notice and a code, and sends nothing. Give the person that printout as
      it is, not a summary of it, and ask.
    - **On their yes**, the same command with `--yes <code>`. What lands is written back into `xsolana.json`. If it

package/skills/xsolana-economy/references/apps.md

@@ -38,6 +38,11 @@ await app.openBox('chest', { listing: boxes.find(l => l.key === 'chest') }); //
 await app.pay('entry'); // a payment of the spec
 const lotteries = await app.lotteries(); // [{ key, name, price, currency, status, round, sold, drawsAt, nftTicket, … }]
 await app.buyTickets('weekly', 2, { listing: lotteries.find(l => l.key === 'weekly') }); // an NFT ticket: { nft: asset, listing }
+// tickets that cost a token a recipe makes: craft what the player lacks in the same transaction, one approval
+await app.buyTickets('weekly', 10, {
+  listing,
+  make: { recipe: 'entry', times: 4, listing: recipes.find(r => r.key === 'entry') },
+});
 await app.payNft(asset, { to, reference }); // pay with an NFT (burned, or given to `to`): admit the player by the receipt
 await app.stake('farm', '10', 0); // tokens, at lock tier 0;  app.stakeNft('farm', asset) for a collectible
 await app.harvest('farm'); // rewards;  app.unstake('farm', '10') once the lock has run

package/types/play/index.d.ts

@@ -352,9 +352,11 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * `chosenRecipient`: the wallet (or collectible) the player names for a share the lottery lets them choose (a
      * referrer). A lottery whose ticket costs an NFT (`nft_ticket`) sells one ticket for one of the player's NFTs that
      * passes its rule: `nft`, its address (held by the project until the draw, then burned, given on or stashed; back to
-     * the player if the round is cancelled). `listProof`: for a list gate.
+     * the player if the round is cancelled). `listProof`: for a list gate. `make`: { recipe, times, listing (or
+     * version), assets }, a recipe crafted first in the same transaction, so a player short of what a ticket costs (an
+     * entry a recipe makes) approves once for both; a recipe that rolls can't ride along.
      */
-    buyTickets(lotteryKey: any, count?: number, { shown, chosenRecipient, listProof, nft: paidWith, listing, maxPrice, acceptLeftover, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    buyTickets(lotteryKey: any, count?: number, { shown, chosenRecipient, listProof, nft: paidWith, listing, maxPrice, acceptLeftover, make, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Writes an NFT's traits from the project's traits tree (`traits` in the spec) into its Sheet, where rules read them:
      * anyone may, paying the Sheet's rent. `attributes` ([{ key, value }]) and `proof` come from the project's tree
@@ -454,7 +456,11 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * read now is never signed in its place. `extra`: the tail a Core collection's plugins need when the craft moves or
      * rolls on a Core NFT (sent after the Memo program's account, as on every other Core move).
      */
-    craft(recipeKey: any, assets?: any[], times?: number, { version, listing, extra, ...others }?: Readonly<Record<string, any>>): Promise<{
+    craft(recipeKey: any, assets?: any[], times?: number, { version, listing, extra, build, ...others }?: Readonly<Record<string, any>>): Promise<{
+        instructions: any[];
+        made: any;
+    } | {
+        instructions?: undefined;
         signature: any;
         made: any;
         roll?: any;