@xgamesfun/solana 0.26.4 → 0.27.1

package/js/play/index.js

@@ -371,23 +371,27 @@ export function solanaApp({
       before: tokenMetadata ? [computeUnitLimit(400_000), ...before] : [],
     };
   }
+  /** Whether a Core asset's account shows the project holds it: held by another, or burned (one byte left), it is gone. */
+  const coreHeld = account => account.data[0] === 1 && parseCoreAsset(account.data).owner === project;
   /**
-   * Whether the project still holds `asset`, as the program reads it (`piece::held`): { held, evidence }. A Core asset by
-   * its owner (one burned is gone); a Token Metadata NFT by the project's token account of it, and when that holds none,
-   * by the account that holds it now or by its mint when it was burned (`evidence`, what a call-off passes to show it
-   * gone); a compressed NFT by the RPC's DAS record of it (proven again by `nftOf`). `held` is null when nothing shows
-   * either way.
+   * Whether the project still holds `asset`, as the program reads it (`piece::held`): { held, evidence, das }. A Core
+   * asset by its owner (one burned is gone); a Token Metadata NFT by the project's token account of it, and when that
+   * holds none, by the account that holds it now or by its mint when it was burned (`evidence`, what shows it gone); a
+   * compressed NFT by the RPC's DAS record of it (`das`, proven again on chain before anything relies on it). `held` is
+   * null when nothing shows either way. `holder`: a wallet thought to hold it now (a player handing it in), whose own
+   * token account is read before any search.
    */
-  async function heldNow(asset) {
+  async function heldNow(asset, { holder = null } = {}) {
     const account = await client.account(asset);
-    if (account?.owner === MPL_CORE)
-      return { held: account.data[0] === 1 && parseCoreAsset(account.data).owner === project };
+    if (account?.owner === MPL_CORE) return { held: coreHeld(account) };
     if (account?.owner === TOKEN_PROGRAM) {
       const u64 = (data, at) => new DataView(data.buffer, data.byteOffset).getBigUint64(at, true);
       const amount = data => (data?.length >= 72 ? u64(data, 64) : 0n);
       if (amount((await client.account(loot.ata(project, asset)))?.data) === 1n) return { held: true };
       // Burned: its mint holds none.
       if (account.data.length >= 44 && u64(account.data, 36) === 0n) return { held: false, evidence: asset };
+      const own = holder ? loot.ata(holder, asset) : null;
+      if (own && amount((await client.account(own))?.data) === 1n) return { held: false, evidence: own };
       const found = await client.programAccounts(TOKEN_PROGRAM, [
         { dataSize: 165 },
         { memcmp: { offset: 0, bytes: asset } },
@@ -398,8 +402,70 @@ export function solanaApp({
     if (account) return { held: null };
     const das = await client.call('getAsset', { id: asset }).catch(() => null);
     if (!das?.compression?.compressed) return { held: null };
-    return { held: !das.compression.burnt && das.ownership?.owner === project };
+    // DAS says a burned NFT at the asset's top level (`burnt`).
+    const burnt = das.burnt === true || das.compression.burnt === true;
+    return { held: !burnt && das.ownership?.owner === project, das };
   }
+  /** `heldNow` of several NFTs: the Core assets from one read of them all, any other kind one by one. By asset. */
+  async function heldEach(assets) {
+    const unique = [...new Set(assets)];
+    const found = unique.length ? await client.accounts(unique) : [];
+    const out = new Map();
+    for (const [i, asset] of unique.entries())
+      out.set(asset, found[i]?.owner === MPL_CORE ? { held: coreHeld(found[i]) } : await heldNow(asset));
+    return out;
+  }
+  /**
+   * What proves `asset` gone from the project, as the instruction that lets go of it takes it (loot 0.27: a record
+   * whose NFT is proven gone closes): { before, kind }, or null when the project still holds it or nothing shows either
+   * way. Whoever controls a collection the project does not can take an NFT out of the project's hands or burn it. A
+   * Core asset shows it by itself (`kind`: its collection now); a Token Metadata NFT by the token account that holds it
+   * now, or its mint once burned (`kind.tokenMetadata.evidence`); a compressed NFT by its record, proven again as its
+   * leaf is now (`before`, by `signer`). `holder`: as `heldNow` takes it. `now`: what `heldNow` read of it already.
+   */
+  async function goneProof(asset, signer = wallet.address, { holder = null, now = null } = {}) {
+    now ??= await heldNow(asset, { holder });
+    if (now.held !== false) return null;
+    if (now.das) {
+      const proof = await client.call('getAssetProof', { id: asset });
+      const tree = await client.account(now.das.compression.tree);
+      const compressed = loot.compressedFromDas({ asset: now.das, proof, treeData: tree.data });
+      return { before: [computeUnitLimit(1_000_000), loot.proveLeafIx({ signer, compressed })], kind: { compressed } };
+    }
+    if (now.evidence)
+      return { before: [], kind: { tokenMetadata: { programmable: false, ruleSet: null, evidence: now.evidence } } };
+    return { before: [], kind: { collection: (await collectionOf(asset)) ?? MPL_CORE } };
+  }
+  /**
+   * An NFT a record of the project's is to send on (`nftOf`, to `to`), or, when it is proven gone from the project
+   * (`goneProof`), what shows that, with `gone` true: the instruction then finishes without it and nothing is sent.
+   * `now`: what `heldNow` read of it already.
+   */
+  async function leaving(asset, signer = wallet.address, { to, payer = signer, now = null } = {}) {
+    const proof = await goneProof(asset, signer, { now });
+    if (!proof) return { ...(await nftOf(asset, signer, { to, payer })), gone: false };
+    // A Core asset shows it by itself, with the accounts it always took.
+    if (!proof.kind.tokenMetadata && !proof.kind.compressed) return { ...(await nftOf(asset, signer)), gone: true };
+    return { before: proof.before, hasAuthority: false, ...proof.kind, gone: true };
+  }
+  /**
+   * The release of a hold a route just made of `asset`, an NFT it owed and could only hand out (`kind`: from
+   * `leaving`). The program makes such a hold at `["hold", asset, 0]` for `player`, the route's `signer` paying its
+   * rent and `rentTo` named for its NFT's account's (`hold::owe`). The release right after it, by the same signer,
+   * ends it: for an NFT proven gone from the project it closes the hold on the proof and nothing is sent (`NftGone`);
+   * for any other it sends the NFT on to `player` (`Released`). Either way the hold's rent comes back to the signer.
+   * `g`: the project, for a hold owed to the treasury.
+   */
+  const releaseOwed = (asset, kind, { player, rentTo }, signer, g) =>
+    loot.releaseIx({
+      signer,
+      project,
+      asset,
+      ...kind,
+      hold: { player, payer: signer, rent_to: rentTo, free_at: 0n },
+      address: loot.pda.hold(asset, 0),
+      treasury: g.treasury,
+    });
   /**
    * A token's own settings that let whoever is to be paid turn a payment away, for a page to say before a player puts
    * money in: accounts that start frozen or can be switched to it (a payee closes their own account, and the one
@@ -1066,7 +1132,10 @@ export function solanaApp({
   /**
    * Waits for an order's roll (the oracle answers a moment after the open), then settles it. With `burner` (the
    * throwaway key the open funded), the burner signs and pays the settle, and gives the rest back: no wallet prompt.
-   * The order names it (`settler`), so it may settle; when the player or the project did first, the burner only gives its lamports back. `putBack`: NFTs
+   * The order names it (`settler`), so it may settle; when the player or the project did first, the burner only gives its lamports back.
+   * An NFT of the order the project no longer holds (its collection took it back or burned it) is passed over: a
+   * stash's NFT won is not given (its place in `assets` is null) and the NFT rolled on is not sent back; `gone` lists
+   * them, with `says`. `putBack`: NFTs
    * won that the player puts back into their stash in place of taking them (one whose collection now refuses to let it
    * move); `giveUp`: the places in the order's `won` of tokens or collectibles the player gives up because they can't
    * receive them (an account the token's issuer froze, a collection that refuses the mint): tokens given up stay in the
@@ -1191,6 +1260,9 @@ export function solanaApp({
       };
     };
     const holders = await holdersOf(order.shares);
+    // NFTs of this order the project no longer holds (their collection took them back or burned them): the settle
+    // passes each over on that proof. A stash's NFT won is then not given; the NFT rolled on is not sent back.
+    const lost = new Set();
     // Given by its fate to a wallet that is an account of the loot program, the NFT goes back to the player.
     const gives = order.held ? order.fate?.then?.Give?.[0] : undefined;
     const handBack = gives !== undefined && loot.handsBack(await client.account(gives));
@@ -1207,15 +1279,25 @@ export function solanaApp({
           const {
             before,
             hasAuthority: _,
+            gone,
             ...kind
-          } = await nftOf(won.Nft.nft, signer, { to: order.player, payer: wallet.address });
+          } = await leaving(won.Nft.nft, signer, { to: order.player, payer: wallet.address });
+          if (gone) lost.add(won.Nft.nft);
           nfts[won.Nft.nft] = kind;
           proving.push(...before);
         }
       }
-      // The NFT the roll was on: its kind, and for a compressed one a proof first.
-      const { before: subjectProof, ...subject } =
-        order.subject && order.subject !== NOBODY ? await nftOf(order.subject, signer) : { before: [] };
+      // The NFT the roll was on: its kind, and for a compressed one a proof first. One the order holds may be gone.
+      const {
+        before: subjectProof,
+        gone: subjectGone,
+        ...subject
+      } = order.subject && order.subject !== NOBODY
+        ? order.held
+          ? await leaving(order.subject, signer)
+          : await nftOf(order.subject, signer)
+        : { before: [] };
+      if (subjectGone) lost.add(order.subject);
       const ix = loot.settleIx({
         signer,
         orderAddress,
@@ -1296,7 +1378,7 @@ export function solanaApp({
     if (burner && !keepBurner && !emptied) await emptyKey(burner);
     else if (burner && emptied) keys?.forget(burner.name);
     const given = new Set(giveUp.map(Number));
-    const assets = wonAssets(order).map((a, k) => (putBack.includes(a) || given.has(k) ? null : a));
+    const assets = wonAssets(order).map((a, k) => (putBack.includes(a) || given.has(k) || lost.has(a) ? null : a));
     return {
       order: orderAddress,
       won: order.won,
@@ -1304,6 +1386,13 @@ export function solanaApp({
       settled: signature,
       ...(signatures.length ? { parts: [...signatures, signature] } : {}),
       ...(assets.find(Boolean) ? { asset: assets.find(Boolean) } : {}),
+      // What the settle passed over: not given (a stash's NFT won), not sent back (the NFT rolled on).
+      ...(lost.size
+        ? {
+            gone: [...lost],
+            says: 'The project no longer holds an NFT of this order (whoever controls its collection took it back or burned it): it was not given or sent back. Everything else settled as rolled.',
+          }
+        : {}),
     };
   }
 
@@ -1595,7 +1684,8 @@ export function solanaApp({
     // A box that rolls on an NFT takes the one the player brings (`on`), whatever its kind.
     if (box.subject && !on) throw new Error('This box rolls on an NFT: say which (on).');
     // A box that burns it, gives it away or moves its numbers takes it into the project's hands until the roll settles.
-    if (box.subject && loot.boxHolds(box)) await noLeftovers(on, acceptLeftover);
+    // What an earlier owner of it left in the project is cleared first (`clearLeftovers`).
+    const clears = box.subject && loot.boxHolds(box) ? await clearLeftovers(on, acceptLeftover) : [];
     const brought = box.subject ? await nftOf(on) : { before: [] };
     const { before: proving, hasAuthority, ...kind } = brought;
     const subject = box.subject
@@ -1713,7 +1803,7 @@ export function solanaApp({
             x.keys[0]?.pubkey === associatedTokenAddress(wallet.address, NATIVE_MINT)
           ),
       );
-    const signature = await send(instructions, [], { keepWrapped: solPrize });
+    const signature = await send(await closesFirst(clears, instructions), [], { keepWrapped: solPrize });
     // The slot it landed in: the order is read from a node that has seen it (a load-balanced RPC's node lagging
     // behind answers nothing for an order just opened).
     const landed = (await client.signatureStatus?.(signature).catch(() => null))?.slot ?? null;
@@ -1751,6 +1841,17 @@ export function solanaApp({
       );
   }
 
+  /**
+   * Refuses, in words, to buy or rent the listing of an NFT the project no longer holds (whoever controls its
+   * collection took it back or burned it): nothing is there. Sent all the same, the take would only close the listing.
+   */
+  async function listedStill(asset) {
+    if ((await heldNow(asset)).held === false)
+      throw new Error(
+        `The project no longer holds the NFT ${asset}: whoever controls its collection took it back or burned it while it was listed. There is nothing to buy or rent, and nothing was sent. Anyone can close this listing for nothing (closeGone): its rent goes back to its maker.`,
+      );
+  }
+
   /** A box bought at once when it needs no roll (`buyBox`: a shop item, a bundle, a fixed pack of any count), or
    * opened and collected: one that rolls, gives a fresh item (its traits are rolled), or rolls on an NFT. A fixed pack
    * too big for one transaction is opened instead (the oracle answers it like any box). */
@@ -1876,16 +1977,18 @@ export function solanaApp({
     const lotNow = lot ? await heldNow(lot) : { held: null };
     const bidNow = [];
     if (sold && auction.nft_bids) for (const nft of auction.held) bidNow.push(await heldNow(nft));
-    const gone = lotNow.held === false || bidNow.some(n => n.held === false);
+    const lostBids = sold && auction.nft_bids ? auction.held.filter((_, i) => bidNow[i].held === false) : [];
+    const gone = lotNow.held === false || lostBids.length > 0;
     const ending = sold && lot && (callOff || gone) ? 'CallOff' : 'Deliver';
     const home = !sold || ending === 'CallOff';
     // The lot to its winner, or home to its seller; a bid's NFTs to whoever owned the lot, or back to their bidder.
+    // One that is gone is not sent: its accounts only show the end that the project no longer holds it.
     const before = [];
-    const lotKind = lot ? await kindFor(lot, home ? auction.seller : auction.high_bidder, lotNow.evidence, before) : {};
+    const lotKind = lot ? await kindFor(lot, home ? auction.seller : auction.high_bidder, lotNow, before) : {};
     const bidTo = ending === 'CallOff' ? auction.high_bidder : owner;
     const held = [];
     if (sold && auction.nft_bids)
-      for (const [i, nft] of auction.held.entries()) held.push(await kindFor(nft, bidTo, bidNow[i].evidence, before));
+      for (const [i, nft] of auction.held.entries()) held.push(await kindFor(nft, bidTo, bidNow[i], before));
     if (sold && !home) holders ??= await holdersOf(auction.shares);
     const end = (ending, hold = false) =>
       loot.endAuctionIx({ ...base, auction, item, ...lotKind, held, holders, ending, hold });
@@ -1900,6 +2003,24 @@ export function solanaApp({
       ...(made ? { asset: made } : {}),
     };
     if (ending === 'CallOff') Object.assign(result, { calledOff: true, gone });
+    // What the end did about an NFT that is gone, in words: nothing here says it moved.
+    if (gone) {
+      const which =
+        lotNow.held === false
+          ? `the lot (${lot})`
+          : `${lostBids.length === 1 ? 'an NFT' : 'NFTs'} of the winning bid (${lostBids.join(', ')})`;
+      const did = !sold
+        ? 'Nothing went home: the auction is closed, and its rent went back to its seller.'
+        : ending === 'Deliver'
+          ? 'Nothing was paid for it: the lot went to its winner, and the rest of the bid was paid.'
+          : lotNow.held === false
+            ? `The sale was called off: ${auction.nft_bids ? 'the NFTs of the winning bid the project still held' : 'the winning bid'} went back to its bidder, and nothing went home to the seller.`
+            : 'The sale was called off: the lot went home to its seller, and the rest of the bid went back to its bidder.';
+      Object.assign(result, {
+        gone: true,
+        says: `The project no longer holds ${which}: whoever controls its collection took it back or burned it while the auction held it. ${did}`,
+      });
+    }
 
     // An end that may make holds: a lot going home, a bid's NFTs going back or to the treasury for the project's lot.
     const outs = [
@@ -1967,15 +2088,15 @@ export function solanaApp({
     return holding();
   }
 
-  /** An NFT's kind on an auction's end, going to `to`: what `nftOf` reads, its proof put in `before`; `evidence` for a Token
-   * Metadata NFT that left the project (the account that holds it now, or its mint). */
-  async function kindFor(asset, to, evidence, before) {
-    const { before: proof, hasAuthority: _, ...kind } = await nftOf(asset, wallet.address, { to });
+  /** An NFT's kind on an auction's end, going to `to`: what `nftOf` reads, its proof put in `before`. `now`: what
+   * `heldNow` read of it; one that is gone carries what shows it instead (a Token Metadata NFT's account that holds it
+   * now, or its mint; a compressed NFT's leaf as it is now), and is sent nowhere. */
+  async function kindFor(asset, to, now, before) {
+    const { before: proof, hasAuthority: _h, gone: _g, ...kind } = await leaving(asset, wallet.address, { to, now });
     before.push(...proof);
     return {
       ...kind,
       collection: kind.compressed || kind.tokenMetadata ? undefined : ((await collectionOf(asset)) ?? MPL_CORE),
-      ...(evidence && kind.tokenMetadata ? { evidence } : {}),
     };
   }
 
@@ -2024,16 +2145,30 @@ export function solanaApp({
     if (opens.length) await send([...new Map(opens.map(x => [x.keys[1].pubkey, x])).values()]);
     const before = [];
     const held = [];
-    if (auction.nft_bids) for (const nft of auction.held) held.push(await kindFor(nft, auction.seller, null, before));
+    // An NFT of the bid that is gone (its collection took it back or burned it) is not paid: its accounts show the
+    // end that the project no longer holds it, and the end passes it over.
+    const lost = [];
+    if (auction.nft_bids)
+      for (const nft of auction.held) {
+        const now = await heldNow(nft);
+        if (now.held === false) lost.push(nft);
+        held.push(await kindFor(nft, auction.seller, now, before));
+      }
     const end = (hold = false) => loot.endAuctionIx({ ...base, auction, held, holders, hold });
     const steps = ix => [
       computeUnitLimit(1_000_000),
       ...before.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM),
       ix,
     ];
+    const passed = lost.length
+      ? {
+          gone: true,
+          says: `The project no longer holds ${lost.length === 1 ? 'an NFT' : 'NFTs'} of the winning bid (${lost.join(', ')}): whoever controls its collection took it back or burned it while the auction held it. Nothing was paid for it: the rest of the bid was paid to the seller.`,
+        }
+      : {};
     if (sendPlan({ payer: wallet.address, instructions: steps(end()), alone: isProveLeaf }))
       try {
-        return { paid: await send(steps(end())) };
+        return { paid: await send(steps(end())), ...passed };
       } catch (e) {
         // The lot is the winner's already: what is owed waits until the account it goes into can take it.
         return {
@@ -2041,9 +2176,9 @@ export function solanaApp({
           says: `The lot is the winner’s; the money waits (${e.message}): end the auction again to pay it.`,
         };
       }
-    const outs = auction.held.map(x => [x, auction.seller]);
-    const { signature, releases } = await heldThenReleased(at, steps(end(true)), outs);
-    return { paid: signature, releases };
+    const outs = auction.held.filter(x => !lost.includes(x)).map(x => [x, auction.seller]);
+    const { signature, releases } = await heldThenReleased(at, steps(end(outs.map(([x]) => x))), outs);
+    return { paid: signature, releases, ...passed };
   }
 
   /**
@@ -2059,9 +2194,12 @@ export function solanaApp({
     const signature = await send([...instructions, fund]);
     const releases = [];
     for (const [asset, to] of outs) {
+      // Taken back or burned since the end made it a hold: its release closes the hold on that proof, and sends nothing.
+      let lost = false;
       const release = async signer => {
         const hold = await read('Hold', loot.pda.hold(asset, 0));
-        const { before: proof, hasAuthority: _h, ...kind } = await nftOf(asset, signer, { to });
+        const { before: proof, hasAuthority: _h, gone, ...kind } = await leaving(asset, signer, { to });
+        lost = gone;
         return [
           ...proof,
           loot.releaseIx({
@@ -2078,58 +2216,143 @@ export function solanaApp({
       const steps = await release(key.address);
       const byKey = (await dryRun(key.address, steps)).ok ? await sendAs(key, steps).catch(() => null) : null;
       // One that still can't move (frozen for now) stays a hold: claims() lists it for whoever it is owed to.
-      releases.push(byKey ?? (await send(await release(wallet.address)).catch(e => ({ asset, waits: e.message }))));
+      const sent = byKey ?? (await send(await release(wallet.address)).catch(e => ({ asset, waits: e.message })));
+      releases.push(lost && typeof sent === 'string' ? { asset, gone: true, closed: sent } : sent);
     }
     await emptyKey(key);
     return { signature, releases };
   }
 
+  /** What closing a hold whose NFT is gone does, in words, for `claims()`. */
+  const goneHoldSays = hold =>
+    `The project no longer holds this NFT: whoever controls its collection took it back or burned it while it was held. Its hold can be closed now, by anyone: closing it sends nothing, and the hold's rent goes back to whoever paid it (${hold.payer}).${hold.debt ? ' It was a loan: nothing is repaid, the borrower keeps what they borrowed, and the lender gets neither the NFT nor the repayment.' : ''}`;
+  /** The same for a listing. */
+  const GONE_LISTING =
+    'The project no longer holds this NFT: whoever controls its collection took it back or burned it while it was listed. There is nothing to buy or rent. The listing can be closed for nothing, by its maker (unlist) or by anyone (closeGone), once no rental runs: its rent goes back to its maker.';
+
   /**
-   * A hold's claim, or, when the project no longer holds its NFT (whoever controls its collection took it back or
-   * burned it while it was held), the same claim flagged `gone`: the hold's record still says the NFT is held, and it
-   * is not, so nothing can be sent.
+   * What ending an auction does when its lot or an NFT of its winning bid is gone, in words, for `claims()`: `x` the
+   * auction, `me` the wallet told (its seller, or its high bidder), `lot` the lot when it is gone, `bids` the NFTs of
+   * the winning bid that are gone.
    */
-  async function goneOr(asset, claim) {
-    if ((await heldNow(asset)).held !== false) return claim;
-    return {
-      ...claim,
-      gone: true,
-      says: 'The project no longer holds this NFT: whoever controls its collection took it back or burned it while it was held. Its hold says otherwise, but nothing can be sent, and nothing was paid against it.',
-    };
+  function goneSaleSays(name, x, me, lot, bids) {
+    const [sold, owed] = [BigInt(x.high) > 0n, BigInt(x.proceeds_owed) > 0n];
+    const mine = sold && x.high_bidder === me;
+    const why = 'whoever controls its collection took it back or burned it while the auction held it';
+    const lostBids = `${bids.length === 1 ? 'an NFT' : 'NFTs'} of ${mine ? 'your' : 'the winning'} bid (${bids.join(', ')})`;
+    if (lot && !sold)
+      return `The project no longer holds its lot (${lot}): ${why}. “${name}” ended with no bid, and nothing comes back to you: ending it closes the auction, and its rent comes back to you.`;
+    if (lot) {
+      const back = x.nft_bids
+        ? `the NFTs of ${mine ? 'your' : 'the winning'} bid that the project still holds go back to ${mine ? 'you' : 'their bidder'}`
+        : mine
+          ? 'your bid comes back to you'
+          : 'the winning bid goes back to its bidder';
+      return `The project no longer holds its lot (${lot}): ${why}. The sale of “${name}” is called off by its end, which anyone may send: ${back}, and ${mine ? 'the lot is not yours' : 'you are paid nothing'}.${bids.length ? ` It no longer holds ${lostBids} either: nothing comes back for it.` : ''}`;
+    }
+    const first = `The project no longer holds ${lostBids}: ${why}.`;
+    // A player's lot that has not moved: the two sides move together or not at all, so the sale is called off.
+    if (x.lot.Asset && !owed)
+      return `${first} The sale of “${name}” is called off by its end, which anyone may send: the lot goes home to ${mine ? 'its seller' : 'you'}, and the rest of the bid back to ${mine ? 'you' : 'its bidder'}. Nothing comes back for the one gone.`;
+    // The lot went first, or it is the project's own: the end passes that NFT over and pays the rest.
+    return owed
+      ? `${first} The winner of “${name}” has the lot: ending it again pays you the rest of the bid, and nothing for the one gone.`
+      : `${first} Ending “${name}” gives the lot to ${mine ? 'you' : 'its winner'} and pays the rest of the bid: nothing is paid for the one gone.`;
   }
+  /** What claiming does about the NFTs of a round's parts that are gone, in words, for `claims()`: `tickets` the NFTs
+   * that paid for the wallet's tickets, `prizes` the NFTs its places won; `back` when its tickets go back to their
+   * buyers (a round called off, a lottery that returns its tickets). */
+  const goneRoundSays = (tickets, prizes, back) =>
+    [
+      tickets.length
+        ? `The project no longer holds the NFT that paid for your ticket (${tickets.join(', ')}): whoever controls its collection took it back or burned it while the lottery held it. ${back ? 'It can’t come back to you' : 'It goes nowhere'}: claiming settles that part and sends nothing.`
+        : '',
+      prizes.length
+        ? `The project no longer holds an NFT you won (${prizes.join(', ')}): whoever controls its collection took it back or burned it. It can’t be given: claiming closes that prize and sends nothing.`
+        : '',
+    ]
+      .filter(Boolean)
+      .join(' ');
 
   /**
-   * The records of this project an earlier owner of `asset` left behind: its listing at
-   * `["listing", project, asset]` (one read) and its holds (one search, by the asset's address), each that names a wallet
-   * other than the player's. Each is { kind, address, says }. Such a record stays when whoever controls the NFT's
-   * collection moved it out of the project's hands without the program, and the program hands out whatever the project
-   * holds at that address: once this player's deposit puts the NFT back in the project's hands, the record can send it
-   * to the wallet it names. NFTs of the project's own collections are not read: those collections refuse the permanent
-   * delegates that take an NFT out.
+   * This project's records of `asset`: its listing at `["listing", project, asset]` (one read) and its holds (one
+   * search, by the asset's address). Each is { kind: 'listing' | 'hold', address, record }.
    */
-  async function leftovers(asset) {
-    if (ours(await collectionOf(asset))) return [];
-    const me = wallet.address;
+  async function recordsOf(asset) {
     const out = [];
     const listingAt = loot.pda.listing(project, asset);
     const listing = await readMaybe('Listing', listingAt);
-    if (listing && listing.maker !== me) {
-      const sale = Boolean(listing.deal.Sell);
-      out.push({
-        kind: 'listing',
-        address: listingAt,
-        says: `A listing of this NFT (${listingAt}) is still open in this project, left by an earlier owner, ${listing.maker}. Once the project holds the NFT again, ${listing.maker} can take it home by closing that listing${sale ? `, and anyone can buy it at the listing's price, which is paid to ${listing.maker}` : ''}.`,
-      });
-    }
+    if (listing) out.push({ kind: 'listing', address: listingAt, record: listing });
     const tag = { memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Hold)) } };
     const holds = await client.programAccounts(loot.LOOT_PROGRAM, [
       tag,
       { memcmp: { offset: 1, bytes: project } },
       { memcmp: { offset: 33, bytes: asset } },
     ]);
+    for (const { pubkey, account } of holds)
+      out.push({ kind: 'hold', address: pubkey, record: loot.decode('Hold', account.data) });
+    return out;
+  }
+
+  /**
+   * The stashes of this project that list `asset`: a project's stash (`kind` 'stash') or a lottery's own
+   * ('lottery-stash'), each { kind, address, id } (`id`: the stash's, or the lottery's). A stash keeps its NFTs in
+   * rows of no fixed place, so no filter finds one NFT's row: this is one search of the project's stashes
+   * (`getProgramAccounts` by tag, project and payload), which returns every stash of the project whole, 36 bytes for
+   * each NFT a stash lists, and reads them here.
+   */
+  async function stashesOf(asset) {
+    const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
+    const found = await client.programAccounts(loot.LOOT_PROGRAM, [
+      at(0, encodeBase58(Uint8Array.of(loot.TAGS.Table))),
+      at(1, project),
+      at(37, encodeBase58(Uint8Array.of(loot.PAYLOAD.Nft))),
+    ]);
+    const out = [];
+    for (const { pubkey, account } of found) {
+      const stash = loot.decodeStash(account.data);
+      if (!stash?.nfts.includes(asset)) continue;
+      const own = pubkey === loot.pda.stash(project, stash.id);
+      out.push({ kind: own ? 'stash' : 'lottery-stash', address: pubkey, id: stash.id });
+    }
+    return out;
+  }
+
+  /**
+   * The records of this project an earlier owner of `asset` left behind (`recordsOf`), each that names a wallet other
+   * than the player's: { kind, address, record, says }. Such a record is left when whoever controls the NFT's
+   * collection moved it out of the project's hands without the program. Until it is closed, the program hands out
+   * whatever the project holds at that address: once this player's deposit puts the NFT back in the project's hands, the
+   * record can send it to the wallet it names. `own`: the player's own listing of it counts too (a route that lists:
+   * the program takes no second listing of an NFT while one is open). NFTs of the project's own collections are not
+   * read: those collections refuse the permanent delegates that take an NFT out.
+   */
+  async function leftovers(asset, { own = false } = {}) {
+    if (ours(await collectionOf(asset))) return [];
+    const me = wallet.address;
+    const out = [];
     const time = BigInt(await chainNow());
-    for (const { pubkey, account } of holds) {
-      const hold = loot.decode('Hold', account.data);
+    const iso = at => new Date(Number(at) * 1000).toISOString();
+    for (const r of await recordsOf(asset)) {
+      if (r.kind === 'listing') {
+        const listing = r.record;
+        const mine = listing.maker === me;
+        if (mine && !own) continue;
+        const sale = Boolean(listing.deal.Sell);
+        // A running rental is kept: nobody but its maker can even stop the listing until it has run.
+        const rented =
+          time < BigInt(listing.until)
+            ? ` It is rented until ${iso(listing.until)}: the program keeps a running rental, so nobody can close this listing before then (anyone can after, for nothing).`
+            : '';
+        out.push({
+          ...r,
+          says: mine
+            ? `Your own earlier listing of this NFT (${r.address}) is still open in this project.${rented}`
+            : `A listing of this NFT (${r.address}) is still open in this project, left by an earlier owner, ${listing.maker}. Once the project holds the NFT again, ${listing.maker} can take it home by closing that listing${sale ? `, and anyone can buy it at the listing's price, which is paid to ${listing.maker}` : ''}.${rented}`,
+        });
+        continue;
+      }
+      const hold = r.record;
       const to = hold.player === project ? 'the project’s treasury' : hold.player;
       const names = [hold.player, hold.debt?.lender].filter(Boolean);
       if (names.every(x => x === me)) continue;
@@ -2140,31 +2363,137 @@ export function solanaApp({
           : `a loan's hold: anyone who repays it (${hold.debt.repay} to ${hold.debt.lender}) sends the NFT to ${to}, and once it is due anyone sends it to the lender`
         : due
           ? `a hold that is over: anyone can send the NFT to ${to} at once`
-          : `a hold that runs until ${new Date(Number(hold.free_at) * 1000).toISOString()}: the project's authority decides where the NFT goes until then, and anyone sends it to ${to} after`;
+          : `a hold that runs until ${iso(hold.free_at)}: the project's authority decides where the NFT goes until then, and anyone sends it to ${to} after`;
       out.push({
-        kind: 'hold',
-        address: pubkey,
-        says: `This project still has ${what} (${pubkey}), left from an earlier owner of this NFT. Once the project holds the NFT again, it can be sent there.`,
+        ...r,
+        says: `This project still has ${what} (${r.address}), left from an earlier owner of this NFT. Once the project holds the NFT again, it can be sent there.`,
       });
     }
     return out;
   }
 
   /**
-   * Refuses, in words, to hand `asset` to the project while a record an earlier owner left can take it (`leftovers`),
-   * unless the caller says the player accepts that (`accept` true). `listing`: the route is a listing, which the program
-   * refuses outright while a listing of the NFT is open (its address is taken), whatever the option says.
+   * The instructions that close `records` of `asset` (`recordsOf`) on the proof that the project no longer holds it
+   * (`proof`, from `goneProof`), as `signer` sends them: a hold by `release`, a listing by `take_listing`. Anyone may
+   * send either, at any time; nothing is sent or paid, and no project fee is taken. A listing whose rental still runs
+   * can't be closed (`Rented`): the program keeps a running rental, and the listing closes once it has run.
+   * Returns { closes, closed: [{ kind, address }], waits: the records left }.
+   */
+  async function closesOf(asset, records, proof, signer = wallet.address) {
+    const g = await projectNow();
+    const time = BigInt(await chainNow());
+    const closes = [];
+    const closed = [];
+    const waits = [];
+    for (const r of records) {
+      if (r.kind === 'listing') {
+        if (time < BigInt(r.record.until)) {
+          waits.push(r);
+          continue;
+        }
+        closes.push(
+          loot.takeListingIx({
+            taker: signer,
+            project,
+            projectState: g,
+            listing: r.record,
+            holders: await holdersOf(r.record.shares ?? []),
+            programs,
+            ...proof.kind,
+          }),
+        );
+      } else {
+        const hold = r.record;
+        closes.push(
+          loot.releaseIx({
+            signer,
+            project,
+            asset,
+            ...proof.kind,
+            hold,
+            address: r.address,
+            treasury: g.treasury,
+            ...(hold.debt ? { to: hold.debt.lender } : {}),
+          }),
+        );
+      }
+      closed.push({ kind: r.kind, address: r.address });
+    }
+    return { closes: closes.length ? [...proof.before, ...closes] : [], closed, waits };
+  }
+
+  /**
+   * The deposit guard. Before the player hands `asset` to the project, what an earlier owner left of it there
+   * (`leftovers`) is cleared: the player holds the NFT, so it is provably gone from the project, and each leftover hold
+   * closes by `release` on that proof and a leftover listing by `take_listing` on it (anyone may, at any time, and
+   * nothing is paid). Returns those instructions, tried in a dry run, to go in front of the deposit (`closesFirst`);
+   * none when nothing was left. The closes cost the player their transaction fee only: each record's rent goes to
+   * whoever that record names (a hold's payer, a listing's maker), never to the player.
+   * What can't be closed still refuses the deposit, in words, with nothing sent: a listing whose rental still runs
+   * (the program keeps it until the rental has run), or a record of an NFT nothing shows gone. `accept` true goes
+   * ahead all the same (the closes that can be made still go first). `listing`: the route is a listing, which the
+   * program refuses outright while a listing of the NFT is open (its address is taken), whatever the option says.
    */
-  async function noLeftovers(asset, accept, { listing = false } = {}) {
-    const found = await leftovers(asset);
-    if (listing && found.some(x => x.kind === 'listing'))
+  async function clearLeftovers(asset, accept, { listing = false } = {}) {
+    const found = await leftovers(asset, { own: listing });
+    if (!found.length) return [];
+    const proof = await goneProof(asset, wallet.address, { holder: wallet.address });
+    let { closes, waits } = proof ? await closesOf(asset, found, proof) : { closes: [], waits: found };
+    let why = '';
+    if (closes.length) {
+      const trial = [computeUnitLimit(1_400_000), ...closes.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM)];
+      // Tried in a dry run when they are one transaction as they stand; a longer list is made to fit as it is sent.
+      const one = compileFitting({
+        payer: wallet.address,
+        blockhash: NOBODY,
+        instructions: trial,
+        tables: await standing(),
+      });
+      const tried = one ? await dryRun(wallet.address, trial) : { ok: true };
+      if (!tried.ok) {
+        why = tried.error ? ` Closing it was refused in a dry run: ${tried.error.msg} (${tried.error.name}).` : '';
+        [closes, waits] = [[], found];
+      }
+    }
+    const open = waits.find(x => x.kind === 'listing');
+    if (listing && open)
       throw new Error(
-        `${found.find(x => x.kind === 'listing').says} The program refuses another listing of this NFT while that one is open (its address is taken): nothing was sent.`,
+        `${open.says}${why} The program refuses another listing of this NFT while that one is open (its address is taken): nothing was sent.`,
       );
-    if (!found.length || accept === true) return;
-    throw new Error(
-      `${found.map(x => x.says).join(' ')} This deposit would put the NFT where that record can take it: it would be lost to you. Nothing was sent. Go ahead only if the player accepts this: pass acceptLeftover: true.`,
-    );
+    if (waits.length && accept !== true)
+      throw new Error(
+        `${waits.map(x => x.says).join(' ')}${why} This deposit would put the NFT where that record can take it: it would be lost to you. Nothing was sent. Go ahead only if the player accepts this: pass acceptLeftover: true.`,
+      );
+    return closes;
+  }
+
+  /**
+   * A deposit's `instructions` with `closes` (`clearLeftovers`) in front of them: in the same transaction when both
+   * fit one as the wallet sends it (a legacy one, or one with the project's standing tables); when they do not, the
+   * closes are sent first in a transaction of their own, and the deposit's instructions come back alone.
+   */
+  async function closesFirst(closes, instructions) {
+    if (!closes.length) return instructions;
+    const isLimit = ix => ix.programId === COMPUTE_BUDGET_PROGRAM && ix.data[0] === 2;
+    // One proof of a compressed NFT serves both: the closes read its record first, then the deposit moves it.
+    const proven = new Set(closes.filter(isProveLeaf).map(ix => ix.keys[1].pubkey));
+    const together = [
+      computeUnitLimit(1_400_000),
+      ...closes.filter(ix => !isLimit(ix)),
+      ...instructions.filter(ix => !isLimit(ix) && !(isProveLeaf(ix) && proven.has(ix.keys[1].pubkey))),
+    ];
+    const fits =
+      Boolean(
+        compileFitting({
+          payer: wallet.address,
+          blockhash: NOBODY,
+          instructions: loot.withLeafCloses(together),
+          tables: await standing(),
+        }),
+      ) && transactionLocks(wallet.address, together) <= 64;
+    if (fits) return together;
+    await send(closes);
+    return instructions;
   }
 
   /** Who holds each collectible a split's holder shares name now: { asset: holder }. */
@@ -2266,6 +2595,77 @@ export function solanaApp({
     ];
   }
 
+  /** How many of the losers' NFTs left a winner's claim reads to choose its picks among. */
+  const PICKS_READ = 8;
+  /**
+   * The NFTs a claim of entry `i` of a contest of NFTs moves, as `claim` sends it: the entry's own while the contest
+   * holds it, and for a winner the losers' NFTs its share still lets it pick, at most 4 a claim. `take` names the
+   * picks (one asset, or several). With none named, the first of the losers' NFTs left that the project still holds
+   * are picked (the first `PICKS_READ` are read), and one that is gone only when no other is left there: a pick of an
+   * NFT gone takes nothing. Each is { j, nft, gone }: its entry's place in the list, and whether the project no longer
+   * holds it (its collection took it back or burned it).
+   */
+  async function contestNfts(contest, entries, i, take) {
+    const own = entries[i];
+    const won = contest.verdict === 'Won' && Number(contest.winner) === Number(own.side);
+    const out = Number(own.amount) === 1 ? [{ j: i, nft: own.nft }] : [];
+    const share = won && !(own.bits & loot.ENDED) ? loot.shareOf(contest, own) - Number(own.taken) : 0;
+    const left = entries
+      .map((e, j) => ({ j, nft: e.nft, e }))
+      .filter(({ e }) => Number(e.side) !== Number(contest.winner) && Number(e.amount) === 1);
+    const wanted = take ? [take].flat() : [];
+    const among =
+      share <= 0 ? [] : wanted.length ? left.filter(x => wanted.includes(x.nft)) : left.slice(0, PICKS_READ);
+    if (wanted.length && among.length < Math.min(wanted.length, share))
+      throw new Error(`${wanted.join(', ')} is not a loser’s NFT left in this contest for you to pick.`);
+    const heldOf = await heldEach([...out, ...among].map(x => x.nft));
+    const isGone = x => heldOf.get(x.nft)?.held === false;
+    const picks = wanted.length ? among : [...among.filter(x => !isGone(x)), ...among.filter(isGone)];
+    out.push(...picks.slice(0, Math.min(share, 4)));
+    return out.map(x => ({ j: x.j, nft: x.nft, gone: isGone(x) }));
+  }
+  /** What a contest's claim does about its NFTs that are gone, in words, for `claims()`: `own` the wallet's own NFT
+   * when it is gone, `picks` the losers' NFTs gone that its picks land on. */
+  const goneContestSays = (own, picks) =>
+    [
+      own
+        ? `The project no longer holds the NFT you entered (${own}): whoever controls its collection took it back or burned it while the contest held it. It can’t come back to you: claiming closes your entry and sends nothing.`
+        : '',
+      picks.length
+        ? `The project no longer holds ${picks.length === 1 ? 'the loser’s NFT' : 'the losers’ NFTs'} left for you to pick (${picks.join(', ')}): whoever controls its collection took it back or burned it. A pick of it takes nothing: claiming closes it and sends nothing.`
+        : '',
+    ]
+      .filter(Boolean)
+      .join(' ');
+
+  /**
+   * The NFTs the pulls of a wallet's parts of round `r` (`mine`: [{ entry, parts }]) are to hand out: each entry's NFT
+   * ticket ('Own'), and each NFT its places are still owed (`Prize`: the lottery's own stash's, as the pulls take them
+   * out; a project stash's named one). Returns { tickets, prizes }, their addresses.
+   */
+  async function roundNfts(r, mine) {
+    const [tickets, prizes] = [[], []];
+    let own;
+    for (const { entry, parts } of mine) {
+      const e = r.entries[entry];
+      for (const part of parts) {
+        if (part === 'Own' && e.nft !== NOBODY) tickets.push(e.nft);
+        if (!part.Prize || loot.tokenRun(r, Number(part.Prize[0]))) continue;
+        const run = Number(part.Prize[0]);
+        const place = r.terms.places[run];
+        if (place.prize?.Nft) prizes.push(place.prize.Nft.nft);
+        if (!loot.ownStash(place)) continue;
+        own ??= { stash: loot.decodeStash((await client.account(loot.pda.lotteryStash(r.lottery)))?.data ?? null) };
+        const predicted = loot.stashNfts(r, own.stash);
+        for (const p of loot.prizePlacesOwed(r, entry, run)) {
+          const nft = predicted[loot.nftSlot(r, p)];
+          if (nft) prizes.push(nft);
+        }
+      }
+    }
+    return { tickets, prizes };
+  }
+
   /**
    * When a draw of round `r` (at `key`) would cancel it (an open round short of its least tickets; a waiting one past
    * the timeout), the pulls of `who`'s own parts as the cancelled round owes them (a few entries' worth), to go right
@@ -2325,6 +2725,11 @@ export function solanaApp({
    * The pulls of `parts` of entry `i` of a round (`partsOwed`; `i` null for parts owed in common, `commonOwed`), signed by
    * `signer`, and the rolls they make ([{ order, box }], `loot.pullRolls`). With `closes`, the last pull carries the
    * round's close (when the parts it pays are the last owed).
+   * An NFT of a part that is proven gone from the project is not sent anywhere. A ticket whose price sends it on
+   * passes what proves it gone, and its part settles (`NftGone`, the round its record). A ticket going back to its
+   * buyer and a place's NFT are only handed out by the program: the pull passes each as its hold, and a release on
+   * the proof follows it here, which closes the hold (`NftGone`, the hold its record). A pull makes holds of all its
+   * prize NFTs or of none, so with one of them gone the others are made holds too and released on to their winner.
    */
   async function pulls(key, r, i, parts, signer, { closes = false, lotteryClosed = false } = {}) {
     const e = i == null ? null : r.entries[i];
@@ -2340,20 +2745,38 @@ export function solanaApp({
     const extra = await hookTail([...roundMints(r), ...r.prizes.map(p => p.mint)]);
     for (const [k, part] of parts.entries()) {
       const more = {};
+      // The NFTs this pull makes holds in place of handing them out (`hold::owe`: for whom, and whose its NFT's
+      // account's rent is), each released right after it. The round only hands an NFT out and reads nothing, so one
+      // proven gone from the project is made a hold, and that hold closes on the proof.
+      const holdsMade = new Map();
       if (part === 'Own' && e.nft !== NOBODY) {
         const then = r.status === 'Cancelled' || r.terms.returns ? null : r.terms.nft_ticket?.then;
         more.handBack = Boolean(then?.Give) && loot.handsBack(await client.account(then.Give[0]));
         const to = !then || more.handBack ? e.buyer : then.Give ? then.Give[0] : undefined;
-        const { before = [], hasAuthority: _, ...kind } = await nftOf(e.nft, signer, { to });
+        const { before = [], hasAuthority: _, gone, ...kind } = await leaving(e.nft, signer, { to });
         out.push(...before);
-        more.ticket = kind;
+        // Where its price sends it on (burned, given, stashed) the round reads the ticket itself: proven gone, it goes
+        // nowhere and the part settles. Going back to its buyer it is only handed out: made a hold, closed below.
+        if (gone && !then) {
+          more.hold = true;
+          holdsMade.set(e.nft, { kind, player: e.buyer, rentTo: e.buyer });
+        } else more.ticket = kind;
       } else if (part.Prize && !loot.tokenRun(r, Number(part.Prize[0]))) {
         // Each of the entry's places in the run: an NFT of the lottery's own stash (which one, as the pull takes them
         // out), a project stash's NFT, an item, or a roll (asked in the same transaction).
         const run = Number(part.Prize[0]);
         const given = r.terms.places[run].prize;
-        const inputs = await prizeInputs([given], signer, e.buyer);
+        // An NFT's kind is read below, with whether the project still holds it.
+        const inputs = await prizeInputs([given.Nft || given.Held ? null : given], signer, e.buyer);
         out.push(...inputs.before);
+        const handed = new Map();
+        const hand = async nft => {
+          if (inputs.nfts[nft]) return;
+          const { before, hasAuthority: _, gone, ...kind } = await leaving(nft, signer, { to: e.buyer });
+          inputs.nfts[nft] = kind;
+          out.push(...before);
+          handed.set(nft, { kind, gone, player: e.buyer, rentTo: signer });
+        };
         const stash = loot.ownStash(r.terms.places[run])
           ? loot.decodeStash((await client.account(loot.pda.lotteryStash(r.lottery)))?.data ?? null)
           : null;
@@ -2365,10 +2788,7 @@ export function solanaApp({
           const predicted = loot.stashNfts(r, stash);
           for (const place of loot.prizePlacesOwed(r, i, run)) {
             const nft = predicted[loot.nftSlot(r, place)];
-            if (!nft || inputs.nfts[nft]) continue;
-            const { before, hasAuthority: _, ...kind } = await nftOf(nft, signer, { to: e.buyer });
-            inputs.nfts[nft] = kind;
-            out.push(...before);
+            if (nft) await hand(nft);
           }
         }
         const stashes = given.Nft
@@ -2378,10 +2798,17 @@ export function solanaApp({
               ) ?? { nfts: [] },
             }
           : {};
+        // A project stash's named NFT is handed out only while that stash lists it.
+        if (given.Nft && stashes[given.Nft.stash].nfts.includes(given.Nft.nft)) await hand(given.Nft.nft);
+        // One of them gone: a pull makes holds of all its NFTs or of none, so each becomes a hold, and its release
+        // below closes the one that is gone and sends any other on to its winner.
+        const holds = [...handed.values()].some(x => x.gone);
+        if (holds) for (const [nft, x] of handed) holdsMade.set(nft, x);
         more.prize = {
           stash,
           stashes,
           nfts: inputs.nfts,
+          hold: holds,
           collection: inputs.collection,
           poolMints: inputs.poolMints,
           items: inputs.items,
@@ -2416,7 +2843,8 @@ export function solanaApp({
               ) && (await dryRun(signer, tx)).ok
             );
           };
-          let most = owed;
+          // (Made holds, each NFT's release follows the pull in its transaction: a few places a pull then.)
+          let most = holds ? Math.min(owed, 4) : owed;
           while (most > 1 && !(await sized(most))) most = Math.max(1, Math.floor(most * 0.75));
           if (most < owed) [more.prize.most, partial] = [most, true];
           heap = true;
@@ -2443,21 +2871,26 @@ export function solanaApp({
       }
       const last = k === parts.length - 1;
       const round = closes && last ? { ...r, owed: pullSettles(r, i, part) } : { ...r, owed: Number.MAX_SAFE_INTEGER };
-      out.push(
-        loot.pullIx({
-          payer: signer,
-          project,
-          roundAddress: key,
-          round,
-          entry: i ?? 0,
-          part,
-          projectState: g,
-          lotteryClosed,
-          programs,
-          extra,
-          ...more,
-        }),
-      );
+      const pull = loot.pullIx({
+        payer: signer,
+        project,
+        roundAddress: key,
+        round,
+        entry: i ?? 0,
+        part,
+        projectState: g,
+        lotteryClosed,
+        programs,
+        extra,
+        ...more,
+      });
+      out.push(pull);
+      // Each hold this pull makes (a pull that stops short carries only some) is released at once: one whose NFT is
+      // gone closes on the proof and nothing is sent, any other goes on to its winner, and the hold's rent comes back
+      // to the signer, who paid it.
+      for (const [nft, { kind, player, rentTo }] of holdsMade)
+        if (pull.keys.some(x => x.pubkey === loot.pda.hold(nft, 0)))
+          out.push(releaseOwed(nft, kind, { player, rentTo }, signer, g));
     }
     return { instructions: out, rolls, heap, partial };
   }
@@ -2596,15 +3029,18 @@ export function solanaApp({
       return out;
     },
 
-    /** Gives an order's payment back once its time has come (a roll that failed or never came). */
+    /** Gives an order's payment back once its time has come (a roll that failed or never came). An NFT the project
+     * held for the roll goes back with it; one it no longer holds (its collection took it back or burned it) is not
+     * looked for, and the whole payment goes back all the same. */
     async refund(orderAddress) {
       const order = await read('Order', orderAddress);
       // An NFT the project held for the roll goes back.
       const {
         before = [],
         hasAuthority: _,
+        gone: _gone,
         ...subject
-      } = order.held ? await nftOf(order.subject, wallet.address, { to: order.player }) : {};
+      } = order.held ? await leaving(order.subject, wallet.address, { to: order.player }) : {};
       return send([...before, loot.refundIx({ signer: wallet.address, orderAddress, order, subject, programs })]);
     },
 
@@ -2839,12 +3275,13 @@ export function solanaApp({
       shown ??= await passing(lottery.gate, 'buy a ticket');
       listProof = listProofOf(lottery.gate, l.gate?.list, listProof);
       let nft;
+      let clears = [];
       const before = [];
       if (terms.nft_ticket) {
         if (!paidWith) throw new Error(`A ticket of “${l.name}” costs an NFT: say which (nft).`);
         if (BigInt(count) !== 1n) throw new Error('An NFT pays for one ticket at a time.');
-        // The project holds an NFT ticket until the round is drawn.
-        await noLeftovers(paidWith, acceptLeftover);
+        // The project holds an NFT ticket until the round is drawn: what an earlier owner left of it goes first.
+        clears = await clearLeftovers(paidWith, acceptLeftover);
         const { before: proof, ...kind } = await nftOf(paidWith);
         nft = { asset: paidWith, ...kind };
         before.push(...proof);
@@ -2914,9 +3351,12 @@ export function solanaApp({
       }
       const buy = [...before, ...withSolWrap(wallet.address, mint, BigInt(terms.price) * BigInt(count), [ix])];
       return send(
-        draw.length
-          ? [computeUnitLimit(800_000), ...draw, ...buy.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM)]
-          : buy,
+        await closesFirst(
+          clears,
+          draw.length
+            ? [computeUnitLimit(800_000), ...draw, ...buy.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM)]
+            : buy,
+        ),
       );
     },
 
@@ -3012,9 +3452,9 @@ export function solanaApp({
       only(others, ['extra', 'transfers', 'acceptLeftover'], 'stakeNft');
       const f = part('farms', farmKey);
       const farm = await read('Farm', loot.pda.farm(project, f.id));
-      // A farm that keeps its NFTs in escrow hands this one to the project; one that freezes or watches leaves it in the
-      // wallet, where no record of the project's can move it.
-      if (farm.custody === 'Escrow') await noLeftovers(asset, acceptLeftover);
+      // A farm that keeps its NFTs in escrow hands this one to the project (what an earlier owner left of it there is
+      // cleared first); one that freezes or watches leaves it in the wallet, where no record of the project's can move it.
+      const clears = farm.custody === 'Escrow' ? await clearLeftovers(asset, acceptLeftover) : [];
       await openFor(f, farm, tier);
       const token = await farmTokens([farm.rewards_mint], [], { extra, transfers });
       const { before, ...nft } = await nftOf(asset);
@@ -3036,11 +3476,24 @@ export function solanaApp({
       // prize and as a forfeit, is sized before it goes in, and an NFT that could never come back out isn't staked.
       if (!farm.farmed.Tokens) await exitFits(f, farm, asset, nft, before, tier, token);
       return send(
-        await walking(f, farm, [
-          ...refresh,
-          ...before,
-          loot.stakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, previous, tier, ...token }),
-        ]),
+        await closesFirst(
+          clears,
+          await walking(f, farm, [
+            ...refresh,
+            ...before,
+            loot.stakeNftIx({
+              player: wallet.address,
+              project,
+              id: f.id,
+              farm,
+              asset,
+              ...nft,
+              previous,
+              tier,
+              ...token,
+            }),
+          ]),
+        ),
       );
     },
 
@@ -3081,8 +3534,10 @@ export function solanaApp({
       const boxes = roll != null ? { [roll]: await read('LootBox', loot.pda.box(project, roll)) } : {};
       // A mission whose box holds the NFT it rolls on takes it into the project's hands on the way out, from a farm that
       // left it in the wallet.
-      if (roll != null && farm.custody !== 'Escrow' && loot.boxHolds(boxes[roll]))
-        await noLeftovers(asset, acceptLeftover);
+      const clears =
+        roll != null && farm.custody !== 'Escrow' && loot.boxHolds(boxes[roll])
+          ? await clearLeftovers(asset, acceptLeftover)
+          : [];
       // A roll still at the NFT's order address blocks the leave, unless it was asked and came back with nothing to give
       // (Waiting, asked once): that one stands in for this. Any other is asked (its player or the project's keys), answered and settled first.
       if (roll != null) {
@@ -3125,7 +3580,7 @@ export function solanaApp({
             { code: tried.error.code, name: 'PrizeNotCovered' },
           );
       }
-      const { signature, rolls } = await sendRolling(steps);
+      const { signature, rolls } = await sendRolling(await closesFirst(clears, steps));
       const rolled = rolls.length ? { rolled: rolls[0] } : {};
       if (roll != null)
         return {
@@ -3466,23 +3921,37 @@ export function solanaApp({
     /**
      * Hands an NFT of any kind to the project until a time (a hold): `seconds` from now, or `{ until }` (Unix seconds).
      * The hold's address names its end. Returns { signature, freeAt }.
+     *
+     * Like every route that hands an NFT in (`stakeNft` in escrow, `borrow`, `enter`, `bid`, `listForSale`,
+     * `listForRent`, a ticket paid with an NFT, a box that rolls on one), it first clears what an earlier owner of the
+     * NFT left in this project: a hold or a listing that stayed open when whoever controls the NFT's collection took it
+     * out of the project's hands. Left open, such a record could take the NFT once the project holds it again. The
+     * player holds the NFT now, so the program closes each on that proof (a hold by `release`, a listing by
+     * `take_listing`, nothing sent or paid), in front of the deposit in the same transaction, or in a transaction of
+     * their own before it when the two do not fit one. The closes cost the player their transaction fee only: each
+     * record's rent goes to whoever that record names (a hold's payer, a listing's maker), never to the player. Only
+     * what can't be closed still refuses the deposit, in words (a listing whose rental still runs: the program keeps
+     * it until the rental has run); `acceptLeftover: true` goes ahead all the same. NFTs of the project's own
+     * collections are not read.
      */
     async hold(asset, seconds, { acceptLeftover, ...others } = NO_OPTIONS) {
       only(others, ['acceptLeftover'], 'hold');
-      await noLeftovers(asset, acceptLeftover);
+      const clears = await clearLeftovers(asset, acceptLeftover);
       const freeAt = BigInt(typeof seconds === 'object' ? seconds.until : now() + Number(seconds));
       const { before, hasAuthority: _, ...nft } = await nftOf(asset);
-      const signature = await send([
-        ...before,
-        loot.holdIx({
-          player: wallet.address,
-          project,
-          asset,
-          ...nft,
-          collection: nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE,
-          freeAt,
-        }),
-      ]);
+      const signature = await send(
+        await closesFirst(clears, [
+          ...before,
+          loot.holdIx({
+            player: wallet.address,
+            project,
+            asset,
+            ...nft,
+            collection: nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE,
+            freeAt,
+          }),
+        ]),
+      );
       return { signature, freeAt };
     },
 
@@ -3540,7 +4009,7 @@ export function solanaApp({
      */
     async borrow(maker, id, asset, { due, acceptRisks = false, acceptLeftover, extra, ...others } = NO_OPTIONS) {
       only(others, ['due', 'acceptRisks', 'acceptLeftover', 'extra'], 'borrow');
-      await noLeftovers(asset, acceptLeftover);
+      const clears = await clearLeftovers(asset, acceptLeftover);
       const loan = await this.loanOffer(maker, id);
       extra ??= await hookTail([loan.mint]);
       if (loan.risks.length && acceptRisks !== true)
@@ -3564,11 +4033,13 @@ export function solanaApp({
         programs: loanPrograms,
         extra,
       });
-      const signature = await send([
-        ...before,
-        createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, loan.mint, loan.program),
-        ix,
-      ]);
+      const signature = await send(
+        await closesFirst(clears, [
+          ...before,
+          createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, loan.mint, loan.program),
+          ix,
+        ]),
+      );
       return { signature, due, hold: loot.pda.hold(asset, due) };
     },
 
@@ -3593,7 +4064,9 @@ export function solanaApp({
      * borrower in the same instruction: one prompt. `repay`: the debt the payer was shown (`loan()`'s, in base units);
      * the program refuses any other (`TermsChanged`). An NFT its collection took back or burned while the project held
      * it is refused here, before anything is signed: the program takes no repayment for it, and the borrower keeps what
-     * they borrowed. When the NFT can't move now (frozen for now, or its collection refuses the move), or `home` is
+     * they borrowed. Such a loan is closed for nothing instead: `claims()` lists it for its borrower and its lender, and
+     * `claim` of it closes the hold (nothing is repaid, and the hold's rent goes back to whoever paid it). When the NFT
+     * can't move now (frozen for now, or its collection refuses the move), or `home` is
      * false, the money goes alone, so the loan does not fall due: the hold is then over, and anyone sends the NFT home
      * once it can move (`claims()` lists it). A compressed NFT is proven in the same transaction; the money alone for one
      * whose proof keeps going out of date goes without it. Returns { signature, home }, and `says` when the NFT waits.
@@ -3614,7 +4087,7 @@ export function solanaApp({
         );
       if ((await heldNow(asset)).held === false)
         throw new Error(
-          `The project no longer holds the NFT ${asset}: whoever controls its collection took it back or burned it while it was held. The program takes no repayment for it (NotTheNft): the borrower keeps what they borrowed.`,
+          `The project no longer holds the NFT ${asset}: whoever controls its collection took it back or burned it while it was held. The program takes no repayment for it (NotTheNft), so nothing was sent: the borrower keeps what they borrowed. This loan can be closed for nothing: claims() lists it for its borrower and for its lender, and claim() of it closes the hold (nothing is repaid, and the hold's rent goes back to whoever paid it).`,
         );
       const { before, hasAuthority: _, ...nft } = await nftOf(asset, wallet.address, { to: hold.player });
       const kind = nft.compressed || nft.tokenMetadata ? nft : { collection: (await collectionOf(asset)) ?? MPL_CORE };
@@ -3672,23 +4145,25 @@ export function solanaApp({
       listProof = listProofOf(contest.gate, null, listProof);
       if (contest.nft) {
         if (!staked) throw new Error('This contest takes an NFT: say which (nft).');
-        await noLeftovers(staked, acceptLeftover);
+        const clears = await clearLeftovers(staked, acceptLeftover);
         const { before, ...kind } = await nftOf(staked);
-        return send([
-          ...before,
-          loot.enterIx({
-            player: wallet.address,
-            project,
-            id,
-            contest,
-            side,
-            amount: 1n,
-            shown,
-            listProof,
-            nft: { asset: staked, ...kind },
-            programs,
-          }),
-        ]);
+        return send(
+          await closesFirst(clears, [
+            ...before,
+            loot.enterIx({
+              player: wallet.address,
+              project,
+              id,
+              contest,
+              side,
+              amount: 1n,
+              shown,
+              listProof,
+              nft: { asset: staked, ...kind },
+              programs,
+            }),
+          ]),
+        );
       }
       const t = [...tokens.values()].find(x => mintOf(x.key) === contest.mint);
       const value = units(amount, t?.source === 'sol' ? 9 : (t?.decimals ?? 0));
@@ -3787,7 +4262,9 @@ export function solanaApp({
      * Bids `amount` (whole units) on an auction. The bid it tops goes back to its bidder in the same transaction
      * (the program opens their account again if they closed it, paid by this bidder). In SOL, only what the player's
      * wrapped-SOL account does not hold already is wrapped, and the account stays open: if this bid is topped, it comes
-     * back there.
+     * back there. In an auction of NFT bids, an NFT of the topped bid that the project no longer holds (its collection
+     * took it back or burned it) can't go back: the bid makes it a hold for its bidder and closes that hold on the
+     * proof in the same transaction, so a high bid with an NFT gone can still be topped.
      */
     async bid(auctionKey, amount, { shown, listProof, nfts, acceptLeftover, ...others } = NO_OPTIONS) {
       only(others, ['shown', 'listProof', 'nfts', 'acceptLeftover'], 'bid');
@@ -3803,7 +4280,8 @@ export function solanaApp({
         if (bundle.length > loot.MAX_BID_NFTS) throw new Error(`A bid holds at most ${loot.MAX_BID_NFTS} NFTs.`);
         if (auction.held.length >= loot.MAX_BID_NFTS)
           throw new Error(`The high bid holds ${loot.MAX_BID_NFTS} NFTs, the most a bid holds: it can't be topped.`);
-        for (const asset of bundle) await noLeftovers(asset, acceptLeftover);
+        const clears = [];
+        for (const asset of bundle) clears.push(...(await clearLeftovers(asset, acceptLeftover)));
         const before = [];
         const kindOf = async (asset, to) => {
           const { before: proof, ...kind } = await nftOf(asset, wallet.address, { to });
@@ -3812,9 +4290,17 @@ export function solanaApp({
         };
         const bid = [];
         for (const asset of bundle) bid.push(await kindOf(asset));
-        // The bid it tops goes back to its bidder: into a fresh account of theirs when their own can't take it.
+        // The bid it tops goes back to its bidder: into a fresh account of theirs when their own can't take it. An
+        // NFT of it that is gone (its collection took it back or burned it) can't go back: the auction only hands it
+        // out, so it is made a hold for its bidder, and that hold closes on the proof right after the bid.
         const held = [];
-        for (const asset of auction.held) held.push(await kindOf(asset, auction.high_bidder));
+        const lost = new Map();
+        for (const asset of auction.held) {
+          const { before: proof, gone, ...kind } = await leaving(asset, wallet.address, { to: auction.high_bidder });
+          before.push(...proof);
+          held.push({ asset, ...kind });
+          if (gone) lost.set(asset, kind);
+        }
         const ix = loot.bidIx({
           bidder: wallet.address,
           project,
@@ -3824,9 +4310,21 @@ export function solanaApp({
           listProof,
           nfts: bid,
           held,
+          hold: [...lost.keys()],
           programs,
         });
-        return send([computeUnitLimit(800_000), ...before.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]);
+        const g = await projectNow();
+        const closes = [...lost].map(([asset, { hasAuthority: _, ...kind }]) =>
+          releaseOwed(asset, kind, { player: auction.high_bidder, rentTo: auction.high_bidder }, wallet.address, g),
+        );
+        return send(
+          await closesFirst(clears, [
+            computeUnitLimit(800_000),
+            ...before.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM),
+            ix,
+            ...closes,
+          ]),
+        );
       }
       const mint = auction.mint;
       const value = units(amount, decimalsOf(a.currency));
@@ -3872,6 +4370,12 @@ export function solanaApp({
      * the sale is called off on that evidence, which anyone may: the bid goes back to its bidder (`{ calledOff: true }`).
      * With no bid, the lot goes home to its seller. An end too big for one transaction otherwise makes each NFT that may
      * be a hold one, and sends each on with a release after it (`releases`).
+     * An NFT that is gone is never sent, whatever its kind, and the result says so (`gone: true`, and `says`, what the
+     * end did in words): a lot gone with no bid stays where it is and the auction closes, its rent to its seller; a
+     * sale with the lot or an NFT of the bid gone is called off, and what the project still holds goes back; for the
+     * project's own lot, or a lot that went first, the end passes the bid's NFT that is gone over and pays the rest.
+     * A hold made at the end whose NFT goes before its release is closed on the proof: its entry in `releases` is
+     * then `{ asset, gone: true, closed }`, `closed` the signature.
      */
     async endAuction(auctionKey, { holders, ...others } = NO_OPTIONS) {
       only(others, ['holders'], 'endAuction');
@@ -3938,21 +4442,23 @@ export function solanaApp({
      */
     async listForSale(asset, { price, currency, shares = [], acceptLeftover, ...others } = NO_OPTIONS) {
       only(others, ['price', 'currency', 'shares', 'acceptLeftover'], 'listForSale');
-      await noLeftovers(asset, acceptLeftover, { listing: true });
+      const clears = await clearLeftovers(asset, acceptLeftover, { listing: true });
       const mint = mintOf(currency);
       const { before, ...nft } = await nftOf(asset);
-      return send([
-        ...before,
-        loot.openListingIx({
-          maker: wallet.address,
-          project,
-          asset,
-          mint,
-          deal: { Sell: { price: units(price, decimalsOf(currency)) } },
-          shares,
-          ...nft,
-        }),
-      ]);
+      return send(
+        await closesFirst(clears, [
+          ...before,
+          loot.openListingIx({
+            maker: wallet.address,
+            project,
+            asset,
+            mint,
+            deal: { Sell: { price: units(price, decimalsOf(currency)) } },
+            shares,
+            ...nft,
+          }),
+        ]),
+      );
     },
 
     /**
@@ -3964,31 +4470,40 @@ export function solanaApp({
       { price, lasts, maxPeriods = 1, currency, shares = [], acceptLeftover, ...others } = NO_OPTIONS,
     ) {
       only(others, ['price', 'lasts', 'maxPeriods', 'currency', 'shares', 'acceptLeftover'], 'listForRent');
-      await noLeftovers(asset, acceptLeftover, { listing: true });
+      const clears = await clearLeftovers(asset, acceptLeftover, { listing: true });
       const mint = mintOf(currency);
       const { before, ...nft } = await nftOf(asset);
-      return send([
-        ...before,
-        loot.openListingIx({
-          maker: wallet.address,
-          project,
-          asset,
-          mint,
-          deal: { Rent: { price: units(price, decimalsOf(currency)), lasts, max_periods: maxPeriods } },
-          shares,
-          ...nft,
-        }),
-      ]);
+      return send(
+        await closesFirst(clears, [
+          ...before,
+          loot.openListingIx({
+            maker: wallet.address,
+            project,
+            asset,
+            mint,
+            deal: { Rent: { price: units(price, decimalsOf(currency)), lasts, max_periods: maxPeriods } },
+            shares,
+            ...nft,
+          }),
+        ]),
+      );
     },
 
-    /** The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. */
+    /**
+     * The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. One more
+     * read says whether the project still holds the NFT: when whoever controls its collection took it back or burned
+     * it, the listing is flagged `gone` with `says`, what that means in words. There is then nothing to buy or rent,
+     * and the listing can be closed for nothing (`unlist` by its maker, `closeGone` by anyone).
+     */
     async listing(asset) {
       const listing = await readMaybe('Listing', loot.pda.listing(project, asset));
       if (!listing) return null;
+      const gone = (await heldNow(asset)).held === false;
       return {
         listing: loot.pda.listing(project, asset),
         ...listing,
         renter: loot.renterOf(listing, await chainNow()),
+        ...(gone ? { gone: true, says: GONE_LISTING } : {}),
       };
     },
 
@@ -4002,7 +4517,12 @@ export function solanaApp({
       return holds ? renter : null;
     },
 
-    /** The project's listings, a maker's (`maker`) or all: one search of the program's accounts. */
+    /**
+     * The project's listings, a maker's (`maker`) or all: one search of the program's accounts, then one read of the
+     * listed NFTs together, which flags a listing `gone` (with `says`) when the project no longer holds its NFT: a
+     * Core asset held by another or burned, a Token Metadata NFT whose token left the project's account. A compressed
+     * NFT is not read here (an indexer's answer for each): `listing(asset)` says it for one.
+     */
     async listings({ maker, ...others } = NO_OPTIONS) {
       only(others, ['maker'], 'listings');
       const filters = [
@@ -4011,19 +4531,36 @@ export function solanaApp({
         ...(maker ? [{ memcmp: { offset: 33, bytes: maker } }] : []),
       ];
       const time = await chainNow();
-      return (await client.programAccounts(loot.LOOT_PROGRAM, filters)).map(({ pubkey, account }) => {
+      const found = (await client.programAccounts(loot.LOOT_PROGRAM, filters)).map(({ pubkey, account }) => {
         const listing = loot.decode('Listing', account.data);
         return { listing: pubkey, ...listing, renter: loot.renterOf(listing, time) };
       });
+      // Each NFT and the project's token account of it, all in one read.
+      const read = found.length ? await client.accounts(found.flatMap(l => [l.asset, loot.ata(project, l.asset)])) : [];
+      return found.map((l, i) => {
+        const [nft, held] = [read[2 * i], read[2 * i + 1]];
+        const gone =
+          nft?.owner === MPL_CORE
+            ? !coreHeld(nft)
+            : nft?.owner === TOKEN_PROGRAM &&
+              !(
+                held?.data?.length >= 72 &&
+                new DataView(held.data.buffer, held.data.byteOffset).getBigUint64(64, true) === 1n
+              );
+        return gone ? { ...l, gone: true, says: GONE_LISTING } : l;
+      });
     },
 
     /**
      * Buys a listed NFT at the terms the player saw: `listing`, as `listing()` or `listings()` showed it. It is
      * required: the terms signed are those, never the listing read now, so a price or a share changed since is refused.
+     * A listing whose NFT the project no longer holds (its collection took it back or burned it) is refused in words
+     * before anything is signed: nothing is there to buy, and anyone can close that listing for nothing (`closeGone`).
      */
     async buyListing(asset, { listing, ...others } = NO_OPTIONS) {
       only(others, ['listing'], 'buyListing');
       await shownListing(asset, listing, 'Sell');
+      await listedStill(asset);
       const { before, ...nft } = await nftOf(asset, wallet.address, { to: wallet.address });
       const holders = await holdersOf(listing.shares ?? []);
       return send([
@@ -4044,11 +4581,13 @@ export function solanaApp({
 
     /**
      * Rents a listed NFT for `periods` periods, at the terms the player saw: `listing`, as `listing()` or `listings()`
-     * showed it (required, as for `buyListing`).
+     * showed it (required, as for `buyListing`). One whose NFT the project no longer holds is refused in words, as
+     * `buyListing` refuses it.
      */
     async rentListing(asset, { periods = 1, listing, ...others } = NO_OPTIONS) {
       only(others, ['periods', 'listing'], 'rentListing');
       await shownListing(asset, listing, 'Rent');
+      await listedStill(asset);
       const holders = await holdersOf(listing.shares ?? []);
       const total = BigInt(listing.deal.Rent.price) * BigInt(periods);
       // A compressed NFT is read by its record, proven first in the same transaction.
@@ -4070,13 +4609,66 @@ export function solanaApp({
       ]);
     },
 
-    /** Takes a listed NFT home (its maker). While a rental runs it only stops the listing; call again once it is over. */
+    /**
+     * Takes a listed NFT home (its maker). While a rental runs it only stops the listing; call again once it is over.
+     * A listing whose NFT the project no longer holds (its collection took it back or burned it) closes without it, on
+     * that proof: nothing is sent, and the listing's rent comes back to its maker. While a rental of it still runs,
+     * that close too only stops the listing, and closes it once the rental has run.
+     */
     async unlist(asset) {
       const listing = await read('Listing', loot.pda.listing(project, asset));
+      const proof = await goneProof(asset);
+      if (proof)
+        return send([...proof.before, loot.closeListingIx({ maker: wallet.address, project, listing, ...proof.kind })]);
       const { before, ...nft } = await nftOf(asset, wallet.address, { to: wallet.address });
       return send([...before, loot.closeListingIx({ maker: wallet.address, project, listing, ...nft })]);
     },
 
+    /**
+     * Closes what this project still records of an NFT it no longer holds (`asset`: whoever controls its collection
+     * took it out of the project's hands or burned it): each hold of it (`release`), its listing (`take_listing`),
+     * and its row on each of the project's stashes that lists it (`stash`, out), on the proof that it is gone. Anyone
+     * may, at any time, also while a hold runs and for a loan before it is due: nothing is sent or paid, and a loan's
+     * debt ends unpaid. The sender pays the transaction's fee only; each record's rent goes to whoever that record
+     * names (a hold's payer, a listing's maker), never to the sender, and a stash keeps the rent its row no longer
+     * needs (it goes to the sender only when that is one of the project's keys). With its row off a stash, no roll
+     * draws the NFT, and a prize that names it is passed over in place of failing on an NFT that can't move.
+     * What is left is in `waits`: a listing whose rental still runs (the program keeps a running rental, and the
+     * listing closes once it has run), and a lottery's own stash that lists the NFT (`kind` 'lottery-stash', with its
+     * `lottery`, the lottery's id): only the project's keys take a row out of that one (`unraffle`), gone or not.
+     * Refused in words, with nothing sent, when the project still holds the NFT or nothing shows it gone.
+     * Besides one search of the NFT's holds, this makes one search of the project's stashes, which returns every
+     * stash of the project whole (36 bytes for each NFT a stash lists): a stash's rows have no fixed place to look in.
+     * Returns { signature, closed: [{ kind, address }], unstashed: [{ address, id }], waits: [{ kind, address }] }:
+     * `closed` the holds and the listing it closed, `unstashed` the project's stashes it took the row off;
+     * `signature` is null when there was nothing to close.
+     */
+    async closeGone(asset) {
+      const [records, stashes] = [await recordsOf(asset), await stashesOf(asset)];
+      if (!records.length && !stashes.length) return { signature: null, closed: [], unstashed: [], waits: [] };
+      const proof = await goneProof(asset);
+      if (!proof)
+        throw new Error(
+          `Nothing shows that the project no longer holds the NFT ${asset}: its records close this way only once it is proven gone (its collection took it back or burned it). Nothing was sent.`,
+        );
+      const { closes, closed, waits } = await closesOf(asset, records, proof);
+      const listed = stashes.filter(x => x.kind === 'stash');
+      // The row comes off each of the project's stashes: free, nothing moves, and where it would go is not read.
+      const offs = listed.map(({ id }) =>
+        loot.stashIx({ signer: wallet.address, project, id, asset, out: wallet.address, ...proof.kind }),
+      );
+      const left = [
+        ...waits.map(({ kind, address }) => ({ kind, address })),
+        ...stashes
+          .filter(x => x.kind === 'lottery-stash')
+          .map(({ kind, address, id }) => ({ kind, address, lottery: id })),
+      ];
+      const unstashed = listed.map(({ address, id }) => ({ address, id }));
+      const instructions = [...(closes.length ? closes : offs.length ? proof.before : []), ...offs];
+      if (!instructions.length) return { signature: null, closed, unstashed, waits: left };
+      return { signature: await send(instructions), closed, unstashed, waits: left };
+    },
+
     // ---------------------------------------------------------------- raffles
 
     /**
@@ -4125,9 +4717,20 @@ export function solanaApp({
       return send([loot.upsertIx({ owner: wallet.address, project, def: { Lottery: { id, args } }, lotteryState })]);
     },
 
-    /** The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery ended, or no place names it). */
+    /**
+     * The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery
+     * ended, or no place names it). When the project no longer holds the NFT (its collection took it back or burned
+     * it), only its row comes off the stash, on that proof: nothing is sent, and the owner gets no NFT back. Only the
+     * project's owner or authority may, gone or not: a lottery's own stash is theirs alone (`NotAuthority` for anyone
+     * else; `closeGone` leaves it and says so). Returns the signature.
+     */
     async unraffle(id, nft) {
-      const { before, hasAuthority: _, ...piece } = await nftOf(nft, wallet.address, { to: wallet.address });
+      const {
+        before,
+        hasAuthority: _,
+        gone: _g,
+        ...piece
+      } = await leaving(nft, wallet.address, { to: wallet.address });
       const lotteryState = await readMaybe('Lottery', loot.pda.lottery(project, id));
       return send([
         ...before,
@@ -4413,11 +5016,17 @@ export function solanaApp({
 
     /**
      * What this player can finish now, themselves: a box to settle or refund, a contest entry to claim, a held
-     * collectible to take home, an auction they won (or one off by the clock: their bid back), a lottery place they
+     * collectible to take home, a hold of theirs or a loan they made or took whose NFT the project no longer holds (its
+     * collection took it back or burned it: listed at any time, also while the hold runs, as a `release` flagged
+     * `gone`, whose claim closes the hold and sends nothing), an auction they won (or one off by the clock: their bid back), a lottery place they
      * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0008
      * SOL), and a drawn lottery's unpaid places, which anyone may pay so the next round can open. [{ kind, says, … }];
      * a winner's first claim of a contest of tokens carries `potUnits` and `prizeUnits`, its part as the decision wrote
      * it (base units, as text). Pass one to `claim`.
+     * A `pull`, a `contest` or an `auction` whose claim would hand out an NFT the project no longer holds is flagged
+     * `gone` too, with `assets` (those NFTs) and `says`, what the claim does about each in words: a ticket's NFT, a
+     * place's NFT, a contest's entry or a loser's NFT picked is not sent anywhere and its part closes; an auction with
+     * its lot or an NFT of its winning bid gone is called off, or ended without it. Show `says` before the player signs.
      */
     async claims() {
       const me = wallet.address;
@@ -4453,8 +5062,8 @@ export function solanaApp({
         const off = loot.contestOff(contest, time);
         if (!(off || contest.verdict === 'Won')) continue;
         const list = await client.account(loot.contestEntries(pubkey, contest));
-        const entry =
-          list?.owner === loot.LOOT_PROGRAM ? loot.decodeEntries(list.data).find(e => e.player === me) : null;
+        const entries = list?.owner === loot.LOOT_PROGRAM ? loot.decodeEntries(list.data) : [];
+        const entry = entries.find(e => e.player === me);
         if (!entry) continue;
         const won = !off && Number(contest.winner) === Number(entry.side);
         const first = won && !(entry.bits & loot.CLAIMED);
@@ -4477,55 +5086,61 @@ export function solanaApp({
               : 'Your share of the pot.';
         // A winner's part of a contest of tokens is what the decision wrote, whoever claims first (`contestWinnings`).
         const winnings = first && !contest.nft ? loot.contestWinnings(contest, entry.amount) : null;
+        // A contest of NFTs: what its claim moves, and which of those the project no longer holds (its collection
+        // took it back or burned it). Such an NFT is not sent anywhere: the claim closes it, and says so here first.
+        const moves = contest.nft ? await contestNfts(contest, entries, entries.indexOf(entry), undefined) : [];
+        const lost = moves.filter(m => m.gone);
+        const mine = lost.find(m => m.nft === entry.nft && entries[m.j] === entry);
+        const there = [
+          moves.some(m => entries[m.j] === entry && !m.gone) ? 'your NFT back' : '',
+          moves.some(m => entries[m.j] !== entry && !m.gone) ? 'your pick of the losers’' : '',
+        ]
+          .filter(Boolean)
+          .join(', and ');
+        const goneSays = [
+          off ? 'The contest is off.' : '',
+          there ? `${there[0].toUpperCase()}${there.slice(1)}.` : '',
+          goneContestSays(
+            mine?.nft,
+            lost.filter(m => m !== mine).map(m => m.nft),
+          ),
+        ]
+          .filter(Boolean)
+          .join(' ');
         out.push({
           kind: 'contest',
           id: contest.id,
           side: entry.side,
-          says,
+          ...(lost.length ? { gone: true, assets: lost.map(m => m.nft), says: goneSays } : { says }),
           ...(winnings ? { potUnits: String(winnings.pot), prizeUnits: String(winnings.prize) } : {}),
         });
       }
       // The player's holds; the project's treasury wallet's also those owed to the treasury (a hold whose player is the
-      // project's own address: a dropped stash NFT, a lottery's or an auction's NFT owed to it).
+      // project's own address: a dropped stash NFT, a lottery's or an auction's NFT owed to it). And the loans this
+      // wallet made: one search of the project's holds finds them all.
       const g = await projectNow();
       const holdsOf = [me, ...(g.treasury === me ? [project] : [])];
-      const holds = (
-        await Promise.all(
-          holdsOf.map(who => client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, who)])),
-        )
-      ).flat();
-      for (const { pubkey, account } of holds) {
-        const hold = loot.decode('Hold', account.data);
-        // A repaid loan is a plain hold that is over (no debt, `free_at` 0): its NFT goes home whenever. An unpaid one's
-        // is the lender's once due.
-        if (!hold.debt && time >= BigInt(hold.free_at))
-          out.push(
-            await goneOr(hold.asset, {
-              kind: 'release',
-              asset: hold.asset,
-              hold: pubkey,
-              says:
-                hold.player === project
-                  ? 'An NFT owed to the treasury: send it there.'
-                  : 'Your collectible back: its hold is over.',
-            }),
-          );
-      }
-      // A loan this wallet made that is overdue and unpaid: its NFT is the lender's to take.
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [
-        tag('Hold'),
-        at(1, project),
-      ])) {
-        const hold = loot.decode('Hold', account.data);
-        if (hold.debt?.lender === me && time >= BigInt(hold.free_at))
-          out.push(
-            await goneOr(hold.asset, {
-              kind: 'release',
-              asset: hold.asset,
-              hold: pubkey,
-              says: 'A loan you made is overdue and unpaid: take its NFT.',
-            }),
-          );
+      const holds = (await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project)]))
+        .map(({ pubkey, account }) => ({ pubkey, hold: loot.decode('Hold', account.data) }))
+        .filter(({ hold }) => holdsOf.includes(hold.player) || hold.debt?.lender === me);
+      // Whether the project still holds each one's NFT: whoever controls its collection can take it back or burn it.
+      const heldOf = await heldEach(holds.map(({ hold }) => hold.asset));
+      for (const { pubkey, hold } of holds) {
+        const claim = { kind: 'release', asset: hold.asset, hold: pubkey };
+        // An NFT proven gone: its hold closes at any time, also while it runs and for a loan before it is due.
+        if (heldOf.get(hold.asset)?.held === false) out.push({ ...claim, gone: true, says: goneHoldSays(hold) });
+        // A repaid loan is a plain hold that is over (no debt, `free_at` 0): its NFT goes home whenever.
+        else if (!hold.debt && holdsOf.includes(hold.player) && time >= BigInt(hold.free_at))
+          out.push({
+            ...claim,
+            says:
+              hold.player === project
+                ? 'An NFT owed to the treasury: send it there.'
+                : 'Your collectible back: its hold is over.',
+          });
+        // A loan this wallet made that is overdue and unpaid: its NFT is the lender's to take.
+        else if (hold.debt?.lender === me && time >= BigInt(hold.free_at))
+          out.push({ ...claim, says: 'A loan you made is overdue and unpaid: take its NFT.' });
       }
       // A compressed NFT's proof record this wallet paid for and left open: closing it brings its rent back.
       for (const { account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Proven')])) {
@@ -4546,32 +5161,47 @@ export function solanaApp({
       }
       const auctions = spec.auctions ?? [];
       const found = await client.accounts(auctions.map(a => auctionAt(a)));
-      auctions.forEach((a, i) => {
+      for (const [i, a] of auctions.entries()) {
         const x = found[i] && loot.decode('Auction', found[i].data);
-        if (!x || time < loot.auctionEnds(x)) return;
+        if (!x || time < loot.auctionEnds(x)) continue;
+        const [sold, owed] = [BigInt(x.high) > 0n, BigInt(x.proceeds_owed) > 0n];
+        if (!(x.seller === me || (sold && !owed && x.high_bidder === me))) continue;
+        // Its lot, or an NFT of the winning bid, that the project no longer holds (its collection took it back or
+        // burned it): the end does not send it anywhere, and this says what the end does instead.
+        const lot = owed ? null : (x.lot.Asset?.[0] ?? null);
+        const bids = sold && x.nft_bids ? x.held : [];
+        const heldOf = lot || bids.length ? await heldEach([...(lot ? [lot] : []), ...bids]) : new Map();
+        const lostBids = bids.filter(nft => heldOf.get(nft)?.held === false);
+        if ((lot && heldOf.get(lot)?.held === false) || lostBids.length) {
+          const lotGone = lot && heldOf.get(lot)?.held === false;
+          out.push({
+            kind: 'auction',
+            key: a.key,
+            gone: true,
+            assets: [...(lotGone ? [lot] : []), ...lostBids],
+            says: goneSaleSays(a.name, x, me, lotGone ? lot : null, lostBids),
+          });
+          continue;
+        }
         // The lot went first (an end too wide for one transaction, or a seller's account that couldn't take the money
         // then): only the money is left to pay.
-        if (BigInt(x.proceeds_owed) > 0n) {
-          if (x.seller === me)
-            out.push({
-              kind: 'auction',
-              key: a.key,
-              says: `The winner of “${a.name}” has the lot, and the winning bid is still to be paid to you: end it again, and it is paid (once your account can take it).`,
-            });
-          return;
-        }
-        if (x.high_bidder === me) out.push({ kind: 'auction', key: a.key, says: `You won “${a.name}”: take it.` });
+        if (owed)
+          out.push({
+            kind: 'auction',
+            key: a.key,
+            says: `The winner of “${a.name}” has the lot, and the winning bid is still to be paid to you: end it again, and it is paid (once your account can take it).`,
+          });
+        else if (x.high_bidder === me) out.push({ kind: 'auction', key: a.key, says: `You won “${a.name}”: take it.` });
         // The seller's own auction, over: ending it pays them (or brings an unsold lot home).
-        else if (x.seller === me)
+        else
           out.push({
             kind: 'auction',
             key: a.key,
-            says:
-              BigInt(x.high) > 0n
-                ? `Your auction “${a.name}” is over: end it, and the winning bid is paid to you.`
-                : `Your auction “${a.name}” ended with no bid: take your lot back.`,
+            says: sold
+              ? `Your auction “${a.name}” is over: end it, and the winning bid is paid to you.`
+              : `Your auction “${a.name}” ended with no bid: take your lot back.`,
           });
-      });
+      }
       for (const l of spec.lotteries ?? []) {
         // A lottery the page names but nobody has written yet (a raffle still to open) has nothing to finish.
         if (!(await client.account(loot.pda.lottery(project, l.id)))) continue;
@@ -4610,17 +5240,32 @@ export function solanaApp({
             const parts = e.buyer === me ? loot.partsOwed(r, i) : [];
             return parts.length ? [{ entry: i, parts }] : [];
           });
-          if (mine.length)
+          if (mine.length) {
+            // An NFT of these parts that the project no longer holds (its collection took it back or burned it) is
+            // not sent anywhere: the claim settles its part without it, and says so here first.
+            const { tickets, prizes } = await roundNfts(r, mine);
+            const heldOf = tickets.length + prizes.length ? await heldEach([...tickets, ...prizes]) : new Map();
+            const lost = list => [...new Set(list)].filter(nft => heldOf.get(nft)?.held === false);
+            const [lostTickets, lostPrizes] = [lost(tickets), lost(prizes)];
+            const back = r.status === 'Cancelled' || Boolean(r.terms.returns);
+            const owed =
+              r.status === 'Cancelled'
+                ? `Recover your ticket payment for “${l.name}”.`
+                : `Take what you are owed in “${l.name}”.`;
             out.push({
               kind: 'pull',
               key: l.key,
               round,
               pulls: mine,
-              says:
-                r.status === 'Cancelled'
-                  ? `Recover your ticket payment for “${l.name}”.`
-                  : `Take what you are owed in “${l.name}”.`,
+              ...(lostTickets.length + lostPrizes.length
+                ? {
+                    gone: true,
+                    assets: [...lostTickets, ...lostPrizes],
+                    says: `${owed} ${goneRoundSays(lostTickets, lostPrizes, back)}`,
+                  }
+                : { says: owed }),
             });
+          }
           // Anyone may pay everyone else what they are owed, and the parts owed in common (about 0.002 SOL of account
           // rent for each payee who has no account for it yet, which stays with them): the last pull closes the round,
           // and its rent goes back to whoever fronted it (the lottery, or its first buyer).
@@ -4722,9 +5367,18 @@ export function solanaApp({
     },
 
     /**
-     * Finishes one of `claims()`, signed by this player. Returns the signature. A winner of a contest of NFTs picks
-     * which loser's NFT they take (`{ take: asset }`, the NFT of a losing entry that still holds one; the first found by default):
-     * only the winner can, while any are left.
+     * Finishes one of `claims()`, signed by this player. Returns the signature. A `release` flagged `gone` closes its
+     * hold on the proof that the project no longer holds the NFT: nothing is sent, the hold's rent goes back to whoever
+     * paid it, and a loan's debt ends unpaid. A winner of a contest of NFTs picks
+     * which loser's NFT they take (`{ take: asset }`, the NFT of a losing entry that still holds one; by default the
+     * first found that the project still holds): only the winner can, while any are left.
+     * An NFT a lottery's round or a contest owes that the project no longer holds (its collection took it back or
+     * burned it) is not sent anywhere, and the claim still finishes. A ticket whose price sends it on (burned, given,
+     * stashed) settles on the proof with nothing moved. A ticket going back to its buyer, a place's NFT and a
+     * contest's NFT are only handed out by the program, which reads nothing first: the claim has it make a hold of
+     * that NFT (`["hold", nft, 0]`) and closes that hold on the proof right after, in the same transaction when it
+     * fits. The signer pays that hold's rent and gets it back at once. The program's receipts for it are those of a
+     * hold made (`Held`, and `PrizeGiven` for a place's prize) and then `NftGone`: no `Released`.
      */
     async claim(c, { take, build = false, ...others } = NO_OPTIONS) {
       only(others, ['take', 'build'], 'claim');
@@ -4755,37 +5409,25 @@ export function solanaApp({
         // lets it pick (`take`: one asset, or several; the first left by default), as many as fit.
         const nfts = [];
         const kinds = {};
+        // The NFTs of this claim that are proven gone from the project, each with what shows it and who staked it.
+        // The contest only hands an NFT out and reads nothing, so each is passed as its hold (`["hold", nft, 0]`, made
+        // for this player, who gets it), and that hold closes on the proof right after the claim: nothing is sent.
+        const lost = new Map();
         if (contest.nft) {
           const proofs = {};
-          const kindOf = async (asset, to) => {
-            const { before, hasAuthority: _, ...kind } = await nftOf(asset, me, { to });
-            proofs[asset] = before;
-            kinds[asset] = kind;
-          };
-          if (Number(own.amount) === 1) {
-            nfts.push(i);
-            await kindOf(own.nft, me);
-          }
-          const share = won && !(own.bits & loot.ENDED) ? loot.shareOf(contest, own) - Number(own.taken) : 0;
-          const left = entries
-            .map((e, j) => ({ e, j }))
-            .filter(({ e }) => Number(e.side) !== Number(contest.winner) && Number(e.amount) === 1);
-          const wanted = take ? [take].flat() : [];
-          const picked = (wanted.length ? left.filter(({ e }) => wanted.includes(e.nft)) : left).slice(
-            0,
-            Math.min(share, 4),
-          );
-          if (wanted.length && picked.length < Math.min(wanted.length, share))
-            throw new Error(`${wanted.join(', ')} is not a loser’s NFT left in this contest for you to pick.`);
-          for (const { e, j } of picked) {
+          for (const { j, nft } of await contestNfts(contest, entries, i, take)) {
+            const { before, hasAuthority: _, gone, ...kind } = await leaving(nft, me, { to: me });
+            proofs[nft] = before;
+            kinds[nft] = kind;
+            if (gone) lost.set(nft, { kind, player: me, rentTo: entries[j].player });
             nfts.push(j);
-            await kindOf(e.nft, me);
           }
           // A compressed NFT's proof is long (up to 17 nodes): such a claim moves one NFT, as a v0 transaction with a
           // lookup table (`send`), and the next claim takes the next.
           if (nfts.length > 1 && nfts.some(j => kinds[entries[j].nft]?.compressed)) nfts.splice(1);
           for (const j of nfts) given.before.push(...proofs[entries[j].nft]);
         }
+        const closes = nfts.map(j => entries[j].nft).filter(nft => lost.has(nft));
         const claimed = [
           computeUnitLimit(800_000),
           ...given.before.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM),
@@ -4799,19 +5441,37 @@ export function solanaApp({
             player: me,
             nfts: contest.nft ? nfts : undefined,
             kinds,
+            hold: closes,
             collection: given.collection,
             poolMints: given.poolMints,
             items: given.items,
             nft: given.nft,
             programs,
           }),
+          ...closes.map(nft => releaseOwed(nft, lost.get(nft).kind, lost.get(nft), me, g)),
         ];
         // A prize that rolls: asked for in the claim's own transaction and settled by a key after (one prompt).
         return contest.prize?.Roll && !build ? (await sendRolling(claimed)).signature : send(claimed);
       }
       if (c.kind === 'release') {
-        if (c.gone) throw new Error(c.says);
         const hold = await read('Hold', c.hold);
+        // Its NFT proven gone from the project: the hold closes on that proof, at any time, and nothing is sent. Its
+        // rent goes back to whoever paid it; a loan's debt ends unpaid.
+        const proof = await goneProof(c.asset, me);
+        if (proof)
+          return send([
+            ...proof.before,
+            loot.releaseIx({
+              signer: me,
+              project,
+              asset: c.asset,
+              ...proof.kind,
+              hold,
+              address: c.hold,
+              treasury: g.treasury,
+              ...(hold.debt ? { to: hold.debt.lender } : {}),
+            }),
+          ]);
         const { before, hasAuthority: _, ...nft } = await nftOf(c.asset, me, { to: me });
         // An overdue loan's NFT goes to its lender.
         return send([