From 69a97544dabdfb812c332ca37f4ef460f291d9a2 Mon Sep 17 00:00:00 2001
From: teahubxyz <teahubxyz@teahub.xyz>
Date: Thu, 15 Oct 2026 00:32:29 -0700
Subject: [PATCH] Orgchain v1.7: items, standing offers and the first deal; a
 Mainnet setting

The chain takes ordinary spends of up to eight inputs and outputs, whose
key-path signatures may carry SIGHASH_SINGLE|ANYONECANPAY (0x83); reveals
keep their two-in, two-out shape. A new make op records an item, an
inscription its maker holds. Any node can offer test BTC for an item another
node holds, in any holding: the buyer's SegWit key signs the whole deal, the
offer stands in the lab, and the holder accepts by countersigning the item's
input, so the item and the payment swap in one transaction. Offers go stale
when a promised coin moves or a side re-keys or closes, and payments spend
unpromised coins first. Sends take up to eight coins. Mainnet is a third
mining setting: no holding mines, beats pay the lab wallet, and holdings are
funded from it. The sample ends on lineage's open offer for sol's launch-kit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H4upF5LVwmPDDqrhdUfnXh
---
 AGENTS.md               |  17 ++--
 PROVENANCE.md           |   2 +-
 README.md               |  36 ++++++---
 index.html              |  35 ++++++--
 src/adapters/chain.js   |  16 ++--
 src/main.js             | 171 +++++++++++++++++++++++++++++++++-------
 src/orgchain.css        |  10 +++
 src/orgchain/actions.js |  63 ++++++++++++---
 src/orgchain/lineage.js |  14 +++-
 src/orgchain/money.js   | 106 +++++++++++++++++--------
 src/orgchain/offers.js  | 119 ++++++++++++++++++++++++++++
 src/orgchain/store.js   |  20 +++--
 tests/money.test.js     |  30 ++++++-
 tests/offers.test.js    | 169 +++++++++++++++++++++++++++++++++++++++
 tests/orgchain.spec.js  |  67 ++++++++++++++++
 15 files changed, 764 insertions(+), 111 deletions(-)
 create mode 100644 src/orgchain/offers.js
 create mode 100644 tests/offers.test.js

diff --git a/AGENTS.md b/AGENTS.md
index 6ac8797..25eacdc 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -7,12 +7,17 @@ Orgchain is lineage's app for creating and operating lineage holdings on Super T
   is vetted by that reducer before it is signed. A new op means a reducer change, its tests and the README's table.
 - The engine (`src/adapters`, `src/upstream`, `src/storage.js`, `src/miner.js`) is Super Testnet's. Compose with it
   rather than rewriting it, and keep its tests passing. Preserve upstream licenses and provenance. Its local
-  changes are P2WPKH payments and a coinbase split across up to 64 outputs, both in `src/adapters/chain.js`
-  (PROVENANCE.md); keep them small and tested.
-- Money lives in `src/orgchain/money.js`: beats pay the holdings (split by hashrate, or all to the last act), sends
-  spend SegWit coins only, so an inscription can never leave as change, and balances are read off the chain, never
-  stored. Gas (`src/orgchain/actions.js`): every act is paid by the actor's own keys and checked before anything is
-  signed; the lab wallet pays only for foundings and for holdings that predate lab keys.
+  changes are P2WPKH payments, a coinbase split across up to 64 outputs, and ordinary spends of up to eight inputs
+  and outputs whose key-path signatures may carry 0x83, all in `src/adapters/chain.js` (PROVENANCE.md); keep them
+  small and tested.
+- Money lives in `src/orgchain/money.js`: beats pay the holdings (split by hashrate, or all to the last act; under
+  Mainnet none mine, and the lab wallet funds them), sends spend SegWit coins only, so an inscription can never leave
+  as change, and balances are read off the chain, never stored. Gas (`src/orgchain/actions.js`): every act is paid by
+  the actor's own keys and checked before anything is signed; the lab wallet pays only for foundings and for holdings
+  that predate lab keys.
+- Deals live in `src/orgchain/offers.js`: the buyer pre-signs the whole transaction and the holder countersigns.
+  An offer is signatures kept in the lab, never chain state, and who holds an item is read off the chain, never
+  from metadata. Inscription metadata is public and permanent, so never put a secret in it (item notes included).
 - Keys follow the tree (`src/orgchain/keys.js`): store roots only (one per holding, one per graduated org) and derive
   every other key from its position. Every act is signed by whichever key holds the authorizing inscription.
 - A node's chain key is its account's BIP-86 Taproot key (`m/86'/1'/account'/0/0`); SegWit is BIP-84 at the same
diff --git a/PROVENANCE.md b/PROVENANCE.md
index 41702cd..ad2c401 100644
--- a/PROVENANCE.md
+++ b/PROVENANCE.md
@@ -20,7 +20,7 @@ Runtime dependencies are pinned in `package.json` and `package-lock.json`:
 - **@scure/bip32 1.7.0**, Patricio Palladino and Paul Miller, [upstream](https://github.com/paulmillr/scure-bip32), MIT. Used for HD derivation under the BIP-85, BIP-86, BIP-84 and NIP-06 paths. License retained at [`public/licenses/scure-bip32.txt`](public/licenses/scure-bip32.txt).
 - **@scure/bip39 1.6.0**, Patricio Palladino and Paul Miller, [upstream](https://github.com/paulmillr/scure-bip39), MIT. Used for the 24-word lab roots and their seeds. License retained at [`public/licenses/scure-bip39.txt`](public/licenses/scure-bip39.txt).
 
-Two local changes to the engine, both original code in `src/adapters/chain.js`, tested in `tests/money.test.js`, with Super Testnet's tests (`tests/adapters.test.js`) passing unchanged. Orgchain v1.5: the chain also accepts native SegWit (P2WPKH) outputs and SIGHASH_ALL P2WPKH spends, verified per BIP-143, so lineage accounts can hold and send test BTC at their BIP-84 addresses; everything about inscriptions stays Taproot-only. Orgchain v1.6: a coinbase may split the block reward across up to 64 outputs (`mineTo`; `mine` still pays one script), so one beat can pay several holdings.
+Three local changes to the engine, all original code in `src/adapters/chain.js`, tested in `tests/money.test.js`, with Super Testnet's tests (`tests/adapters.test.js`) passing unchanged. Orgchain v1.5: the chain also accepts native SegWit (P2WPKH) outputs and SIGHASH_ALL P2WPKH spends, verified per BIP-143, so lineage accounts can hold and send test BTC at their BIP-84 addresses; everything about inscriptions stays Taproot-only. Orgchain v1.6: a coinbase may split the block reward across up to 64 outputs (`mineTo`; `mine` still pays one script), so one beat can pay several holdings. Orgchain v1.7: ordinary (non-reveal) spends may take up to eight inputs and outputs (`MAX_IO`), and their key-path Taproot signatures may carry SIGHASH_SINGLE|ANYONECANPAY (0x83, the sell-order flag), so one transaction can carry a deal: an item, the buyer's coins, the price and change. Reveals keep their two-in, two-out shape and default signatures.
 
 Vite and Playwright are build/test dependencies, not runtime network services. Their installed package notices remain in the locked dependency installation. No unlicensed upstream code was copied.
 
diff --git a/README.md b/README.md
index 5c6bdab..d346c52 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,9 @@ inscription on a private toy chain in your browser, and its parent inscription i
 chain itself records who did what, and when.
 
 - **Found** a holding (a root: the LLC). **Birth** orgs and agents under any org. **Award** a belt (one skill, one
-  seat). **Decide** (a decision on a node's record). **Graduate** an org (its edge flips from derived to adopted).
-  **Close** a node (derived children close with it; graduated ones hold their own roots and stay open).
+  seat). **Decide** (a decision on a node's record). **Make** an item (an inscription its maker holds, and can sell).
+  **Graduate** an org (its edge flips from derived to adopted). **Close** a node (derived children close with it;
+  graduated ones hold their own roots and stay open).
 - **Time.** A beat is a block. At the default tempo each act is its own beat; at 10, 30 or 60 seconds, acts are cued and
   land together on the next beat; on manual they wait for *Beat now*. The slider and *Replay* show a holding as it
   stood at any beat.
@@ -16,8 +17,10 @@ chain itself records who did what, and when.
   every active holding mines, and each beat's 50 test BTC splits pro rata by hashrate, a dial from 0 to 9 on each
   holding (1 unless set), one coinbase output per holding; under *Last act* the holding behind the latest act or send
   takes the whole beat (with nothing cued, *Beat now* pays the one being worked in), so at a timed tempo acts race
-  for the next beat. **Send** moves test BTC from any active node to any other, in
-  its holding or another, signed by the sender's BIP-84 key: at most two coins in, at most 50 test BTC out, and the
+  for the next beat; under *Mainnet* no holding mines, as on mainnet: beats pay the lab wallet, standing in for the
+  world's miners, and **Fund** moves test BTC from it to a holding, the way you'd fund a seed from a wallet you
+  already have. **Send** moves test BTC from any active node to any other, in
+  its holding or another, signed by the sender's BIP-84 key: at most eight coins in, at most 50 test BTC out, and the
   toy chain's fixed 500-sat fee. Sends land like acts, at once or cued, and *Beat now* mines a beat even when nothing
   is cued. A graduation moves each re-keyed node's money to its new address along with its inscription. Balances
   follow the slider, the timeline lists every reward, send and gas top-up, and Inspect has the exact amounts and the
@@ -27,6 +30,13 @@ chain itself records who did what, and when.
   up from its own money 0.0001 test BTC at a time. A node with neither can't act until someone sends it money, and a
   graduating org pays for the claim on its new root itself. The lab wallet pays only for foundings (a holding owns
   nothing until it mines) and for holdings that predate lab keys.
+- **Deals.** Any active node can **Offer** on an item another node holds, in any holding: OpenOrdex's buy order, with
+  a price. Its SegWit key signs the whole deal at once (SIGHASH_ALL): the item and its own coins in; the item to its
+  Taproot key, the price to the holder's SegWit address and its change out. Nothing reaches the chain until the
+  holder **Accepts** by countersigning the item's input, so the offer stands, kept in the lab like a PSBT in an
+  order book, until it is accepted, withdrawn, or goes stale (a coin it promised moved, or a side closed or re-keyed).
+  The buyer pays the fee; a price of 0 is a free claim. Payments spend coins no offer has promised first. Accepted
+  offers stay as the deals' receipts, and the timeline and Inspect show each deal (`src/orgchain/offers.js`).
 - **One interpretation.** `src/orgchain/lineage.js` folds `lineage/v0` events into trees, and vets every act before
   anything is signed. Events it rejects stay on the chain and show as rejected; they just don't change the tree.
 - **Keys.** Each holding gets its own 24-word lab root, and every node has lineage's keys at its place in the tree
@@ -46,8 +56,9 @@ chain itself records who did what, and when.
   BIP-380 checksums), and its leaves' private keys (OpenSSH, DKIM, WireGuard, PKCS#8, Headscale). Hidden again on
   every selection; lab keys only.
 
-Test coins and test keys only: a local chain, the lab wallet (the faucet that pays for foundings) and each holding's lab
-root, kept in this browser (`localStorage`, key `orgchain:lab:v1`). Nothing here is a real key; minting a real root is
+Test coins and test keys only: a local chain, the lab wallet (the faucet that pays for foundings, and under *Mainnet*
+the wallet holdings are funded from) and each holding's lab root, kept in this browser (`localStorage`, key
+`orgchain:lab:v1`). Nothing here is a real key; minting a real root is
 the operator's call.
 
 ## Events
@@ -60,11 +71,14 @@ the operator's call.
 | `birth` | the parent | `name`, `kind` (`org` or `agent`) |
 | `award` | the issuing org or holding | `to`, `skill`, `belt` (`white`, `green`, `black`) |
 | `decide` | the deciding node | `title`, `why` |
+| `make` | the making node, which then holds the item | `name`, `note` |
 | `graduate` | the child's parent (then the handoff to the child's fresh root) | `of` |
 | `close` | the node itself | none |
 
 Names are domain labels (lowercase letters, digits, hyphens). Org and agent indices count separately and are never
-reused.
+reused. The metadata says what an event means; the parent it spends proves who was allowed to make it; who holds an
+item afterwards is the chain's to say, never the metadata's. Metadata is public and permanent: an item's note is for a
+hash or a link, never a secret or a document.
 
 ## Build and test
 
@@ -83,9 +97,11 @@ Deploy: copy `dist/` to `ventures/lineage/orgchain/` on `teahubxyz/time` `gh-pag
 ## Built on Super Testnet
 
 The chain, wallet, inscriptions, metadata and index (`src/adapters`, `src/upstream`, with `src/storage.js` and
-`src/miner.js`) are [Super Testnet](https://supertestnet.lol)'s, with their tests (`tests/adapters.test.js`) and two
-additions: the chain also moves native SegWit (P2WPKH) payments, BIP-143 signatures included, and a coinbase may
-split its reward across up to 64 outputs (`tests/money.test.js`).
+`src/miner.js`) are [Super Testnet](https://supertestnet.lol)'s, with their tests (`tests/adapters.test.js`) and three
+additions: the chain also moves native SegWit (P2WPKH) payments, BIP-143 signatures included; a coinbase may split
+its reward across up to 64 outputs; and ordinary spends take up to eight inputs and outputs, whose key-path
+signatures may carry SIGHASH_SINGLE|ANYONECANPAY (0x83, the sell-order flag), while reveals keep their two-in,
+two-out shape (`tests/money.test.js`).
 See `PROVENANCE.md` and `public/licenses/`. Lineage's key derivation and the claim and
 countersign handoff (`src/adapters/lineage-keys.js`, `src/adapters/handoff.js`, with their spec vectors in
 `tests/keys.test.js`) come from the `tree` branch. The full lab (explorer, delegates, recursion and
diff --git a/index.html b/index.html
index 8b8023d..629b981 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
 <title>Orgchain · Lineage</title>
-<meta name="description" content="Found and operate lineage holdings on a toy chain in your browser: birth orgs and agents, award belts, decide, send test BTC, graduate and close, one beat at a time. Test coins only.">
+<meta name="description" content="Found and operate lineage holdings on a toy chain in your browser: birth orgs and agents, award belts, decide, make and trade items, send test BTC, graduate and close, one beat at a time. Test coins only.">
 <meta name="color-scheme" content="light dark">
 <link rel="icon" href="./favicon.svg" type="image/svg+xml">
 <script src="./theme.js"></script>
@@ -16,7 +16,7 @@
     <div>
       <p class="kicker"><a href="../">Lineage</a> /</p>
       <h1 class="wordmark">Orgchain</h1>
-      <p class="lede">Found a <b>holding</b>, then birth its orgs and agents, award belts, record decisions, send test BTC, graduate and close. Each act is an inscription whose parent is the node that authorizes it, paid for with the actor's own gas, and each <b>beat</b> is a block whose 50 test BTC the holdings mine. Lineage gives the structure; the chain adds time.</p>
+      <p class="lede">Found a <b>holding</b>, then birth its orgs and agents, award belts, record decisions, make and trade items, send test BTC, graduate and close. Each act is an inscription whose parent is the node that authorizes it, paid for with the actor's own gas, and each <b>beat</b> is a block whose 50 test BTC the holdings mine. Lineage gives the structure; the chain adds time.</p>
     </div>
     <div class="flags">
       <span class="flag hz">Test coins only</span>
@@ -53,8 +53,15 @@
         <div class="pad empty" id="holdings-empty"><p>A holding is the root of a lineage tree: the LLC that births orgs and agents. Found one, or load the sample, the yolopreneur tree from the Lineage docs over six beats.</p></div>
         <div class="pad mining" id="mining">
           <div class="mrow"><span class="lab" id="mining-l">Mining</span>
-            <div class="tempo" role="group" aria-labelledby="mining-l"><button type="button" class="seg" data-rule="split" aria-pressed="true">Split</button><button type="button" class="seg" data-rule="last" aria-pressed="false">Last act</button></div></div>
+            <div class="tempo" role="group" aria-labelledby="mining-l"><button type="button" class="seg" data-rule="split" aria-pressed="true">Split</button><button type="button" class="seg" data-rule="last" aria-pressed="false">Last act</button><button type="button" class="seg" data-rule="none" aria-pressed="false">Mainnet</button></div></div>
           <p class="hint" id="mining-note"></p>
+          <form class="fund" id="f-fund" autocomplete="off" hidden>
+            <label class="lab" for="fund-to">Fund a holding</label>
+            <select id="fund-to" name="to"></select>
+            <label class="lab" for="fund-amount">Amount <span>test BTC</span></label>
+            <div class="line"><input id="fund-amount" name="amount" inputmode="decimal" maxlength="17" spellcheck="false" placeholder="5"><button class="btn primary" type="submit">Fund</button></div>
+            <p class="hint">From the lab wallet, which has <b id="fund-has"></b> and pays the 500-sat fee. At most 50 test BTC at a time.</p>
+          </form>
         </div>
         <form class="pad found" id="f-found" autocomplete="off">
           <label class="lab" for="found-name">Found a holding</label>
@@ -81,7 +88,7 @@
           <p class="pad note" id="act-none">Select a holding, or a node in its tree, to act through it.</p>
           <div class="pad note" id="act-past" hidden><p>You are looking at beat <b id="past-beat"></b>. History is read-only.</p><button type="button" class="btn sm" id="past-now">Back to now</button></div>
           <div id="act-on" hidden>
-            <div class="verbs" role="group" aria-label="Verb"><button type="button" data-verb="birth" aria-pressed="true">Birth</button><button type="button" data-verb="award" aria-pressed="false">Award</button><button type="button" data-verb="decide" aria-pressed="false">Decide</button><button type="button" data-verb="send" aria-pressed="false">Send</button><button type="button" data-verb="graduate" aria-pressed="false">Graduate</button><button type="button" data-verb="close" aria-pressed="false">Close</button></div>
+            <div class="verbs" role="group" aria-label="Verb"><button type="button" data-verb="birth" aria-pressed="true">Birth</button><button type="button" data-verb="award" aria-pressed="false">Award</button><button type="button" data-verb="decide" aria-pressed="false">Decide</button><button type="button" data-verb="make" aria-pressed="false">Make</button><button type="button" data-verb="send" aria-pressed="false">Send</button><button type="button" data-verb="offer" aria-pressed="false">Offer</button><button type="button" data-verb="graduate" aria-pressed="false">Graduate</button><button type="button" data-verb="close" aria-pressed="false">Close</button></div>
             <p class="keyline" id="act-key"></p>
             <p class="keyline" id="act-gas"></p>
             <p class="why pad" id="act-why"></p>
@@ -114,15 +121,33 @@
               <textarea id="decide-why" name="why" maxlength="400" rows="3"></textarea>
               <button class="btn primary go" type="submit">Decide</button>
             </form>
+            <form class="vf pad" id="f-make" data-form="make" autocomplete="off" hidden>
+              <p class="vh"><b data-name></b> makes an item: an inscription it holds, and can sell. The making spends <b data-name></b>'s inscription.</p>
+              <label class="lab" for="make-name">Name</label>
+              <input id="make-name" name="name" maxlength="60" spellcheck="false" placeholder="launch-kit">
+              <label class="lab" for="make-note">Note <span>optional</span></label>
+              <textarea id="make-note" name="note" maxlength="280" rows="2"></textarea>
+              <p class="hint">The name and note are public and permanent, like all inscription metadata: put a hash or a link here, never a secret or a document.</p>
+              <button class="btn primary go" type="submit">Make</button>
+            </form>
             <form class="vf pad" id="f-send" data-form="send" autocomplete="off" hidden>
               <p class="vh"><b data-name></b> sends test BTC from its SegWit address. It has <b id="send-has"></b>.</p>
               <label class="lab" for="send-to">To</label>
               <select id="send-to" name="to"></select>
               <label class="lab" for="send-amount">Amount <span>test BTC</span></label>
               <div class="line amt"><input id="send-amount" name="amount" inputmode="decimal" maxlength="17" spellcheck="false" placeholder="1.5"><button class="btn" type="button" id="send-max">Max</button></div>
-              <p class="hint">The sender pays the chain's 500-sat fee. One send spends at most two coins and moves at most 50 test BTC, one block reward.</p>
+              <p class="hint">The sender pays the chain's 500-sat fee. One send spends at most eight coins and moves at most 50 test BTC, one block reward.</p>
               <button class="btn primary go" type="submit">Send</button>
             </form>
+            <form class="vf pad" id="f-offer" data-form="offer" autocomplete="off" hidden>
+              <p class="vh"><b data-name></b> bids on an item another node holds. It has <b id="offer-has"></b>.</p>
+              <label class="lab" for="offer-item">Item</label>
+              <select id="offer-item" name="lot"></select>
+              <label class="lab" for="offer-price">Price <span>test BTC, or 0 for a free claim</span></label>
+              <input id="offer-price" name="price" inputmode="decimal" maxlength="17" spellcheck="false" placeholder="0.1">
+              <p class="hint">Its SegWit key signs the whole deal now: the item to its Taproot key, the price to the holder, the 500-sat fee from its balance. Nothing reaches the chain until the holder accepts. Until then the offer stands, unless it's withdrawn or a coin it promised moves.</p>
+              <button class="btn primary go" type="submit">Offer</button>
+            </form>
             <form class="vf pad" id="f-graduate" data-form="graduate" hidden>
               <p class="vh"><b data-parent></b> vouches for <b data-name></b>, and the edge flips from derived to adopted. A graduated org holds its own root, so it stays open if <b data-parent></b> closes. The event spends <b data-parent></b>'s inscription.</p>
               <button class="btn primary go" type="submit" id="graduate-go">Graduate</button>
diff --git a/src/adapters/chain.js b/src/adapters/chain.js
index 688b633..959fee4 100644
--- a/src/adapters/chain.js
+++ b/src/adapters/chain.js
@@ -14,11 +14,14 @@ const hash = value => bytesToHex(sha256(new TextEncoder().encode(JSON.stringify(
 const key = (txid, vout) => `${txid}:${vout}`;
 const scriptHex = script => Script.encode(script, false).hex;
 const assert = (condition, message) => { if (!condition) throw new Error(message); };
-// Orgchain's two additions to the engine: native SegWit (P2WPKH) outputs and SIGHASH_ALL spends (BIP-143), so lineage
-// accounts are paid at their BIP-84 addresses, and a coinbase that may split its reward across up to MAX_PAYOUTS
-// outputs, so one beat can pay several holdings. Inscriptions, their parents and their handoffs stay Taproot.
+// Orgchain's additions to the engine: native SegWit (P2WPKH) outputs and SIGHASH_ALL spends (BIP-143), so lineage
+// accounts are paid at their BIP-84 addresses; a coinbase that may split its reward across up to MAX_PAYOUTS outputs,
+// so one beat can pay several holdings; and, for deals, ordinary spends of up to MAX_IO inputs and outputs, whose
+// key-path signatures may carry SIGHASH_SINGLE|ANYONECANPAY (0x83, the sell-order flag). Reveals keep their two-in,
+// two-out shape. Inscriptions, their parents and their handoffs stay Taproot.
 const TAPROOT = /^5120[0-9a-f]{64}$/, P2WPKH = /^0014[0-9a-f]{40}$/;
 export const MAX_PAYOUTS = 64;
+export const MAX_IO = 8;
 const hash160 = hex => bytesToHex(ripemd160(sha256(hexToBytes(hex))));
 // The BIP-143 digest commits to the spent key's P2PKH script code and the coin's value; low-S DER only.
 function segwitValid(tx, i) {
@@ -50,7 +53,9 @@ export class LocalChain {
     const tx = Tx.decode(raw), txid = Tx.util.getTxid(tx);
     assert(!this.transactions.has(txid), 'Duplicate transaction.');
     assert(tx.version === 2 && tx.locktime === 0, 'Unsupported transaction version or locktime.');
-    assert((tx.vin.length === 1 || (!coinbase && tx.vin.length === 2)) && tx.vout.length >= 1 && tx.vout.length <= (coinbase ? MAX_PAYOUTS : 2), 'Unsupported transaction shape.');
+    const reveal = !coinbase && tx.vin.some(i => i.witness?.length === 3);
+    const ins = coinbase ? 1 : reveal ? 2 : MAX_IO, outs = coinbase ? MAX_PAYOUTS : reveal ? 2 : MAX_IO;
+    assert(tx.vin.length >= 1 && tx.vin.length <= ins && tx.vout.length >= 1 && tx.vout.length <= outs, 'Unsupported transaction shape.');
     let total = 0;
     for (const output of tx.vout) {
       const value = Number(output.value);
@@ -83,7 +88,8 @@ export class LocalChain {
           return;
         }
         assert(input.witness?.length === 1 || (i === scriptInput && input.witness?.length === 3), 'Unsupported witness.');
-        assert(/^[0-9a-f]{128}$/.test(input.witness[0]), 'Only default 64-byte Schnorr signatures are accepted.');
+        assert(/^[0-9a-f]{128}$/.test(input.witness[0]) || (!reveal && /^[0-9a-f]{128}83$/.test(input.witness[0])),
+          'Only default 64-byte Schnorr signatures, or SIGHASH_SINGLE|ANYONECANPAY outside reveals, are accepted.');
       });
       assert(coins.reduce((sum, c) => sum + c.value, 0) - total === FEE, 'v0 requires a fixed 500 sat fee per transaction.');
       let config = {};
diff --git a/src/main.js b/src/main.js
index 4affa50..d12dbdf 100644
--- a/src/main.js
+++ b/src/main.js
@@ -4,9 +4,10 @@ import './orgchain.css';
 import { MetadataIndex } from './adapters/metadata-index.js';
 import { census, lineageEvents, reduce, rows, slug, summary, trail } from './orgchain/lineage.js';
 import { LAB_KEY, beat, decodeLab, emptyLab, encodeLab, mutate, readLab, setRigs, setRule, setTempo, tick } from './orgchain/store.js';
-import { SAMPLE, act, gasCheck, gasCost, lastHolding, minerOf, send, seedSample } from './orgchain/actions.js';
+import { SAMPLE, accept, act, deposit, gasCheck, gasCost, lastHolding, minerOf, offer, send, seedSample, withdraw } from './orgchain/actions.js';
 import { addressesOf, derivedSubtree, holderOf, keyOf, leavesOf, secretsOf } from './orgchain/keys.js';
 import { DUST, FEE, balances, brief, btc, coins, ledger, miners, most, owners, payerOf, rigsOf, satsOf, tankOf, tanks } from './orgchain/money.js';
+import { holderOfItem, offerStatus, offerWhy } from './orgchain/offers.js';
 import { readEnvelope } from './adapters/inscription.js';
 
 const $ = id => document.getElementById(id);
@@ -32,10 +33,15 @@ const ui = { holding: null, node: null, event: null, tx: null, beat: null, verb:
 let lab = emptyLab(), index = new MetadataIndex(lab.chain), events = [], live = reduce([]), view = live;
 // The money (orgchain/money.js): whose each SegWit script is, every move in chain order, and balances now and as viewed.
 let money = { owner: new Map(), ledger: [], now: new Map(), view: new Map() };
+// Who holds each item now (orgchain/offers.js): a node's id, or null when no node in this lab does.
+let holders = new Map();
 const tip = () => lab.chain.blocks.length;
 const cuedActs = () => events.filter(e => e.status === 'pending').length;
-const cuedSends = () => money.ledger.filter(m => m.beat === null && m.kind === 'pay').length;
-const cued = () => cuedActs() + cuedSends();
+const cuedMoney = kind => money.ledger.filter(m => m.beat === null && m.kind === kind).length;
+const CUED = [['pay', 'cued send'], ['deal', 'cued deal'], ['fund', 'cued deposit']];
+const cued = () => cuedActs() + CUED.reduce((sum, [kind]) => sum + cuedMoney(kind), 0);
+const itemName = id => live.items.get(id)?.name ?? 'an item';
+const offers = () => lab.offers ?? [];
 const purse = id => money.view.get(id) ?? 0; // a balance at the viewed beat
 const held = id => money.now.get(id) ?? 0; // a balance now, cued sends included
 const node = (id, state = live) => (id ? state.nodes.get(id) ?? null : null);
@@ -58,8 +64,9 @@ function derive() {
   if (!node(ui.node) || node(ui.node).root !== ui.holding) ui.node = ui.holding;
   if (ui.event && !live.log.some(e => e.id === ui.event)) ui.event = null;
   view = ui.beat === null ? live : reduce(events, { upTo: ui.beat });
-  const owner = owners(lab.keys, events, live);
-  money = { owner, ledger: ledger(lab.chain, owner, tanks(lab.keys, events, live)), now: balances(lab.chain, owner) };
+  const owner = owners(lab.keys, events, live), deals = new Map(offers().map(o => [o.txid, o]));
+  money = { owner, ledger: ledger(lab.chain, owner, tanks(lab.keys, events, live), deals), now: balances(lab.chain, owner) };
+  holders = new Map([...live.items.keys()].map(id => [id, holderOfItem(lab, events, live, id)?.node.id ?? null]));
   money.view = ui.beat === null ? money.now : balances(lab.chain, owner, ui.beat);
   if (ui.tx && !money.ledger.some(m => m.key === ui.tx)) ui.tx = null;
   render();
@@ -91,9 +98,10 @@ async function perform(op, by, fields, done) {
 }
 // Run something that may beat, then say what the beat landed and whom it paid.
 async function landCue(action) {
-  const acts = cuedActs(), sends = cuedSends(), height = tip();
+  const before = [cuedActs(), ...CUED.map(([kind]) => cuedMoney(kind))], height = tip();
   if (!(await run(action)) || tip() === height) return;
-  const landed = [[acts - cuedActs(), 'cued act'], [sends - cuedSends(), 'cued send']].filter(([n]) => n > 0).map(([n, w]) => plural(n, w));
+  const after = [cuedActs(), ...CUED.map(([kind]) => cuedMoney(kind))], words = ['cued act', ...CUED.map(([, w]) => w)];
+  const landed = before.map((n, i) => [n - after[i], words[i]]).filter(([n]) => n > 0).map(([n, w]) => plural(n, w));
   const earned = earnings(money.ledger.filter(x => x.kind === 'mine' && x.beat === tip()));
   say(`Beat ${tip()}: ${landed.length ? `${landed.join(' and ')} landed, and ${earned}` : earned}.`);
 }
@@ -130,8 +138,13 @@ function cueNote() {
   return 'landing on the next beat';
 }
 
+const NOTES = {
+  split: "Every active holding mines: each beat's 50 tBTC splits by hashrate, set on each holding (0 sits out).",
+  last: "The holding behind the latest act or send takes the whole beat; with nothing cued, Beat now pays the one you're working in. At a timed tempo it's a race for the next beat.",
+  none: "Mainnet has no mining to join: beats pay the lab wallet, standing in for the world's miners. Fund a holding from it, the way you'd fund a seed from a wallet you already have.",
+};
 function renderHoldings() {
-  const split = lab.mining?.rule !== 'last', mining = split ? miners(lab, live) : [], total = mining.reduce((sum, r) => sum + rigsOf(lab, r.id), 0);
+  const rule = lab.mining?.rule ?? 'split', split = rule === 'split', mining = split ? miners(lab, live) : [], total = mining.reduce((sum, r) => sum + rigsOf(lab, r.id), 0);
   $('holdings-list').replaceChildren(...live.roots.map(r => {
     const c = census(live, r.id), on = r.id === ui.holding, active = r.status === 'active', share = mining.some(x => x.id === r.id) ? rigsOf(lab, r.id) / total : 0;
     const worth = [...live.nodes.values()].reduce((sum, x) => sum + (x.root === r.id ? held(x.id) : 0), 0);
@@ -141,9 +154,13 @@ function renderHoldings() {
       onclick: () => pick({ holding: r.id, node: r.id }) }, h('span', { class: 'hn', text: r.name }), ' ', h('span', { class: 'hm', text: facts.join(' · ') })),
     split && active && payerOf(lab.keys, live, r) && rigView(r, rigsOf(lab, r.id)));
   }));
-  for (const b of document.querySelectorAll('[data-rule]')) b.setAttribute('aria-pressed', String((lab.mining?.rule ?? 'split') === b.dataset.rule));
-  $('mining-note').textContent = split ? "Every active holding mines: each beat's 50 tBTC splits by hashrate, set on each holding (0 sits out)."
-    : "The holding behind the latest act or send takes the whole beat; with nothing cued, Beat now pays the one you're working in. At a timed tempo it's a race for the next beat.";
+  for (const b of document.querySelectorAll('[data-rule]')) b.setAttribute('aria-pressed', String(rule === b.dataset.rule));
+  $('mining-note').textContent = NOTES[rule];
+  const fundable = live.roots.filter(r => r.status === 'active' && payerOf(lab.keys, live, r)), to = $('fund-to'), keep = to.value;
+  $('f-fund').hidden = rule !== 'none' || !fundable.length || ui.beat !== null;
+  to.replaceChildren(...fundable.map(r => h('option', { value: r.id, text: r.name })));
+  to.value = fundable.some(r => r.id === keep) ? keep : fundable.some(r => r.id === ui.holding) ? ui.holding : fundable[0]?.id ?? '';
+  $('fund-has').textContent = btc(lab.wallet ? tankOf(lab.chain, lab.wallet) : 0);
   $('holdings-empty').hidden = live.roots.length > 0;
   $('holdings-sub').textContent = live.roots.length ? String(live.roots.length) : '';
   $('sample').disabled = live.roots.some(r => r.name === SAMPLE && r.status === 'active');
@@ -200,13 +217,26 @@ const everyone = n => [...live.nodes.values()].filter(x => x.id !== n.id && x.st
   .map(x => [x, (x.root === n.root ? 0 : 4) + (below(x, n) ? 0 : 2) + (x.kind === 'agent' ? 0 : 1)]).sort((a, b) => a[1] - b[1]).map(([x]) => x);
 // Why n cannot send now ('' when it can).
 function sendBlock(n) {
-  const wallet = payerOf(lab.keys, live, n), parent = node(n.parent);
+  const wallet = payerOf(lab.keys, live, n);
   if (!wallet) return 'This holding predates lab keys, so it has no SegWit address to send from';
-  if (most(lab.chain.coins(wallet.script)) < DUST) {
-    return parent ? `${n.name} has no test BTC to send yet. ${parent.name} can send some` : `${n.name} has no test BTC yet. It earns some each beat it mines`;
-  }
+  if (most(lab.chain.coins(wallet.script)) < DUST) return broke(n, 'to send');
   return everyone(n).length ? '' : 'There is nobody else to send to yet';
 }
+// "ops has no test BTC to send yet. acme can send some"
+function broke(n, what) {
+  const parent = node(n.parent);
+  return `${n.name} has no test BTC ${what} yet. ${parent ? `${parent.name} can send some` : lab.mining?.rule === 'none' ? 'Fund it from the lab wallet' : 'It earns some each beat it mines'}`;
+}
+// Items other active nodes hold: what n can bid on, those in its own holding first.
+const biddable = n => [...live.items.values()].map(it => [it, node(holders.get(it.id))]).filter(([, x]) => x && x.id !== n.id && x.status === 'active')
+  .sort((a, b) => (a[1].root === n.root ? 0 : 1) - (b[1].root === n.root ? 0 : 1)).map(([it]) => it);
+// Why n cannot make an offer now ('' when it can). The buyer pays the deal's fee, so a free claim still needs coins.
+function offerBlock(n) {
+  const wallet = payerOf(lab.keys, live, n);
+  if (!wallet) return 'This holding predates lab keys, so it has no SegWit address to pay from';
+  if (!biddable(n).length) return 'Nobody else holds an item yet. Items come from Make';
+  return lab.chain.coins(wallet.script).some(c => c.value >= FEE + DUST || c.value === FEE) ? '' : broke(n, 'to pay with');
+}
 // Why a verb is unavailable for this node ('' when it is available). The reducer has the final word.
 function blocked(n) {
   const parent = node(n.parent), closed = n.status === 'closed' ? `${n.name} is closed` : '';
@@ -215,7 +245,9 @@ function blocked(n) {
     birth: closed || (n.kind === 'agent' ? 'Agents do not give birth' : gas('birth')),
     award: closed || (n.kind === 'agent' ? 'Agents do not award belts' : recipients(n).length ? gas('award') : 'There is nobody else in this holding to award yet'),
     decide: closed || gas('decide'),
+    make: closed || gas('make'),
     send: closed || sendBlock(n),
+    offer: closed || offerBlock(n),
     graduate: closed || (!parent ? 'A holding has no parent to graduate from' : n.kind !== 'org' ? 'Only orgs graduate'
       : n.edge === 'adopted' ? `${n.name} has already graduated` : parent.status !== 'active' ? `${parent.name} is closed` : gas('graduate', parent.id, { of: n.id })),
     close: closed || gas('close'),
@@ -239,17 +271,21 @@ function renderAct() {
   for (const el of document.querySelectorAll('#act-on [data-name]')) el.textContent = n.name;
   for (const el of document.querySelectorAll('#act-on [data-parent]')) el.textContent = parent?.name ?? '';
   const sig = list => list.map(o => `${o.value}=${o.textContent}`).join('|');
-  for (const [to, list] of [[$('award-to'), recipients(n)], [$('send-to'), everyone(n)]]) {
-    const keep = to.value, options = list.map(x => h('option', { value: x.id, text: `${trail(live, x.id)}${x.kind === 'agent' ? ' (agent)' : ''}` }));
+  const lists = [[$('award-to'), recipients(n).map(x => [x.id, `${trail(live, x.id)}${x.kind === 'agent' ? ' (agent)' : ''}`])],
+    [$('send-to'), everyone(n).map(x => [x.id, `${trail(live, x.id)}${x.kind === 'agent' ? ' (agent)' : ''}`])],
+    [$('offer-item'), biddable(n).map(it => [it.id, `${it.name} · held by ${whose(holders.get(it.id))}`])]];
+  for (const [to, list] of lists) {
+    const keep = to.value, options = list.map(([value, text]) => h('option', { value, text }));
     if (sig(options) !== sig([...to.options])) { to.replaceChildren(...options); if (options.some(o => o.value === keep)) to.value = keep; }
   }
-  $('send-has').textContent = btc(held(n.id));
+  for (const id of ['send-has', 'offer-has']) $(id).textContent = btc(held(n.id));
   $('graduate-go').textContent = `Graduate ${n.name}`;
   const signer = ui.verb === 'graduate' ? parent : n, k = signer && keyOf(lab.keys, live, signer);
-  const path = k && (ui.verb === 'send' ? `${k.from} · ${payerOf(lab.keys, live, signer).path}` : k.path);
+  const pays = ui.verb === 'send' || ui.verb === 'offer', path = k && (pays ? `${k.from} · ${payerOf(lab.keys, live, signer).path}` : k.path);
   $('act-key').textContent = !signer || why[ui.verb] ? '' : k ? `Signs as ${signer.name}: ${path}` : 'Signs with the lab wallet: this holding predates lab keys.';
   const moving = ui.verb === 'graduate' && keyOf(lab.keys, live, n) ? derivedSubtree(live, n.id).length : 0;
   $('act-gas').textContent = !signer || why[ui.verb] || !k ? '' : ui.verb === 'send' ? `Fee: ${FEE} sats, from ${n.name}'s balance.`
+    : ui.verb === 'offer' ? `Fee: ${FEE} sats, from ${n.name}'s balance, paid only if the holder accepts.`
     : `Gas: ${gasCost(ui.verb, moving).toLocaleString('en-US')} sats from ${signer.name}'s tank (${btc(tankOf(lab.chain, k.wallet))}), which tops up from its balance.${moving ? ` ${n.name} pays ${FEE} more, from its own money, to claim its new root.` : ''}`;
   const below = derivedBelow(n), arming = ui.closing === n.id;
   $('close-note').textContent = below
@@ -294,9 +330,46 @@ function nodeView(n) {
         h('li', {}, belt(b), h('span', { class: 'when', text: ` from ${node(b.by)?.name ?? '?'}, ${at(b.beat)}` }))))),
       n.decisions.length > 0 && h('div', {}, h('p', { class: 'lab', text: 'Decisions' }), h('ul', { class: 'list' }, n.decisions.map(d =>
         h('li', {}, h('b', { text: d.title }), d.why && ` · ${d.why}`, h('span', { class: 'when', text: ` (${at(d.beat)})` }))))),
-      moneyView(n), keysView(n)),
+      itemsView(n), moneyView(n), keysView(n)),
   ];
 }
+// What a node made and holds: items with the open offers on them, which it can accept, and its own bids, which it can
+// withdraw. At a past beat, only what it had made by then.
+function itemsView(n) {
+  const list = (label, items) => items.length > 0 && h('div', {}, h('p', { class: 'lab', text: label }), h('ul', { class: 'list items' }, items));
+  const line = (it, more) => h('li', {}, h('b', { text: it.name }), it.note && ` · ${it.note}`, h('span', { class: 'when', text: ` (${more})` }));
+  if (ui.beat !== null) return list('Made', n.made.map(id => view.items.get(id)).filter(Boolean).map(it => line(it, at(it.beat))));
+  const made = it => `made${it.maker === n.id ? '' : ` by ${whose(it.maker)}`}${it.beat === 'cued' ? ', cued' : ` at beat ${it.beat}`}`;
+  const held = [...live.items.values()].filter(it => holders.get(it.id) === n.id).map(it => {
+    const li = line(it, made(it)), bids = offers().filter(o => o.item === it.id && o.seller === n.id && offerStatus(lab, live, o) === 'open');
+    if (bids.length) {
+      li.append(h('ul', { class: 'bids' }, bids.map(o => h('li', {}, h('span', { text: `${whose(o.buyer)} offers ${o.price ? btc(o.price) : 'nothing, a free claim'}` }),
+        n.status === 'active' && h('button', { type: 'button', class: 'btn sm', 'aria-label': `Accept ${whose(o.buyer)}'s offer for ${it.name}`, onclick: () => acceptDeal(o) }, 'Accept')))));
+    }
+    return li;
+  });
+  const gone = n.made.map(id => live.items.get(id)).filter(it => it && holders.get(it.id) !== n.id)
+    .map(it => line(it, holders.get(it.id) ? `now held by ${whose(holders.get(it.id))}` : 'held outside this lab'));
+  const mine = offers().filter(o => o.buyer === n.id && offerStatus(lab, live, o) !== 'done').map(o => {
+    const why = offerWhy(lab, live, o);
+    return h('li', {}, h('b', { text: o.price ? btc(o.price) : 'nothing' }), ` for ${itemName(o.item)}`,
+      h('span', { class: 'when', text: why ? ` (stale: ${why})` : ` (open until ${whose(o.seller)} accepts)` }),
+      h('button', { type: 'button', class: 'btn sm', 'aria-label': `Withdraw the offer for ${itemName(o.item)}`, onclick: () => withdrawDeal(o) }, 'Withdraw'));
+  });
+  return [list('Items', held), list('Made, held elsewhere', gone), list('Offers made', mine)];
+}
+// A node's name, with its trail when it sits in another holding.
+const whose = id => { const x = node(id); return !x ? '?' : x.root === ui.holding ? x.name : trail(live, id); };
+async function acceptDeal(o) {
+  const item = itemName(o.item), buyer = whose(o.buyer), seller = whose(o.seller);
+  if (!(await run(l => { accept(l, o.txid); }))) return;
+  const m = money.ledger.find(x => x.txid === o.txid);
+  say(`${seller} accepted: ${item} goes to ${buyer}${o.price ? ` for ${btc(o.price)}` : ', free'}, ${m?.beat ? `at beat ${m.beat}` : 'cued for the next beat'}.`);
+}
+async function withdrawDeal(o) {
+  const item = itemName(o.item), buyer = whose(o.buyer);
+  if (await run(l => { withdraw(l, o.txid); })) say(`${buyer} withdrew its offer for ${item}.`);
+}
 // A node's latest money moves, as of the viewed beat.
 function moneyView(n) {
   const list = money.ledger.filter(m => (m.to === n.id || m.from === n.id) && (ui.beat === null || (m.beat !== null && m.beat <= ui.beat))).slice(-6).reverse();
@@ -309,6 +382,12 @@ function flow(m, id) {
   if (m.kind === 'mine') return `+${btc(m.amount)}, a beat's reward`;
   if (m.kind === 'move') return `${btc(m.amount)} moved to its new key, after a ${m.fee}-sat fee`;
   if (m.kind === 'gas') return `−${btc(m.amount)} into its gas tank, and a ${m.fee}-sat fee`;
+  if (m.kind === 'fund') return `+${btc(m.amount)} from the lab wallet`;
+  if (m.kind === 'deal') {
+    const item = itemName(m.item);
+    if (m.to === id) return m.amount ? `+${btc(m.amount)} from ${name(m.from)} for ${item}` : `${item} to ${name(m.from)}, free`;
+    return m.amount ? `−${btc(m.amount)} to ${name(m.to)} for ${item}, and a ${m.fee}-sat fee` : `${item} from ${name(m.to)}, free but for a ${m.fee}-sat fee`;
+  }
   return m.to === id ? `+${btc(m.amount)} from ${name(m.from)}` : `−${btc(m.amount)} to ${name(m.to)}, and a ${m.fee}-sat fee`;
 }
 // "40 tBTC yolopreneur → time"
@@ -317,6 +396,8 @@ function moneyLine(m) {
   if (m.kind === 'mine') return `${btc(m.amount)} → ${name(m.to)}`;
   if (m.kind === 'move') return `${btc(m.amount)} → ${name(m.to)}'s new key`;
   if (m.kind === 'gas') return `${btc(m.amount)} → ${name(m.to)}'s gas tank`;
+  if (m.kind === 'fund') return `${btc(m.amount)} lab wallet → ${name(m.to)}`;
+  if (m.kind === 'deal') return `${itemName(m.item)} ${name(m.to)} → ${name(m.from)}, ${m.amount ? `for ${btc(m.amount)}` : 'free'}`;
   return `${btc(m.amount)} ${name(m.from)} → ${name(m.to)}`;
 }
 // Lineage's keys for a node as of the viewed beat: its Taproot, SegWit and nostr addresses, where they come from, who
@@ -401,14 +482,20 @@ function eventView(e) {
 // A money move: a beat's reward, a send, or money following a node to its new keys.
 function txView(m) {
   const name = id => node(id)?.name ?? 'a key outside this lab', record = lab.chain.transactions.get(m.txid);
+  const deal = m.kind === 'deal', fund = m.kind === 'fund';
   const facts = [
     ['When', m.beat === null ? 'cued for the next beat' : `beat ${m.beat}`],
-    ['From', m.kind === 'mine' ? "its share of the beat's block reward (the coinbase)" : `${name(m.from)}'s SegWit address${m.kind === 'move' ? ', from before it graduated' : ''}`],
-    ['To', m.kind === 'gas' ? `${name(m.to)}'s gas tank, at its Taproot key` : `${name(m.to)}'s ${m.kind === 'move' ? 'new ' : ''}SegWit address`],
-    ['Amount', btc(m.amount)],
+    deal && ['Item', `${itemName(m.item)}, an inscription: from ${name(m.to)}'s Taproot key to ${name(m.from)}'s`],
+    ['From', m.kind === 'mine' ? "its share of the beat's block reward (the coinbase)" : fund ? 'the lab wallet, standing in for a wallet you already have'
+      : `${name(m.from)}'s SegWit address${m.kind === 'move' ? ', from before it graduated' : ''}`],
+    ['To', m.kind === 'gas' ? `${name(m.to)}'s gas tank, at its Taproot key` : deal && !m.amount ? 'nobody: a free claim pays no price'
+      : `${name(m.to)}'s ${m.kind === 'move' ? 'new ' : ''}SegWit address`],
+    [deal ? 'Price' : 'Amount', deal && !m.amount ? 'nothing' : btc(m.amount)],
     m.kind !== 'mine' && ['Fee', `${m.fee} sats, retired: this toy chain pays no fees to miners`],
-    m.change > 0 && ['Change', `${btc(m.change)} back to ${name(m.from)}`],
-    ['Signed by', m.kind === 'mine' ? 'nobody: a coinbase spends nothing' : `${name(m.from)}'s SegWit key (BIP-143, SIGHASH_ALL)`],
+    m.change > 0 && ['Change', `${btc(m.change)} back to ${fund ? 'the lab wallet' : name(m.from)}`],
+    ['Signed by', m.kind === 'mine' ? 'nobody: a coinbase spends nothing' : fund ? "the lab wallet's Taproot key"
+      : deal ? `${name(m.from)}'s SegWit key (SIGHASH_ALL) when it made the offer, then ${name(m.to)}'s Taproot key when it accepted`
+        : `${name(m.from)}'s SegWit key (BIP-143, SIGHASH_ALL)`],
     ['Transaction', m.txid],
   ].filter(Boolean);
   return [
@@ -449,7 +536,7 @@ function eventItem(e) {
     onclick: () => pick({ event: e.id, node: e.node ?? ui.node }) },
     h('span', { class: 'op', text: e.ok ? verb : `✕ ${verb.replace(/:$/, '')}` }), ' ', h('span', { class: 'es', text: rest.join(' ') })));
 }
-const moneyItem = m => h('li', {}, h('button', { type: 'button', class: `ev money${m.kind === 'gas' ? ' gas' : ''}${m.key === ui.tx ? ' on' : ''}`, 'aria-pressed': String(m.key === ui.tx),
+const moneyItem = m => h('li', {}, h('button', { type: 'button', class: `ev money${m.kind === 'gas' ? ' gas' : ''}${m.kind === 'deal' ? ' deal' : ''}${m.key === ui.tx ? ' on' : ''}`, 'aria-pressed': String(m.key === ui.tx),
   onclick: () => pick({ tx: m.key, node: node(m.to)?.root === ui.holding ? m.to : ui.node }) }, h('span', { class: 'op', text: m.kind }), ' ', h('span', { class: 'es', text: moneyLine(m) })));
 
 // Verbs
@@ -464,7 +551,7 @@ $('sample').addEventListener('click', async () => {
   say('Rehearsing the yolopreneur tree over six beats…');
   if (!(await run(l => { id = seedSample(l); }))) return;
   pick({ holding: id, node: id });
-  say('Loaded the yolopreneur sample: six beats of history. Press Replay to watch it grow.');
+  say("Loaded the yolopreneur sample: six beats of history, ending on lineage's open offer for sol's launch-kit. Press Replay to watch it grow.");
 });
 $('f-birth').addEventListener('submit', async event => {
   event.preventDefault();
@@ -494,6 +581,21 @@ $('f-send').addEventListener('submit', async event => {
   say(`${n.name} sent ${btc(amount)} to ${node(to)?.root === n.root ? node(to).name : trail(live, to)}, ${m?.beat ? `at beat ${m.beat}` : 'cued for the next beat'}.`);
   form.elements.amount.value = '';
 });
+$('f-make').addEventListener('submit', async event => {
+  event.preventDefault();
+  const form = event.currentTarget, n = node(ui.node), name = slug(form.elements.name.value), note = form.elements.note.value.trim();
+  if (!name) return say('Name the item: lowercase letters, digits and hyphens.', true);
+  if (await perform('make', n.id, { name, note }, (id, where) => `${n.name} made ${name}, ${where}.`)) form.reset();
+});
+$('f-offer').addEventListener('submit', async event => {
+  event.preventDefault();
+  const form = event.currentTarget, n = node(ui.node), item = $('offer-item').value, price = satsOf(form.elements.price.value);
+  if (price === null) return say('Write a price in test BTC, for example 0.1, or 0 for a free claim.', true);
+  const holder = whose(holders.get(item)), name = itemName(item);
+  if (!(await run(l => { offer(l, item, n.id, price); }))) return;
+  say(`${n.name} offers ${price ? btc(price) : 'nothing'} for ${name}. The offer stands until ${holder} accepts it.`);
+  form.elements.price.value = '';
+});
 $('send-max').addEventListener('click', () => {
   const n = node(ui.node), wallet = n && payerOf(lab.keys, live, n);
   if (wallet) $('send-amount').value = coins(most(lab.chain.coins(wallet.script)));
@@ -516,7 +618,20 @@ for (const b of document.querySelectorAll('[data-verb]')) b.addEventListener('cl
 // Mining: split by hashrate, or the last act takes the beat
 for (const b of document.querySelectorAll('[data-rule]')) b.addEventListener('click', async () => {
   const rule = b.dataset.rule;
-  if (await run(l => setRule(l, rule))) say(rule === 'split' ? 'Each beat splits across the holdings that mine, by hashrate.' : 'Each beat goes whole to the holding that acts.');
+  if (await run(l => setRule(l, rule))) {
+    say({ split: 'Each beat splits across the holdings that mine, by hashrate.', last: 'Each beat goes whole to the holding that acts.',
+      none: 'Mainnet: no holding mines. Beats pay the lab wallet, and you fund holdings from it.' }[rule]);
+  }
+});
+$('f-fund').addEventListener('submit', async event => {
+  event.preventDefault();
+  const form = event.currentTarget, to = form.elements.to.value, amount = satsOf(form.elements.amount.value);
+  if (amount === null) return say('Write an amount in test BTC, for example 5 (at most eight decimals).', true);
+  let txid = null;
+  if (!(await run(l => { txid = deposit(l, to, amount); }))) return;
+  const m = money.ledger.find(x => x.txid === txid);
+  say(`The lab wallet funded ${node(to)?.name} with ${btc(amount)}, ${m?.beat ? `at beat ${m.beat}` : 'cued for the next beat'}.`);
+  form.elements.amount.value = '';
 });
 
 // Time: the tempo, Beat now, and the clock that lands cued acts when their beat is due
diff --git a/src/orgchain.css b/src/orgchain.css
index 654fa4f..867a5e7 100644
--- a/src/orgchain.css
+++ b/src/orgchain.css
@@ -315,3 +315,13 @@ textarea { resize: vertical; line-height: 1.5; }
 .rig { display: flex; align-items: center; justify-content: space-between; gap: 10px; padding: 0 18px 12px; border-left: 0; }
 .rig .rl { color: var(--ink-2); }
 .holds li:has(.hold.on) .rig .rl { color: var(--on-signal); }
+.verbs button:nth-child(-n+6) { border-bottom: 2px solid var(--ink); }
+.verbs button:last-child:nth-child(3n+2) { grid-column: span 2; }
+.fund { display: grid; gap: 6px; margin-top: 14px; }
+.fund .lab { margin-top: 4px; }
+.mining .tempo { flex: 1 1 auto; flex-wrap: nowrap; }
+.mining .seg { flex: 1 1 auto; min-width: 0; padding: 9px 6px 8px; letter-spacing: 0.02em; }
+.items li { overflow-wrap: anywhere; }
+.items .btn.sm { margin-left: 8px; vertical-align: middle; }
+.bids { list-style: none; margin: 6px 0 0; padding: 0 0 0 12px; border-left: 2px solid var(--ink-3); display: grid; gap: 6px; }
+.ev.money.deal .op { color: var(--ink); }
diff --git a/src/orgchain/actions.js b/src/orgchain/actions.js
index 9f6d0a8..4583e34 100644
--- a/src/orgchain/actions.js
+++ b/src/orgchain/actions.js
@@ -1,4 +1,5 @@
-// Orgchain's verbs as lineage/v0 inscriptions: found, birth, award, decide, graduate, close.
+// Orgchain's verbs as lineage/v0 inscriptions: found, birth, award, decide, make, graduate, close. Beside them, money
+// moves: sends, offers on items and their acceptance, and funding a holding from the lab wallet.
 // Each act is signed by the key that holds its authorizing node's inscription (lineage's key tree, ./keys.js).
 // Gas: every act is paid by the acting node's own keys, topped up from its own money (./money.js); the lab wallet
 // only pays for foundings (a holding owns nothing until it mines) and for holdings that predate lab keys.
@@ -12,11 +13,13 @@ import { holderCoin, makeClaim, countersign } from '../adapters/handoff.js';
 import { PROTOCOL, lineageEvents, reduce } from './lineage.js';
 import { armClock, beat } from './store.js';
 import { derivedSubtree, emptyKeys, holderOf, keyOf, rootWallet, scriptHex } from './keys.js';
-import { DUST, SAT, canSpend, covers, pay, payouts, payerOf, spend, sweep } from './money.js';
+import { DUST, REWARD, SAT, canSpend, covers, pay, payouts, payerOf, spend, sweep } from './money.js';
+import { acceptOffer, makeOffer, withdrawOffer } from './offers.js';
 
-const FIELDS = { found: ['name'], birth: ['name', 'kind'], award: ['to', 'skill', 'belt'], decide: ['title', 'why'], graduate: ['of'], close: [] };
+const FIELDS = { found: ['name'], birth: ['name', 'kind'], award: ['to', 'skill', 'belt'], decide: ['title', 'why'], make: ['name', 'note'],
+  graduate: ['of'], close: [] };
 const BODY = { found: m => `found ${m.name}`, birth: m => `birth ${m.name}`, award: m => `award ${m.skill} ${m.belt}`,
-  decide: m => `decide ${m.title}`, graduate: () => 'graduate', close: () => 'close' };
+  decide: m => `decide ${m.title}`, make: m => `make ${m.name}`, graduate: () => 'graduate', close: () => 'close' };
 
 export function metadataFor(op, fields = {}) {
   if (!Object.hasOwn(FIELDS, op)) throw new Error('Unknown verb.');
@@ -82,7 +85,7 @@ export function gasCheck(lab, state, op, by, fields = {}) {
   const moving = org && keyOf(lab.keys, state, org) ? derivedSubtree(state, org.id).length : 0;
   if (!gasReady(lab, state, actor, wallet, gasFor(op, moving))) {
     const parent = state.nodes.get(actor.parent);
-    return parent ? `${actor.name} has no test BTC for gas. ${parent.name} can send some` : `${actor.name} has no test BTC for gas. It earns some each beat it mines`;
+    return `${actor.name} has no test BTC for gas. ${parent ? `${parent.name} can send some` : lab.mining?.rule === 'none' ? 'Fund it from the lab wallet' : 'It earns some each beat it mines'}`;
   }
   const purse = moving ? payerOf(lab.keys, state, org) : null;
   if (purse && !covers(lab.chain.coins(purse.script).filter(c => c.value - FEE >= DUST).map(c => ({ value: c.value - FEE })), TANK)) {
@@ -105,13 +108,17 @@ export const minerOf = (lab, holdingId) => payouts(lab, lineageState(lab), holdi
 // The holding behind the newest cued act or send, or null: under 'last', a timed beat goes to whoever acted last.
 export function lastHolding(lab) {
   const state = lineageState(lab), byScript = new Map();
-  for (const n of state.nodes.values()) { const w = payerOf(lab.keys, state, n); if (w) byScript.set(scriptHex(w.script), n.root); }
+  for (const n of state.nodes.values()) {
+    for (const w of [payerOf(lab.keys, state, n), keyOf(lab.keys, state, n)?.wallet]) if (w) byScript.set(scriptHex(w.script), n.root);
+  }
   for (const raw of [...lab.chain.mempool].reverse()) {
     const record = lab.chain.transactions.get(Tx.util.getTxid(raw));
     if (record?.inscription) { const root = state.log.find(e => e.id === record.inscription.id)?.root; if (root) return root; continue; }
-    const input = record?.tx.vin[0], prev = input && lab.chain.transactions.get(input.txid)?.tx.vout[input.vout];
-    const root = prev && byScript.get(scriptHex(prev.scriptPubKey));
-    if (root) return root;
+    // The first input a node signed: a send's sender, or a deal's holder, who accepted it.
+    for (const input of record?.tx.vin ?? []) {
+      const prev = lab.chain.transactions.get(input.txid)?.tx.vout[input.vout], root = prev && byScript.get(scriptHex(prev.scriptPubKey));
+      if (root) return root;
+    }
   }
   return null;
 }
@@ -169,15 +176,41 @@ export function act(lab, op, by, fields, now = Date.now()) {
   return id;
 }
 
-// Send test BTC from one node to another in its holding (./money.js). Like an act, it lands now or is cued.
+// Send test BTC from one node to another, in any holding (./money.js). Like an act, it lands now or is cued.
 export function send(lab, from, to, amount, now = Date.now()) {
   const txid = pay(lab, lineageState(lab), from, to, amount);
   if (lab.clock.tempo === 'each') beat(lab, minerFor(lab, from)); else armClock(lab, now);
   return txid;
 }
+// Offer on an item another node holds (./offers.js): the buyer signs now, and nothing reaches the chain until the holder
+// accepts, which lands like a send; the accepting holder counts as the one that acted. Withdrawing forgets an offer.
+export const offer = (lab, item, buyer, price, now = Date.now()) => makeOffer(lab, item, buyer, price, now);
+export function accept(lab, txid, now = Date.now()) {
+  const o = acceptOffer(lab, txid);
+  if (lab.clock.tempo === 'each') beat(lab, minerFor(lab, o.seller)); else armClock(lab, now);
+  return o;
+}
+export const withdraw = (lab, txid) => withdrawOffer(lab, txid);
+// Mainnet has no mining to join: a holding is funded from a wallet that already holds coins. Here the lab wallet plays
+// that wallet (a beat refills it when it runs short). Like a send, the deposit lands now or is cued.
+export function deposit(lab, holdingId, amount, now = Date.now()) {
+  const state = lineageState(lab), holding = state.nodes.get(holdingId);
+  if (holding?.kind !== 'holding') throw new Error('Pick a holding to fund.');
+  if (holding.status !== 'active') throw new Error(`${holding.name} is closed.`);
+  const dest = payerOf(lab.keys, state, holding);
+  if (!dest) throw new Error('A holding that predates lab keys has no SegWit address to fund.');
+  if (!Number.isSafeInteger(amount) || amount < DUST) throw new Error(`Fund at least ${DUST} sats.`);
+  if (amount > REWARD) throw new Error('Fund at most 50 test BTC at a time: no output on this chain is bigger than one block reward.');
+  fund(lab);
+  if (!canSpend(lab, lab.wallet, amount)) beat(lab);
+  const txid = spend(lab, lab.wallet, dest.script, amount, 'The lab wallet', 'fund');
+  if (lab.clock.tempo === 'each') beat(lab, minerFor(lab, holdingId)); else armClock(lab, now);
+  return txid;
+}
 
 // The drawing in docs/lineage.md, rehearsed over six beats. Names stand in for inscription ids until those exist.
 // Its beats pay yolopreneur, and sends pass money down the tree before each org acts, since every act pays its gas.
+// It ends on a standing offer: lineage's bid for the launch kit sol made, there for the holder to accept.
 export const SAMPLE = 'yolopreneur';
 const PLAN = [
   [['found', null, { name: 'yolopreneur' }]],
@@ -190,20 +223,24 @@ const PLAN = [
     ['birth', 'time', { name: 'doodleloop', kind: 'org' }], ['birth', 'time', { name: 'hearthframe', kind: 'org' }]],
   [['send', 'time', { to: 'sol', amount: 1 }], ['send', 'time', { to: 'luna', amount: 0.5 }],
     ['award', 'time', { to: 'sol', skill: 'launch', belt: 'green' }], ['award', 'time', { to: 'luna', skill: 'post', belt: 'white' }],
-    ['decide', 'yolopreneur', { title: 'Every venture gets a page', why: '<venture>.yolopreneur.lol, served from one pages branch.' }]],
+    ['decide', 'yolopreneur', { title: 'Every venture gets a page', why: '<venture>.yolopreneur.lol, served from one pages branch.' }],
+    ['make', 'sol', { name: 'launch-kit', note: 'The page, the post and the checklist every venture launches with.' }]],
   [['graduate', 'well-known', { of: 'lineage' }],
-    ['decide', 'lineage', { title: 'Lineage gets its own org', why: 'Its own repo on Teahub now, lineage.llc later: adopted, not derived.' }]],
+    ['decide', 'lineage', { title: 'Lineage gets its own org', why: 'Its own repo on Teahub now, lineage.llc later: adopted, not derived.' }],
+    ['offer', 'lineage', { item: 'launch-kit', price: 0.1 }]],
 ];
 export function seedSample(lab) {
   fund(lab);
   if (lab.chain.mempool.length) beat(lab); // land anything already cued, so the sample's beats are its own
-  const ids = {};
+  const ids = {}, items = {};
   for (const group of PLAN) {
     for (const [op, by, fields] of group) {
       if (op === 'send') { pay(lab, lineageState(lab), ids[by], ids[fields.to], fields.amount * SAT); continue; }
+      if (op === 'offer') { makeOffer(lab, items[fields.item], ids[by], fields.price * SAT); continue; }
       const resolved = Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, k === 'to' || k === 'of' ? ids[v] : v]));
       const parent = by ? ids[by] : null, id = perform(lab, op, parent, check(lab, op, parent, resolved));
       if (op === 'found' || op === 'birth') ids[fields.name] = id;
+      if (op === 'make') items[fields.name] = id;
     }
     beat(lab, minerOf(lab, ids[SAMPLE]));
   }
diff --git a/src/orgchain/lineage.js b/src/orgchain/lineage.js
index 35665d5..a4d6309 100644
--- a/src/orgchain/lineage.js
+++ b/src/orgchain/lineage.js
@@ -17,8 +17,9 @@ export function slug(value) {
 export const lineageEvents = index => index.events.filter(e => e.protocol === PROTOCOL);
 
 // Fold events in chain order (blocks, then mempool). upTo: the last beat to include. pending: include cued events.
+// Items are what nodes make: each is an inscription its maker holds at first. Who holds one later is the chain's to say.
 export function reduce(events, { upTo = Infinity, pending = false } = {}) {
-  const nodes = new Map(), roots = [], log = [];
+  const nodes = new Map(), roots = [], log = [], items = new Map();
   const active = n => n.status === 'active';
   for (const e of events) {
     const confirmed = e.status === 'confirmed';
@@ -69,6 +70,12 @@ export function reduce(events, { upTo = Infinity, pending = false } = {}) {
         else if (!text(m.title, 140)) fail('a decision needs a title');
         else { by.decisions.push({ title: text(m.title, 140), why: text(m.why, 400), beat: when, id: e.id }); entry.node = by.id; }
         break;
+      case 'make':
+        if ((why = authority('maker'))) fail(why);
+        else if (!isName(m.name)) fail(NAME_RULE);
+        else if (by.made.some(id => items.get(id).name === m.name)) fail(`there is already a ${m.name} by ${by.name}`);
+        else { items.set(e.id, { id: e.id, name: m.name, note: text(m.note, 280), maker: by.id, beat: when }); by.made.push(e.id); entry.node = by.id; }
+        break;
       case 'graduate': {
         const of = nodes.get(m.of);
         if ((why = authority('parent'))) fail(why);
@@ -96,13 +103,13 @@ export function reduce(events, { upTo = Infinity, pending = false } = {}) {
     entry.root = entry.node ? nodes.get(entry.node).root : by?.root ?? null;
     log.push(entry);
   }
-  return { nodes, roots, log };
+  return { nodes, roots, log, items };
 }
 
 function make(e, name, parent, kind) {
   return { id: e.id, name, kind, parent: parent?.id ?? null, root: parent ? parent.root : e.id, edge: parent ? 'derived' : null,
     status: 'active', index: null, born: e.status === 'confirmed' ? e.height : 'cued',
-    children: [], badges: [], decisions: [], graduated: null, closed: null };
+    children: [], badges: [], decisions: [], made: [], graduated: null, closed: null };
 }
 
 // Depth-first rows for one holding, drawn like docs/lineage.md: agents, then orgs, under every node.
@@ -147,6 +154,7 @@ export function summary(entry, state) {
     case 'birth': return `birth ${m.name}${m.kind === 'agent' ? ' (agent)' : ''} ← ${name(entry.parent)}`;
     case 'award': return `award ${m.skill} · ${m.belt} → ${name(m.to)}, from ${name(entry.parent)}`;
     case 'decide': return `decide “${text(m.title, 140)}” · ${name(entry.parent)}`;
+    case 'make': return `make ${m.name} · ${name(entry.parent)}`;
     case 'graduate': return `graduate ${name(m.of)} from ${name(entry.parent)}`;
     case 'close': return `close ${name(entry.parent)}${entry.also.length ? ` and ${entry.also.length} derived` : ''}`;
     default: return entry.op;
diff --git a/src/orgchain/money.js b/src/orgchain/money.js
index 7527ddf..488830a 100644
--- a/src/orgchain/money.js
+++ b/src/orgchain/money.js
@@ -1,10 +1,11 @@
 // Orgchain's money: test BTC at each node's SegWit address (BIP-84). Beats pay holdings: under 'split' every active
 // holding mines a share by its hashrate, under 'last' the holding that acted takes the beat. Any active node can send
 // to any other, signed by its own SegWit key, and a graduation re-keys a subtree and moves its money along. A node's
-// acts burn gas from its acting key (Taproot), which tops up from its money (actions.js). Test coins only.
+// acts burn gas from its acting key (Taproot), which tops up from its money (actions.js). Under 'none' (mainnet, where
+// there is no mining to join) beats pay the lab wallet, and holdings are funded from it. Test coins only.
 import { Address, Signer, Tx } from '@cmdcode/tapscript';
 import { FEE } from '../adapters/inscription.js';
-import { MAX_PAYOUTS } from '../adapters/chain.js';
+import { MAX_IO, MAX_PAYOUTS } from '../adapters/chain.js';
 import { getVin, getVout } from '../upstream/primitives.js';
 import { PATHS, segwitPubkey, segwitSecret } from '../adapters/lineage-keys.js';
 import { reduce } from './lineage.js';
@@ -61,12 +62,14 @@ export function payee(keys, state, holdingId) {
 export const rigsOf = (lab, id) => lab.mining?.rigs?.[id] ?? 1;
 // The holdings that mine under 'split': active, keyed, with a hashrate above zero (at most MAX_PAYOUTS of them).
 export function miners(lab, state) {
+  if (lab.mining?.rule === 'none') return [];
   return state.roots.filter(r => r.status === 'active' && rigsOf(lab, r.id) > 0 && payerOf(lab.keys, state, r)).slice(0, MAX_PAYOUTS);
 }
 // What a beat pays, as coinbase outputs; null means the lab wallet. Under 'split' the reward splits pro rata by
 // hashrate (the last miner takes the odd sats); under 'last' the holding that acted, or the one being worked in,
-// takes it all.
+// takes it all; under 'none' no holding mines.
 export function payouts(lab, state, holdingId) {
+  if (lab.mining?.rule === 'none') return null;
   if (lab.mining?.rule === 'last') { const script = payee(lab.keys, state, holdingId); return script ? [{ script, value: REWARD }] : null; }
   const list = miners(lab, state), total = list.reduce((sum, r) => sum + rigsOf(lab, r.id), 0);
   let left = REWARD;
@@ -77,12 +80,13 @@ export function payouts(lab, state, holdingId) {
   }) : null;
 }
 
-// The coins a send spends: the fewest and smallest that cover the amount and the fee and leave no dust. The toy chain
-// takes at most two inputs, and no output above one block reward.
-function choose(list, amount) {
+// The coins a payment spends: the fewest that cover the amount and the fee and leave no dust (the smallest coin or
+// pair that does; past two, the biggest coins first). Change is one output, so it can't top one block reward. The toy
+// chain takes MAX_IO inputs, and an offer keeps one of them for the item.
+export function choose(list, amount, max = MAX_IO) {
   const need = amount + FEE, fits = total => total === need || (total - need >= DUST && total - need <= REWARD);
   const sorted = [...list].sort((a, b) => a.value - b.value), one = sorted.find(c => fits(c.value));
-  if (one) return [one];
+  if (one || max < 2) return one ? [one] : null;
   let best = null;
   for (let i = 0; i < sorted.length; i++) {
     for (let j = i + 1; j < sorted.length; j++) {
@@ -90,38 +94,50 @@ function choose(list, amount) {
       if (fits(total) && (!best || total < best[0].value + best[1].value)) best = [sorted[i], sorted[j]];
     }
   }
+  if (best) return best;
+  const big = sorted.reverse();
+  for (let k = 3; k <= Math.min(max, big.length); k++) if (fits(sumOf(big.slice(0, k)))) return big.slice(0, k);
+  return null;
+}
+const sumOf = list => list.reduce((sum, c) => sum + c.value, 0);
+// The most one payment can move from these coins, using at most max of them.
+export function most(list, max = MAX_IO) {
+  let best = 0, t = -FEE;
+  for (const value of list.map(c => c.value).sort((a, b) => b - a).slice(0, max)) {
+    t += value;
+    const x = t <= REWARD ? t : t - REWARD >= DUST ? REWARD : t - DUST;
+    if (x >= DUST && t - x <= REWARD) best = Math.max(best, x);
+  }
   return best;
 }
-// The most one send can move from these coins.
-export function most(list) {
-  const v = list.map(c => c.value).sort((a, b) => b - a), out = [];
-  if (v.length) out.push(v[0] - FEE);
-  if (v.length > 1) { const t = v[0] + v[1] - FEE; out.push(t <= REWARD ? t : t - REWARD >= DUST ? REWARD : t - DUST); }
-  return Math.max(0, ...out.filter(x => x >= DUST && x <= REWARD));
-}
-// Why a send cannot be made from these coins (when choose found none).
-function short(name, list, amount) {
-  const has = list.reduce((sum, c) => sum + c.value, 0), need = amount + FEE, max = most(list);
-  if (has < need) return `${name} has ${btc(has)}, and sending ${btc(amount)} also costs the ${FEE}-sat fee.`;
-  const totals = [...list.map(c => c.value), ...list.flatMap((a, i) => list.slice(i + 1).map(b => a.value + b.value))];
-  const cover = Math.min(...totals.filter(t => t >= need));
+// Why a payment cannot be made from these coins (when choose found none). verb: send, offer or fund.
+export function short(name, list, amount, max = MAX_IO, verb = 'send') {
+  const has = sumOf(list), need = amount + FEE, top = most(list, max), Verb = `${verb[0].toUpperCase()}${verb.slice(1)}`;
+  if (has < need) return `${name} has ${btc(has)}, and ${verb}ing ${amount ? btc(amount) : 'nothing'} also costs the ${FEE}-sat fee.`;
+  const big = list.map(c => c.value).sort((a, b) => b - a), tops = big.slice(0, max).map((_, k) => big.slice(0, k + 1).reduce((s, v) => s + v, 0));
+  const cover = Math.min(...[...big, ...big.flatMap((a, i) => big.slice(i + 1).map(b => a + b)), ...tops].filter(t => t >= need));
   if (Number.isFinite(cover) && cover - need < DUST) {
-    return `Sending ${btc(amount)} would leave ${cover - need} sats of change, under the ${DUST}-sat floor. Send ${btc(max)}, or at least ${DUST - (cover - need)} sats less.`;
+    return `${Verb}ing ${btc(amount)} would leave ${cover - need} sats of change, under the ${DUST}-sat floor. ${Verb} ${btc(top)}, or at least ${DUST - (cover - need)} sats less.`;
   }
-  return `One send spends at most two coins, so the most ${name} can send at once is ${btc(max)}.`;
+  return `One ${verb} spends at most ${max} coins, so the most ${name} can ${verb} at once is ${btc(top)}.`;
 }
 
-// Whether these coins, or a SegWit wallet's, can pay this amount in one transaction.
-export const covers = (list, amount) => !!choose(list, amount);
-export const canSpend = (lab, wallet, amount) => covers(lab.chain.coins(wallet.script), amount);
-// Spend from a SegWit wallet: its coins in, the amount to script, change back, and the fixed fee.
-export function spend(lab, wallet, script, amount, name = 'This node') {
-  const list = lab.chain.coins(wallet.script), picked = choose(list, amount);
-  if (!picked) throw new Error(short(name, list, amount));
-  const change = picked.reduce((sum, c) => sum + c.value, 0) - amount - FEE;
+// Coins promised to standing offers (./offers.js). Payments spend other coins first, so offers don't go stale.
+export const promised = lab => new Set((lab.offers ?? []).flatMap(o => o.payers.map(p => `${p.txid}:${p.vout}`)));
+const plainCoins = (lab, wallet) => lab.chain.coins(wallet.script).filter(c => !c.inscriptions?.length);
+// Whether these coins, or a wallet's plain coins, can pay this amount in one transaction.
+export const covers = (list, amount, max = MAX_IO) => !!choose(list, amount, max);
+export const canSpend = (lab, wallet, amount) => covers(plainCoins(lab, wallet), amount);
+// Spend from a wallet (a node's SegWit key, or the lab wallet's Taproot key): its coins in, the amount to script, change
+// back, and the fixed fee. Coins no standing offer has promised go first.
+export function spend(lab, wallet, script, amount, name = 'This node', verb = 'send') {
+  const list = plainCoins(lab, wallet), busy = promised(lab);
+  const picked = choose(list.filter(c => !busy.has(`${c.txid}:${c.vout}`)), amount) ?? choose(list, amount);
+  if (!picked) throw new Error(short(name, list, amount, MAX_IO, verb));
+  const change = sumOf(picked) - amount - FEE;
   const tx = Tx.create({ vin: picked.map(c => getVin(c.txid, c.vout, c.value, c.scriptPubKey)),
     vout: [getVout(amount, script), ...(change ? [getVout(change, wallet.script)] : [])] });
-  picked.forEach((c, i) => { tx.vin[i].witness = wallet.sign(tx, i); });
+  picked.forEach((c, i) => { tx.vin[i].witness = wallet instanceof PayWallet ? wallet.sign(tx, i) : [wallet.sign(tx, undefined, i)]; });
   const raw = Tx.encode(tx).hex;
   lab.chain.submitPackage([raw]);
   return Tx.util.getTxid(raw);
@@ -175,10 +191,22 @@ export const tanks = (keys, events, live) => scripts(epochs(events, live), (stat
 });
 // What a node's gas tank holds now: the plain coins at its acting key.
 export const tankOf = (chain, wallet) => chain.coins(wallet.script).filter(c => !c.inscriptions?.length).reduce((sum, c) => sum + c.value, 0);
+// The Taproot key behind a script, from whichever tree had it (now, or before a graduation), and whose it is: how a
+// holder signs for an item that reached it under keys it has since moved on from.
+export function keyAt(keys, events, live, script) {
+  for (const state of epochs(events, live)) {
+    for (const n of state.nodes.values()) {
+      const k = keyOf(keys, state, n);
+      if (k && scriptHex(k.wallet.script) === script) return { node: n.id, wallet: k.wallet };
+    }
+  }
+  return null;
+}
 
 // The money's record in chain order: a beat's reward to each node it paid (mine), sends (pay), top-ups of a node's own
-// gas tank (gas), and money that followed a node to its new keys (move). A beat of null means cued.
-export function ledger(chain, owner, tank = new Map()) {
+// gas tank (gas), money that followed a node to its new keys (move), the lab wallet funding a holding (fund), and an
+// item sold for a price (deal; deals maps a deal's txid to its offer, ./offers.js). A beat of null means cued.
+export function ledger(chain, owner, tank = new Map(), deals = new Map()) {
   const out = [], who = script => owner.get(scriptHex(script)) ?? null, sum = list => list.reduce((s, x) => s + x.value, 0);
   for (const { txid, tx, height, coinbase } of chain.transactions.values()) {
     const outs = tx.vout.map(o => ({ script: scriptHex(o.scriptPubKey), node: who(o.scriptPubKey), value: Number(o.value) }));
@@ -192,6 +220,18 @@ export function ledger(chain, owner, tank = new Map()) {
       const prev = chain.transactions.get(i.txid)?.tx.vout[i.vout];
       return prev ? { node: who(prev.scriptPubKey), value: Number(prev.value) } : null;
     });
+    const deal = deals.get(txid);
+    if (deal && ins.length > 1 && ins[0] && ins.slice(1).every(x => x?.node === deal.buyer)) {
+      out.push({ kind: 'deal', key: txid, txid, beat: height, from: deal.buyer, to: deal.seller, amount: deal.price, item: deal.item,
+        fee: sum(ins) - sum(outs), change: sum(outs.filter(o => o.node === deal.buyer)) });
+      continue;
+    }
+    if (ins.every(x => x && !x.node)) {
+      const paid = outs.filter(o => o.node);
+      if (paid.length) out.push({ kind: 'fund', key: txid, txid, beat: height, from: null, to: paid[0].node, amount: paid[0].value,
+        fee: sum(ins) - sum(outs), change: sum(outs.filter(o => !o.node)) });
+      continue;
+    }
     const from = ins[0]?.node;
     if (!from || !ins.every(x => x?.node === from)) continue; // inscriptions, grants and handoffs are Taproot, not money
     const paid = outs.filter(o => o.node !== from), back = outs.filter(o => o.node === from), fee = sum(ins) - sum(outs);
diff --git a/src/orgchain/offers.js b/src/orgchain/offers.js
new file mode 100644
index 0000000..77fd0b3
--- /dev/null
+++ b/src/orgchain/offers.js
@@ -0,0 +1,119 @@
+// Standing offers: OpenOrdex's buy order, with a price. The buyer builds the whole deal and signs its own coins first
+// (SegWit, SIGHASH_ALL), so its signatures already fix where the item goes and what the holder is paid. The offer then
+// stands in the lab until the item's holder countersigns the item's input, the buyer withdraws it, or a coin it spends
+// moves. One transaction: the item and the buyer's coins in; the item to the buyer's Taproot key, the price to the
+// holder's SegWit address and the buyer's change out; the buyer pays the fee. Test coins only.
+import { Tx } from '@cmdcode/tapscript';
+import { FEE } from '../adapters/inscription.js';
+import { MAX_IO } from '../adapters/chain.js';
+import { holderCoin } from '../adapters/handoff.js';
+import { MetadataIndex } from '../adapters/metadata-index.js';
+import { getVin, getVout } from '../upstream/primitives.js';
+import { lineageEvents, reduce } from './lineage.js';
+import { keyOf, scriptHex } from './keys.js';
+import { DUST, REWARD, choose, keyAt, payerOf, promised, short } from './money.js';
+
+export const OFFER_KIND = 'lineage-offer';
+const HEX64 = /^[0-9a-f]{64}$/, ID = /^[0-9a-f]{64}i0$/, TAPROOT = /^5120[0-9a-f]{64}$/, P2WPKH = /^0014[0-9a-f]{40}$/;
+const point = coin => ({ txid: coin.txid, vout: coin.vout, value: coin.value, script: scriptHex(coin.scriptPubKey) });
+const moved = (chain, p) => !chain.utxos.has(`${p.txid}:${p.vout}`);
+const world = lab => { const events = lineageEvents(new MetadataIndex(lab.chain)); return { events, state: reduce(events, { pending: true }) }; };
+
+function build(o) {
+  return Tx.create({
+    vin: [o.holder, ...o.payers].map(p => getVin(p.txid, p.vout, p.value, p.script)),
+    vout: [getVout(o.holder.value, o.to), ...(o.price ? [getVout(o.price, o.pay)] : []), ...(o.change ? [getVout(o.change, o.back)] : [])],
+  });
+}
+
+// Who holds an item now: the node whose Taproot key (in any of its trees) has its coin, or null.
+export function holderOfItem(lab, events, state, itemId) {
+  const coin = holderCoin(lab.chain, itemId), at = coin && keyAt(lab.keys, events, state, scriptHex(coin.scriptPubKey));
+  return at ? { coin, node: state.nodes.get(at.node), wallet: at.wallet } : null;
+}
+
+// The buyer's side: pick its coins, build the deal, sign its inputs, and keep the offer in the lab. A price of 0 is a
+// free claim: the buyer still pays the fee.
+export function makeOffer(lab, itemId, buyerId, price, now = Date.now()) {
+  const { events, state } = world(lab), item = state.items.get(itemId), buyer = state.nodes.get(buyerId);
+  if (!item) throw new Error('Pick an item to make an offer on.');
+  if (!buyer) throw new Error('Pick who makes the offer.');
+  if (!Number.isSafeInteger(price) || price < 0 || (price > 0 && price < DUST)) throw new Error(`Offer nothing, or at least ${DUST} sats.`);
+  if (price > REWARD) throw new Error('Offer at most 50 test BTC: no output on this chain is bigger than one block reward.');
+  const holder = holderOfItem(lab, events, state, itemId), seller = holder?.node;
+  if (!seller) throw new Error(`No node in this lab holds ${item.name}.`);
+  if (seller.id === buyer.id) throw new Error(`${buyer.name} already holds ${item.name}.`);
+  for (const n of [buyer, seller]) if (n.status !== 'active') throw new Error(`${n.name} is ${n.status}.`);
+  const wallet = payerOf(lab.keys, state, buyer), dest = payerOf(lab.keys, state, seller), into = keyOf(lab.keys, state, buyer);
+  if (!wallet || !dest || !into) throw new Error('A holding that predates lab keys cannot trade.');
+  if ((lab.offers ?? []).some(o => o.item === itemId && o.buyer === buyer.id && offerStatus(lab, state, o) === 'open')) {
+    throw new Error(`${buyer.name} already has an open offer on ${item.name}. Withdraw it first.`);
+  }
+  const list = lab.chain.coins(wallet.script), busy = promised(lab);
+  const picked = choose(list.filter(c => !busy.has(`${c.txid}:${c.vout}`)), price, MAX_IO - 1) ?? choose(list, price, MAX_IO - 1);
+  if (!picked) throw new Error(short(buyer.name, list, price, MAX_IO - 1, 'offer'));
+  const o = { kind: OFFER_KIND, version: 1, item: itemId, buyer: buyer.id, seller: seller.id, price, holder: point(holder.coin),
+    payers: picked.map(point), to: scriptHex(into.wallet.script), pay: scriptHex(dest.script), back: scriptHex(wallet.script),
+    change: picked.reduce((sum, c) => sum + c.value, 0) - price - FEE, at: now };
+  const tx = build(o);
+  o.txid = Tx.util.getTxid(tx);
+  o.witnesses = picked.map((c, i) => wallet.sign(tx, i + 1));
+  (lab.offers ??= []).push(o);
+  return o;
+}
+
+// Why an offer can no longer land as signed ('' while it can): a coin it spends moved, a side closed, or a side has
+// new keys since (a graduation re-keys a node, so the item or the price would reach keys it has left).
+export function offerWhy(lab, state, o) {
+  const name = id => state.nodes.get(id)?.name ?? 'a node', item = state.items.get(o.item)?.name ?? 'the item';
+  if (moved(lab.chain, o.holder)) return `${item} has moved since`;
+  if (o.payers.some(p => moved(lab.chain, p))) return `${name(o.buyer)} has spent a coin the offer promised`;
+  for (const id of [o.buyer, o.seller]) { const n = state.nodes.get(id); if (n?.status !== 'active') return `${name(id)} is ${n?.status ?? 'gone'}`; }
+  const buyer = state.nodes.get(o.buyer), seller = state.nodes.get(o.seller), at = w => (w ? scriptHex(w.script) : '');
+  if (at(keyOf(lab.keys, state, buyer)?.wallet) !== o.to || at(payerOf(lab.keys, state, buyer)) !== o.back) return `${buyer.name} has new keys since`;
+  if (o.price && at(payerOf(lab.keys, state, seller)) !== o.pay) return `${seller.name} has new keys since`;
+  return '';
+}
+// done: on the chain, cued or confirmed. stale: it can never land as signed. open: the holder can accept it.
+export const offerStatus = (lab, state, o) => (lab.chain.transactions.has(o.txid) ? 'done' : offerWhy(lab, state, o) ? 'stale' : 'open');
+
+// The holder's side: countersign the item's input with whichever of its keys holds it, and the deal goes to the chain.
+export function acceptOffer(lab, txid) {
+  const o = (lab.offers ?? []).find(x => x.txid === txid);
+  if (!o) throw new Error('That offer is gone.');
+  if (lab.chain.transactions.has(o.txid)) throw new Error('That offer was already accepted.');
+  const { events, state } = world(lab), why = offerWhy(lab, state, o);
+  if (why) throw new Error(`This offer is stale: ${why}.`);
+  const holder = holderOfItem(lab, events, state, o.item);
+  if (holder?.node.id !== o.seller) throw new Error('Only the holder can accept.');
+  const tx = build(o);
+  o.witnesses.forEach((w, i) => { tx.vin[i + 1].witness = w; });
+  tx.vin[0].witness = [holder.wallet.sign(tx, undefined, 0)];
+  lab.chain.submitPackage([Tx.encode(tx).hex]);
+  return o;
+}
+// The buyer forgets an offer that has not landed: nothing of it was on the chain. (Outside the lab, anyone holding the
+// signed offer could still complete it, so withdrawing one for real means spending a coin it promised.)
+export function withdrawOffer(lab, txid) {
+  const o = (lab.offers ?? []).find(x => x.txid === txid);
+  if (!o) throw new Error('That offer is gone.');
+  if (lab.chain.transactions.has(o.txid)) throw new Error('That offer was accepted: it is on the chain now.');
+  lab.offers = lab.offers.filter(x => x !== o);
+  return o;
+}
+
+// A saved offer, checked for shape. The chain checks its signatures when the holder accepts.
+export function decodeOffer(o) {
+  const coin = (p, script) => p && HEX64.test(p.txid) && Number.isSafeInteger(p.vout) && p.vout >= 0 && Number.isSafeInteger(p.value) &&
+    p.value >= DUST && p.value <= REWARD && script.test(p.script);
+  const amount = v => Number.isSafeInteger(v) && (v === 0 || (v >= DUST && v <= REWARD));
+  if (o?.kind !== OFFER_KIND || o.version !== 1 || !ID.test(o.item) || !ID.test(o.buyer) || !ID.test(o.seller) || o.buyer === o.seller ||
+    !amount(o.price) || !amount(o.change) || !coin(o.holder, TAPROOT) || !Array.isArray(o.payers) || !o.payers.length ||
+    o.payers.length > MAX_IO - 1 || !o.payers.every(p => coin(p, P2WPKH)) || !TAPROOT.test(o.to) || !P2WPKH.test(o.pay) ||
+    !P2WPKH.test(o.back) || !HEX64.test(o.txid) || !Array.isArray(o.witnesses) || o.witnesses.length !== o.payers.length ||
+    !o.witnesses.every(w => Array.isArray(w) && w.length === 2 && /^30[0-9a-f]{12,140}01$/.test(w[0]) && /^0[23][0-9a-f]{64}$/.test(w[1])) ||
+    !Number.isSafeInteger(o.at)) throw new Error('Invalid offer.');
+  return { kind: OFFER_KIND, version: 1, item: o.item, buyer: o.buyer, seller: o.seller, price: o.price, holder: { ...o.holder },
+    payers: o.payers.map(p => ({ ...p })), to: o.to, pay: o.pay, back: o.back, change: o.change, at: o.at, txid: o.txid,
+    witnesses: o.witnesses.map(w => [...w]) };
+}
diff --git a/src/orgchain/store.js b/src/orgchain/store.js
index 2ac63af..81b5079 100644
--- a/src/orgchain/store.js
+++ b/src/orgchain/store.js
@@ -3,6 +3,7 @@ import { LocalChain } from '../adapters/chain.js';
 import { NETWORK, TestWallet } from '../adapters/wallet.js';
 import { assertMnemonic } from '../adapters/lineage-keys.js';
 import { SCHEMES, emptyKeys } from './keys.js';
+import { decodeOffer } from './offers.js';
 import { getVout } from '../upstream/primitives.js';
 
 export const LAB_KEY = 'orgchain:lab:v1';
@@ -28,8 +29,9 @@ export function keysPreference(value) {
   return keys;
 }
 // Mining: under 'split' every active holding takes a share of each beat by its hashrate (0 to 9 rigs, 1 unless set);
-// under 'last' the holding that acted takes the whole beat (money.js payouts). Labs saved before v1.6 split.
-export const RULES = ['split', 'last'];
+// under 'last' the holding that acted takes the whole beat (money.js payouts); under 'none', mainnet's case, no holding
+// mines: beats pay the lab wallet, and holdings are funded from it. Labs saved before v1.6 split.
+export const RULES = ['split', 'last', 'none'];
 export function miningPreference(value) {
   const rule = value?.rule ?? 'split', rigs = {};
   if (!RULES.includes(rule)) throw new Error('Invalid mining rule.');
@@ -39,18 +41,26 @@ export function miningPreference(value) {
   }
   return { rule, rigs };
 }
-export const emptyLab = () => ({ wallet: null, chain: new LocalChain(), clock: clockPreference(), keys: emptyKeys(), mining: miningPreference() });
+// Standing offers on items (./offers.js), open or stale until withdrawn; accepted ones stay as the deals' receipts.
+// Labs saved before v1.7 have none.
+export function offersPreference(list = []) {
+  if (!Array.isArray(list) || list.length > 1000) throw new Error('Invalid offers.');
+  const out = list.map(decodeOffer);
+  if (new Set(out.map(o => o.txid)).size !== out.length) throw new Error('Invalid offers.');
+  return out;
+}
+export const emptyLab = () => ({ wallet: null, chain: new LocalChain(), clock: clockPreference(), keys: emptyKeys(), mining: miningPreference(), offers: [] });
 
 export function decodeLab(raw) {
   if (!raw) return emptyLab();
   const data = JSON.parse(raw);
   if (data?.kind !== 'orgchain-lab' || data.network !== NETWORK || data.version !== 1) throw new Error('That is not an Orgchain v1 lab.');
   return { wallet: data.wallet ? TestWallet.load(data.wallet) : null, chain: new LocalChain(data.chain), clock: clockPreference(data.clock),
-    keys: keysPreference(data.keys), mining: miningPreference(data.mining) };
+    keys: keysPreference(data.keys), mining: miningPreference(data.mining), offers: offersPreference(data.offers) };
 }
 export const encodeLab = lab => JSON.stringify({ kind: 'orgchain-lab', network: NETWORK, version: 1,
   wallet: lab.wallet?.backup() ?? null, chain: lab.chain.snapshot(), clock: clockPreference(lab.clock), keys: keysPreference(lab.keys),
-  mining: miningPreference(lab.mining) });
+  mining: miningPreference(lab.mining), offers: offersPreference(lab.offers) });
 // Set a holding's hashrate, or the mining rule.
 export function setRigs(lab, id, n) { lab.mining = miningPreference({ ...lab.mining, rigs: { ...lab.mining?.rigs, [id]: n } }); }
 export function setRule(lab, rule) { lab.mining = miningPreference({ ...lab.mining, rule }); }
diff --git a/tests/money.test.js b/tests/money.test.js
index 16be3be..4765f6a 100644
--- a/tests/money.test.js
+++ b/tests/money.test.js
@@ -1,6 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { Tx } from '@cmdcode/tapscript';
+import { Signer, Tx } from '@cmdcode/tapscript';
+import { TestWallet } from '../src/adapters/wallet.js';
 import { secp256k1 } from '@noble/curves/secp256k1';
 import { bytesToHex } from '@noble/curves/abstract/utils';
 import { LocalChain } from '../src/adapters/chain.js';
@@ -47,6 +48,31 @@ test('the toy chain mines to SegWit, splits a coinbase, and moves P2WPKH spends
   assert.deepEqual([copy.balance(a.script), copy.balance(b.script)], [2.5 * REWARD - SAT - FEE, SAT + REWARD / 2]);
 });
 
+test('ordinary spends take up to eight inputs and outputs, and a key-path signature may be SINGLE|ANYONECANPAY', () => {
+  const chain = new LocalChain(), seller = TestWallet.create(), buyer = TestWallet.create();
+  chain.mine(seller.script);
+  chain.mine(buyer.script);
+  const [s] = chain.coins(seller.script), [b] = chain.coins(buyer.script), vin = c => getVin(c.txid, c.vout, c.value, c.scriptPubKey);
+  const fan = n => { const tx = Tx.create({ vin: [vin(b)], vout: Array.from({ length: n }, (_, i) => getVout(i < n - 1 ? SAT : b.value - (n - 1) * SAT - FEE, buyer.script)) }); tx.vin[0].witness = [buyer.sign(tx)]; return Tx.encode(tx).hex; };
+  assert.throws(() => chain.submitPackage([fan(9)]), /Unsupported transaction shape/);
+  chain.submitPackage([fan(8)]);
+  assert.equal(chain.coins(buyer.script).length, 8);
+  // A sell order: the seller signs its coin and the output it wants paid, and nothing else; a buyer fills it later.
+  const order = Tx.create({ vin: [vin(s)], vout: [getVout(s.value - FEE, seller.script)] });
+  const sig = Signer.taproot.sign(seller.secret, order, 0, { sigflag: 0x83 }).hex;
+  assert.match(sig, /^[0-9a-f]{128}83$/);
+  const [c] = chain.coins(buyer.script), fill = (paid = s.value - FEE) => {
+    const tx = Tx.create({ vin: [vin(s), vin(c)], vout: [getVout(paid, seller.script), getVout(c.value - (paid - (s.value - FEE)), buyer.script)] });
+    tx.vin[0].witness = [sig];
+    tx.vin[1].witness = [buyer.sign(tx, undefined, 1)];
+    return Tx.encode(tx).hex;
+  };
+  assert.throws(() => chain.submitPackage([fill(s.value - FEE - 1000)]), /Invalid signature/); // the seller's output is fixed
+  chain.submitPackage([fill()]);
+  chain.mine(buyer.script);
+  assert.equal(chain.balance(seller.script), REWARD - FEE);
+});
+
 test('every act pays its own gas, and an unfunded node is stopped before anything is signed', () => {
   const lab = emptyLab();
   const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
@@ -135,7 +161,7 @@ test('graduation moves money to the new keys, and the graduate pays its own clai
   seedSample(lab);
   const { now, log, live } = money(lab);
   assert.deepEqual(now, { yolopreneur: 300 * SAT - 50 * SAT - 2 * FEE - TOPUP, 'well-known': 8 * SAT - FEE - TOPUP,
-    lineage: 2 * SAT - FEE - TOPUP, time: 38.5 * SAT - 2 * FEE - 3 * TOPUP, sol: SAT, luna: 0.5 * SAT });
+    lineage: 2 * SAT - FEE - TOPUP, time: 38.5 * SAT - 2 * FEE - 3 * TOPUP, sol: SAT - TOPUP, luna: 0.5 * SAT });
   assert.deepEqual(log.slice(-2), [['move', 7, 'lineage', 'lineage', 2 * SAT - FEE], ['gas', 7, 'lineage', 'lineage', 10_000]]);
   const lineage = [...live.nodes.values()].find(n => n.name === 'lineage');
   assert.equal(lab.chain.balance(payerOf(lab.keys, live, lineage).script), 2 * SAT - FEE - TOPUP);
diff --git a/tests/offers.test.js b/tests/offers.test.js
new file mode 100644
index 0000000..b7b7e9d
--- /dev/null
+++ b/tests/offers.test.js
@@ -0,0 +1,169 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { MetadataIndex } from '../src/adapters/metadata-index.js';
+import { lineageEvents, reduce } from '../src/orgchain/lineage.js';
+import { decodeLab, emptyLab, encodeLab, setRule, setTempo } from '../src/orgchain/store.js';
+import { accept, act, deposit, lastHolding, lineageState, minerOf, offer, seedSample, send, withdraw } from '../src/orgchain/actions.js';
+import { FEE, REWARD, SAT, balances, ledger, most, owners, payerOf, tanks } from '../src/orgchain/money.js';
+import { holderOfItem, offerStatus, offerWhy } from '../src/orgchain/offers.js';
+
+const TOPUP = 10_000 + FEE; // what one gas top-up takes from a node's money
+// A lab's money as the app sees it, deals named by the lab's offers: balances by name, and the ledger as
+// [kind, beat, from, to, amount].
+function money(lab, upTo) {
+  const events = lineageEvents(new MetadataIndex(lab.chain)), live = reduce(events, { pending: true });
+  const owner = owners(lab.keys, events, live), name = id => live.nodes.get(id)?.name ?? null;
+  const deals = new Map((lab.offers ?? []).map(o => [o.txid, o]));
+  return { events, live, now: Object.fromEntries([...balances(lab.chain, owner, upTo)].map(([id, v]) => [name(id), v])),
+    log: ledger(lab.chain, owner, tanks(lab.keys, events, live), deals).map(m => [m.kind, m.beat, name(m.from), name(m.to), m.amount]) };
+}
+const holder = (lab, item) => { const { events, live } = money(lab); return holderOfItem(lab, events, live, item)?.node.name ?? null; };
+const status = (lab, o) => offerStatus(lab, lineageState(lab), o);
+
+test('make records an item its maker holds, and the reducer vets it', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), bot = act(lab, 'birth', acme, { name: 'bot', kind: 'agent' });
+  send(lab, acme, bot, SAT);
+  const kit = act(lab, 'make', bot, { name: 'kit', note: '  A starter kit.  ' });
+  const s = lineageState(lab);
+  assert.deepEqual(s.items.get(kit), { id: kit, name: 'kit', note: 'A starter kit.', maker: bot, beat: 5 });
+  assert.deepEqual(s.nodes.get(bot).made, [kit]);
+  assert.equal(s.log.at(-1).root, acme);
+  assert.equal(holder(lab, kit), 'bot');
+  assert.throws(() => act(lab, 'make', bot, { name: 'kit' }), /^Error: There is already a kit by bot\.$/);
+  assert.throws(() => act(lab, 'make', bot, { name: 'Kit!' }), /^Error: Names are 1-40 lowercase/);
+  act(lab, 'make', acme, { name: 'kit' }); // another maker may use the name
+  act(lab, 'close', bot, {});
+  assert.throws(() => act(lab, 'make', bot, { name: 'more' }), /^Error: The maker is closed\.$/);
+  assert.equal(lineageState(lab).items.size, 2);
+});
+
+test('an offer stands until the holder accepts; then the item and the price change hands in one transaction', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), beta = act(lab, 'found', null, { name: 'beta' });
+  const kit = act(lab, 'make', acme, { name: 'kit', note: 'A starter kit.' });
+  const before = money(lab).now, height = lab.chain.blocks.length;
+  const o = offer(lab, kit, beta, 2 * SAT);
+  assert.equal(lab.chain.mempool.length, 0); // an offer is signatures, not a transaction
+  assert.equal(lab.chain.blocks.length, height);
+  assert.equal(status(lab, o), 'open');
+  assert.throws(() => offer(lab, kit, beta, SAT), /^Error: beta already has an open offer on kit\. Withdraw it first\.$/);
+  assert.throws(() => offer(lab, kit, acme, SAT), /^Error: acme already holds kit\.$/);
+  assert.throws(() => offer(lab, kit, beta, 100), /^Error: Offer nothing, or at least 330 sats\.$/);
+  assert.throws(() => offer(lab, kit, beta, 51 * SAT), /at most 50 test BTC/);
+  accept(lab, o.txid);
+  assert.equal(lab.chain.blocks.length, height + 1);
+  assert.equal(holder(lab, kit), 'beta');
+  const after = money(lab);
+  assert.deepEqual(after.log.at(-1), ['deal', height + 1, 'beta', 'acme', 2 * SAT]);
+  assert.equal(after.now.acme, before.acme + 2 * SAT + REWARD / 2);
+  assert.equal(after.now.beta, before.beta - 2 * SAT - FEE + REWARD / 2);
+  const { tx } = lab.chain.transactions.get(o.txid);
+  assert.deepEqual(tx.vout.map(v => Number(v.value)), [1000, 2 * SAT, o.change]);
+  assert.equal(tx.vin[0].witness.length, 1); // the holder's Taproot signature on the item; the buyer's SegWit ones follow
+  assert.ok(tx.vin.slice(1).every(i => i.witness.length === 2));
+  assert.equal(status(lab, o), 'done');
+  assert.throws(() => accept(lab, o.txid), /already accepted/);
+  assert.throws(() => withdraw(lab, o.txid), /on the chain now/);
+  const back = offer(lab, kit, acme, 0); // a free claim back: the buyer pays only the fee
+  accept(lab, back.txid);
+  assert.equal(holder(lab, kit), 'acme');
+  assert.deepEqual(money(lab).log.at(-1), ['deal', height + 2, 'acme', 'beta', 0]);
+});
+
+test('payments spend unpromised coins first; an offer goes stale when a coin it promised moves', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
+  send(lab, acme, ops, SAT);
+  send(lab, acme, ops, SAT);
+  const kit = act(lab, 'make', acme, { name: 'kit' });
+  const o = offer(lab, kit, ops, 0.5 * SAT);
+  send(lab, ops, acme, 0.2 * SAT);
+  send(lab, ops, acme, 0.7 * SAT);
+  assert.equal(status(lab, o), 'open'); // both sends spent the coin the offer did not promise
+  send(lab, ops, acme, 0.5 * SAT);
+  assert.equal(status(lab, o), 'stale');
+  assert.equal(offerWhy(lab, lineageState(lab), o), 'ops has spent a coin the offer promised');
+  assert.throws(() => accept(lab, o.txid), /^Error: This offer is stale: ops has spent a coin the offer promised\.$/);
+  withdraw(lab, o.txid);
+  assert.deepEqual(lab.offers, []);
+  const beta = act(lab, 'found', null, { name: 'beta' }), first = offer(lab, kit, ops, 0.1 * SAT), second = offer(lab, kit, beta, SAT);
+  accept(lab, second.txid);
+  assert.equal(offerWhy(lab, lineageState(lab), first), 'kit has moved since');
+});
+
+test('a graduation leaves items at the old key: priced offers to it go stale, and it still signs for what it held', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
+  const beta = act(lab, 'found', null, { name: 'beta' });
+  send(lab, acme, ops, 2 * SAT);
+  const kit = act(lab, 'make', ops, { name: 'kit' });
+  const priced = offer(lab, kit, beta, SAT);
+  act(lab, 'graduate', acme, { of: ops });
+  assert.equal(offerWhy(lab, lineageState(lab), priced), 'ops has new keys since'); // its price would reach ops's old address
+  assert.equal(holder(lab, kit), 'ops'); // the item stays at ops's derived key, which the lab can still sign with
+  withdraw(lab, priced.txid);
+  const again = offer(lab, kit, beta, SAT);
+  accept(lab, again.txid);
+  assert.equal(holder(lab, kit), 'beta');
+  assert.deepEqual(money(lab).log.at(-1).slice(2), ['beta', 'ops', SAT]);
+});
+
+test('a cued deal counts for the holder that accepted it, and offers survive a backup', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), beta = act(lab, 'found', null, { name: 'beta' });
+  const kit = act(lab, 'make', acme, { name: 'kit' });
+  setRule(lab, 'last');
+  setTempo(lab, 30, 1000);
+  const o = offer(lab, kit, beta, SAT);
+  const copy = decodeLab(encodeLab(lab));
+  assert.deepEqual(copy.offers, lab.offers);
+  accept(copy, o.txid, 2000);
+  assert.equal(lastHolding(copy), acme);
+  assert.deepEqual(money(copy).log.at(-1), ['deal', null, 'beta', 'acme', SAT]);
+  const bad = JSON.parse(encodeLab(lab));
+  bad.offers[0].price = 5;
+  assert.throws(() => decodeLab(JSON.stringify(bad)), /Invalid offer/);
+});
+
+test('on mainnet no holding mines: beats pay the lab wallet, and holdings are funded from it', () => {
+  const lab = emptyLab();
+  setRule(lab, 'none');
+  const acme = act(lab, 'found', null, { name: 'acme' });
+  assert.equal(minerOf(lab, acme), null);
+  assert.deepEqual(money(lab).now, {});
+  assert.throws(() => act(lab, 'birth', acme, { name: 'ops' }), /^Error: acme has no test BTC for gas\. Fund it from the lab wallet\.$/);
+  deposit(lab, acme, 5 * SAT);
+  assert.deepEqual(money(lab).log, [['fund', 3, null, 'acme', 5 * SAT]]);
+  const ops = act(lab, 'birth', acme, { name: 'ops' });
+  assert.throws(() => deposit(lab, ops, SAT), /Pick a holding to fund/);
+  assert.throws(() => deposit(lab, acme, 51 * SAT), /at most 50 test BTC/);
+  setTempo(lab, 'manual');
+  const height = lab.chain.blocks.length;
+  for (let i = 0; i < 4; i++) deposit(lab, acme, REWARD);
+  assert.ok(lab.chain.blocks.length > height); // the lab wallet runs short, and a beat refills it
+  assert.equal(money(lab).now.acme, 5 * SAT + 4 * REWARD - TOPUP);
+  assert.equal(decodeLab(encodeLab(lab)).mining.rule, 'none');
+});
+
+test('a payment can spend up to eight coins', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
+  for (let i = 0; i < 3; i++) send(lab, acme, ops, 20 * SAT);
+  const txid = send(lab, ops, acme, REWARD); // three coins: more than the two the chain used to take
+  assert.equal(lab.chain.transactions.get(txid).tx.vin.length, 3);
+  for (let i = 0; i < 9; i++) send(lab, acme, ops, SAT);
+  const wallet = payerOf(lab.keys, lineageState(lab), lineageState(lab).nodes.get(ops));
+  const small = lab.chain.coins(wallet.script).filter(c => c.value === SAT);
+  assert.equal(most(small), 8 * SAT - FEE);
+});
+
+test('the sample ends on a standing offer: lineage bids for the launch kit sol made', () => {
+  const lab = emptyLab();
+  seedSample(lab);
+  const [o] = lab.offers, s = lineageState(lab), name = id => s.nodes.get(id).name;
+  assert.deepEqual([s.items.get(o.item).name, name(o.buyer), name(o.seller), o.price, status(lab, o)], ['launch-kit', 'lineage', 'sol', 0.1 * SAT, 'open']);
+  accept(lab, o.txid);
+  assert.equal(holder(lab, o.item), 'lineage');
+  assert.deepEqual(money(lab).log.at(-1), ['deal', 8, 'lineage', 'sol', 0.1 * SAT]);
+});
diff --git a/tests/orgchain.spec.js b/tests/orgchain.spec.js
index 8055a9b..7565cfe 100644
--- a/tests/orgchain.spec.js
+++ b/tests/orgchain.spec.js
@@ -233,3 +233,70 @@ test('the sample replays, any beat can be inspected, and the lab survives a relo
   await expect(page.locator('#holdings-list li')).toHaveCount(0);
   expect(problems).toEqual([]);
 });
+
+test('a node makes an item, another holding bids on it, the holder accepts; on mainnet holdings are funded', async ({ page }) => {
+  const problems = await open(page), inspect = page.locator('#inspect-body'), why = page.locator('#act-why');
+  const hold = name => page.locator('#holdings-list .hold', { has: page.locator('.hn', { hasText: new RegExp(`^${name}$`) }) });
+  await found(page, 'acme');
+  await expect(say(page)).toHaveText('acme is founded, at beat 2.');
+  await found(page, 'beta');
+  await expect(say(page)).toHaveText('beta is founded, at beat 3.');
+  await verb(page, 'offer');
+  await expect(why).toHaveText('Nobody else holds an item yet. Items come from Make.');
+  await hold('acme').click();
+  await verb(page, 'make');
+  await expect(page.locator('#f-make .hint')).toContainText('public and permanent');
+  await page.locator('#make-name').fill('Kit');
+  await page.locator('#make-note').fill('A starter kit.');
+  await submit(page, 'make');
+  await expect(say(page)).toHaveText('acme made kit, at beat 4.');
+  await expect(page.locator('#timeline-list')).toContainText('make kit · acme');
+  await expect(inspect).toContainText('kit · A starter kit. (made at beat 4)');
+  await hold('beta').click();
+  await verb(page, 'offer');
+  await expect(page.locator('#act-gas')).toHaveText("Fee: 500 sats, from beta's balance, paid only if the holder accepts.");
+  await page.locator('#offer-item').selectOption({ label: 'kit · held by acme' });
+  await page.locator('#offer-price').fill('2');
+  await submit(page, 'offer');
+  await expect(say(page)).toHaveText('beta offers 2 tBTC for kit. The offer stands until acme accepts it.');
+  await expect(page.locator('#clock-beat')).toHaveText('4'); // an offer is signatures, not a transaction
+  await expect(inspect).toContainText('2 tBTC for kit (open until acme accepts)');
+  await hold('acme').click();
+  await expect(inspect).toContainText('beta offers 2 tBTC');
+  await inspect.getByRole('button', { name: "Accept beta's offer for kit" }).click();
+  await expect(say(page)).toHaveText('acme accepted: kit goes to beta for 2 tBTC, at beat 5.');
+  await expect(inspect).toContainText('kit · A starter kit. (now held by beta)');
+  await page.locator('#timeline-list .ev', { hasText: 'kit acme → beta, for 2 tBTC' }).click();
+  for (const text of ['Price', '2 tBTC', "beta's SegWit key (SIGHASH_ALL) when it made the offer, then acme's Taproot key when it accepted"]) {
+    await expect(inspect).toContainText(text);
+  }
+  await page.locator('[data-rule="none"]').click();
+  await expect(say(page)).toHaveText('Mainnet: no holding mines. Beats pay the lab wallet, and you fund holdings from it.');
+  await expect(page.locator('#clock-pays')).toHaveText('beats pay the lab wallet');
+  await page.locator('#fund-to').selectOption({ label: 'beta' });
+  await page.locator('#fund-amount').fill('3');
+  await page.locator('#f-fund [type="submit"]').click();
+  await expect(say(page)).toHaveText('The lab wallet funded beta with 3 tBTC, at beat 6.');
+  await hold('beta').click();
+  await expect(page.locator('#timeline-list')).toContainText('3 tBTC lab wallet → beta');
+  await expect(page.locator('#holdings-list')).not.toContainText('of each beat');
+  expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
+  expect(problems).toEqual([]);
+});
+
+test('the sample ends on a standing offer, and its holder accepts it', async ({ page }) => {
+  const problems = await open(page), inspect = page.locator('#inspect-body');
+  await page.locator('#sample').click();
+  await expect(say(page)).toContainText('Loaded the yolopreneur sample', { timeout: 20_000 });
+  await row(page, 'lineage').click();
+  await expect(inspect).toContainText('0.1 tBTC for launch-kit (open until sol accepts)');
+  await row(page, 'sol').click();
+  await expect(inspect).toContainText('launch-kit · The page, the post and the checklist every venture launches with.');
+  await inspect.getByRole('button', { name: "Accept lineage's offer for launch-kit" }).click();
+  await expect(say(page)).toHaveText('sol accepted: launch-kit goes to lineage for 0.1 tBTC, at beat 8.');
+  await expect(page.locator('#timeline-list')).toContainText('launch-kit sol → lineage, for 0.1 tBTC');
+  await row(page, 'lineage').click();
+  await expect(inspect).toContainText('launch-kit · The page, the post and the checklist every venture launches with. (made by sol at beat 6)');
+  expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
+  expect(problems).toEqual([]);
+});