From c8c18b073e8ed1be5651d0ffbfe7dce2d43d7adb Mon Sep 17 00:00:00 2001 From: teahubxyz Date: Thu, 15 Oct 2026 15:48:31 -0700 Subject: [PATCH] Orgchain v1.14: soulbound belts ride their seats' sats A belt is soulbound: the reducer already bound it to the seat it names, and now the lab inscribes it on that seat's own sat, so by ordinal theory it goes wherever the seat goes and never sells apart from it. One reveal carries an award, three coins in: the seat's, which the pointer puts the belt in and the seat's own key signs, accepting it; the issuer's, the parent; and the commit, which pays the fee. Both coins come back unchanged, so an award needs no postage and costs two fees (1,000 sats). ord marks it a reinscription and vindicated, since a pointer and an envelope past the first input would have cursed it before the jubilee. The engine takes that three-input reveal and nothing looser: the parent spent from the inscriber's key, both coins returned unchanged, the pointer on an inscribed sat of the first. A belt is never a lot, and an award can't land in a tree that is listed or sold. Trees count and split by inscribed sat, so a seat's belts stay on it through every sale. Inspect shows a node's belts and ord's charms, and the award form says whose sat the belt will ride. Belts from before v1.14 stay with their issuers and count the same. Rehearsed on Bitcoin Core regtest from height 161: sixteen beats and 131 transactions; ord charms the three belts as the lab does, and after two whole-tree sales each belt shares its seat's satpoint. The compare now checks satpoints and charms. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01H4upF5LVwmPDDqrhdUfnXh --- AGENTS.md | 16 ++-- PROVENANCE.md | 2 +- README.md | 66 +++++++++------- SPEC.md | 38 +++++---- index.html | 3 +- src/adapters/chain.js | 41 ++++++---- src/indexer/compare.js | 15 +++- src/indexer/ord.js | 3 +- src/main.js | 42 +++++++--- src/orgchain/actions.js | 37 ++++++--- src/orgchain/belts.js | 53 +++++++++++++ src/orgchain/offers.js | 10 ++- tests/belts.test.js | 107 ++++++++++++++++++++++++++ tests/fixtures/regtest-rehearsal.json | 2 +- tests/indexer.test.js | 7 +- tests/keys.test.js | 7 +- tests/orgchain.spec.js | 6 +- tools/regtest/README.md | 20 ++--- 18 files changed, 368 insertions(+), 107 deletions(-) create mode 100644 src/orgchain/belts.js create mode 100644 tests/belts.test.js diff --git a/AGENTS.md b/AGENTS.md index 8aa548e..da8b7bf 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -11,8 +11,9 @@ Orgchain is lineage's app for creating and operating lineage holdings on Super T - 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, a coinbase split across up to 64 outputs, ordinary spends of up to 64 inputs and - outputs whose key-path signatures may carry 0x83, coins imported from a real chain, and BIP-341/342 checks of - reveals' script paths, all in `src/adapters/chain.js` (PROVENANCE.md); keep them small and tested. + outputs whose key-path signatures may carry 0x83, a three-input reveal that inscribes on a sat another key holds + (a belt) and returns both coins unchanged, coins imported from a real chain, and BIP-341/342 checks of reveals' + script paths, 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 @@ -24,9 +25,14 @@ Orgchain is lineage's app for creating and operating lineage holdings on Super T who holds a lot is read off the chain, never from metadata. An org sells with its tree, and a holding whole, by its owner (the lab wallet): cash-free, and frozen with everything in it while listed or sold (`actions.js` cashOut, frozenWhy; a listed holding mines nothing). A tree travels as one output (`bundle` for an ask; an offer merges its - inputs) and splits back by the deal's layout once adopted (`unbundle`): one output per inscription, never two - inscriptions left sharing a coin, or selling one would sell the other. Its buyer's keys sign the adoption and the - split: never sign for the buyer at the seller's act. + inputs) and splits back by the deal's layout once adopted (`unbundle`): one output per inscribed sat, never two + sats' inscriptions left sharing a coin, or selling one would sell the other. Its buyer's keys sign the adoption and + the split: never sign for the buyer at the seller's act. +- Belts are soulbound (`src/orgchain/belts.js`): the reducer binds a belt to the node it names, and the lab inscribes + it on that node's own sat (a reinscription) in one three-input reveal that the recipient's key co-signs, so it goes + wherever its node goes. Count and split coins by inscribed sat, never by inscription, since a node shares its sat + with its belts, and never make a belt a lot. The compare checks ord's satpoints and charms (`charmsOf` models the + ones lineage's inscriptions earn); keep that model in step with ord. - Moves (`join`, `adopt`): neither half's effect may depend on their order within a block, since a miner may put them either way; the move records both halves. An old parent keeps a moved child in `children` so its index is never reused: walk children with `kidsOf`. A holding that moves becomes an org: its old root stays in `keys.roots` so old diff --git a/PROVENANCE.md b/PROVENANCE.md index d0f008a..a21dde1 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, NIP-06 and BIP-44 Ethereum 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). -Five 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. Orgchain v1.9: a chain may start from coins imported from a real chain (`importCoin`; `MetadataIndex` numbers their sats the same way, `importRanges` in `src/adapters/sats.js`), so the regtest rehearsal can broadcast the lab's transactions byte for byte; and a reveal's script path is checked per BIP-341 and BIP-342 against the exact script bytes (`tapscriptValid`), with tapscript's own check kept as a fallback so labs saved earlier still load. That rehearsal also found that the inscription adapter (`src/adapters/inscription.js`, adapted from inscriptions-online) committed its reveals to tapscript's `encodeScript` of a hex script, which re-encodes one-byte pushes, so real Bitcoin rejected them; it now commits to the exact bytes (`tapleafOf`). Tested in `tests/indexer.test.js`. +Six local changes to the engine, all original code in `src/adapters/chain.js`, tested in `tests/money.test.js` unless noted, 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. Orgchain v1.13 raised `MAX_IO` to 64, so a whole tree can travel in one transaction. Orgchain v1.9: a chain may start from coins imported from a real chain (`importCoin`; `MetadataIndex` numbers their sats the same way, `importRanges` in `src/adapters/sats.js`), so the regtest rehearsal can broadcast the lab's transactions byte for byte; and a reveal's script path is checked per BIP-341 and BIP-342 against the exact script bytes (`tapscriptValid`), with tapscript's own check kept as a fallback so labs saved earlier still load. That rehearsal also found that the inscription adapter (`src/adapters/inscription.js`, adapted from inscriptions-online) committed its reveals to tapscript's `encodeScript` of a hex script, which re-encodes one-byte pushes, so real Bitcoin rejected them; it now commits to the exact bytes (`tapleafOf`). Tested in `tests/indexer.test.js`. Orgchain v1.14: a reveal may take three inputs to inscribe on a sat another key holds (a belt, on its recipient's own sat): that sat's coin, whose holder co-signs; the parent's coin, at the inscriber's key; and the commit, which pays the fee. Both coins come back unchanged, and the pointer must name an inscribed sat of the first. Other reveals keep their two-in, two-out shape. Tested in `tests/belts.test.js`. Keyrings (`src/orgchain/keyring.js`, original code) sign with each chain's own message standard: BIP-322 simple signatures, EIP-191 `personal_sign`, and a NIP-01 event. `tests/keyring.test.js` pins BIP-322's published vectors, and values that bip322-js 3.0.0, ethers 6 and nostr-tools 2 produced or accepted in a one-time cross-check; none of those is a dependency. diff --git a/README.md b/README.md index 246f27e..3693d9f 100644 --- a/README.md +++ b/README.md @@ -7,13 +7,13 @@ 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, - in any holding: a registry like well-known certifies agents it doesn't hold). **Decide** (a decision on a node's - record). **Make** an item (an inscription its maker holds, and can sell). **Buy** an item, an org or a whole holding, - and **Sell** your own (both sides of a deal, below). **Keyring** (a node publishes its keys on each chain, each - key signing the same statement). **Charter** (a node's legal form, from sole proprietor to series LLC). **Graduate** - an org or an agent: its edge flips from derived to adopted, and it becomes a holding of its own, with its own tree, - timeline and share of the mining, while its parent's tree keeps a row for it. **Close** a node (derived children close - with it; graduated ones hold their own roots and stay open). + in any holding: a registry like well-known certifies agents it doesn't hold), soulbound to its seat. **Decide** (a + decision on a node's record). **Make** an item (an inscription its maker holds, and can sell). **Buy** an item, an org + or a whole holding, and **Sell** your own (both sides of a deal, below). **Keyring** (a node publishes its keys on + each chain, each key signing the same statement). **Charter** (a node's legal form, from sole proprietor to series + LLC). **Graduate** an org or an agent: its edge flips from derived to adopted, and it becomes a holding of its own, + with its own tree, timeline and share of the mining, while its parent's tree keeps a row for it. **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. @@ -29,11 +29,12 @@ chain itself records who did what, and when. 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 raw transaction (`src/orgchain/money.js`). -- **Gas.** Every act is paid by the acting node's own keys: its inscription's two fees and postage (2,000 sats), - plus 500 for each handoff it makes. They come out of its gas tank, the plain coins at its Taproot key, which tops - 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. +- **Gas.** Every act is paid by the acting node's own keys: its inscription's two fees and postage (2,000 sats; an + award rides its seat's sat, so it needs no postage and costs 1,000), plus 500 for each handoff it makes. They come + out of its gas tank, the plain coins at its Taproot key, which tops 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.** Both sides of OpenOrdex's partially signed transaction, on a lot: an item, which its holder sells; an org inside a holding, which its parent sells with its tree; or a whole holding, which its owner sells (the lab wallet plays the owner). **Buy** makes an offer, the buy order: the buyer's SegWit key signs the whole deal at once @@ -55,11 +56,18 @@ chain itself records who did what, and when. tree sits in and merges them into one. The buyer then adopts it: a `join`, signed by the key that now holds its inscription, and an `adopt`, signed by the buyer, move it into the buyer's tree at the buyer's next index (a holding becomes an org there), where its keys and its tree's derive from the buyer's seed. Then the coin it came in splits - back, each node's inscription to its new key and each item to the node that held it, by the layout the deal kept. - Taking an ask adopts at once; after an accepted offer the buyer adopts when it's ready. The seller's tree keeps a row - at the old index, marked with where the org went, and a holding bought whole brings its history into its buyer's - timeline. The sample ends with both sides standing: lineage's offer for the launch kit, and well-known's ask for - mailr; selling time with its ventures, or yolopreneur whole, is one Sell away. + back, each node's inscription to its new key, its belts on the same sat, and each item to the node that held it, by + the layout the deal kept. Taking an ask adopts at once; after an accepted offer the buyer adopts when it's ready. The + seller's tree keeps a row at the old index, marked with where the org went, and a holding bought whole brings its + history into its buyer's timeline. The sample ends with both sides standing: lineage's offer for the launch kit, and + well-known's ask for mailr; selling time with its ventures, or yolopreneur whole, is one Sell away. +- **Belts.** A belt is soulbound: it belongs to the seat it names, and Orgchain inscribes it on that seat's own sat, + so it moves with the seat through every act, graduation and sale, and never sells on its own. One reveal carries it, + three coins in: the seat's, which the pointer puts the belt in and the seat's key signs, accepting it; the issuer's, + the parent that authorizes it; and the commit, which pays the fee. Both coins come back unchanged. `ord` gives the + belt two charms: ♻️ reinscription, since its sat already carries the seat's inscription, and ❤️‍🔥 vindicated, since a + pointer and an envelope past the first input would have cursed it before the jubilee. Inspect lists a node's belts + with their charms (`src/orgchain/belts.js`); belts awarded before v1.14 stay with their issuers. - **Keyrings.** **Keyring** publishes a node's keys in one inscription whose parent is the node itself: its Taproot and SegWit addresses, its npub and its Ethereum address, so another chain or a registry like well-known can find them without deriving anything. Every key signs the same statement, the way its own wallets sign a message: BIP-322 for the @@ -109,7 +117,7 @@ keyring's is the statement its keys signed). | --- | --- | --- | | `found` | none | `name` | | `birth` | the parent | `name`, `kind` (`org` or `agent`) | -| `award` | the issuing org or holding (`to` may sit in any holding) | `to`, `skill`, `belt` (`white`, `green`, `black`) | +| `award` | the issuing org or holding (`to` may sit in any holding, and co-signs: the belt goes on its sat) | `to`, `skill`, `belt` (`white`, `green`, `black`) | | `decide` | the deciding node | `title`, `why` | | `make` | the making node, which then holds the item | `name`, `note` | | `keyring` | the node itself; the newest counts, and a graduation retires it | `taproot`, `segwit`, `nostr`, `ethereum`, and `proof` (each key's signature) | @@ -134,15 +142,16 @@ fold in, why a parent proves authority, and every rule the reducer applies. The node bin/lineage-index.mjs --ord http://127.0.0.1:8088 [--from ] [--compare ] ``` -`tools/regtest/` rehearses the sample, keyrings, asks, offers and whole trees changing hands included, on Bitcoin Core -regtest: the lab's own transactions, byte for byte, confirmed by Bitcoin Core and indexed by `ord`, which then tell the -same story as the lab (`tests/indexer.test.js` replays a recorded run). The first rehearsal found that the lab's reveals -committed to the wrong tapleaf, which real Bitcoin rejects; reveals are now checked the way Bitcoin checks them +`tools/regtest/` rehearses the sample, keyrings, belts, asks, offers and whole trees changing hands included, on Bitcoin +Core regtest: the lab's own transactions, byte for byte, confirmed by Bitcoin Core and indexed by `ord`, which then tell +the same story as the lab (`tests/indexer.test.js` replays a recorded run). The first rehearsal found that the lab's +reveals committed to the wrong tapleaf, which real Bitcoin rejects; reveals are now checked the way Bitcoin checks them (`SPEC.md`, section 1). The rehearsal of org sales found that a miner can put a join and its adoption in either order within a block, so a move records both halves and each half belongs to both holdings (`SPEC.md`, section 5). The rehearsal of whole trees sold an org with its six below it on an offer and a holding whole on an ask, bundling eleven -inscriptions into one coin and splitting them again, and `ord` put every one in the same output as the lab (`SPEC.md`, -section 7). +nodes into one coin and splitting them again, and `ord` put every inscription on the same sat as the lab (`SPEC.md`, +section 7). Three of those nodes wore belts, each inscribed on its own sat by a three-input reveal: `ord` charmed them +♻️ and ❤️‍🔥, and after both sales every belt was still on its seat's sat. ## Build and test @@ -161,11 +170,12 @@ 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 five +`src/miner.js`) are [Super Testnet](https://supertestnet.lol)'s, with their tests (`tests/adapters.test.js`) and six additions: the chain also moves native SegWit (P2WPKH) payments, BIP-143 signatures included; a coinbase may split -its reward across up to 64 outputs; ordinary spends take up to 64 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`); a chain may start from coins imported from a real chain; and reveals' +its reward across up to 64 outputs; ordinary spends take up to 64 inputs and outputs, whose key-path signatures may +carry SIGHASH_SINGLE|ANYONECANPAY, the sell-order flag 0x83 (`tests/money.test.js`); a reveal, otherwise two in and +two out, may inscribe on a sat another key holds, spending that sat's coin, its parent's and the commit and returning +both coins unchanged (`tests/belts.test.js`); a chain may start from coins imported from a real chain; and reveals' script paths are checked per BIP-341 and BIP-342 (`tests/indexer.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 diff --git a/SPEC.md b/SPEC.md index 58e1095..2a89137 100644 --- a/SPEC.md +++ b/SPEC.md @@ -18,11 +18,11 @@ lineage/v0 uses these fields of the ord envelope ([inscriptions](https://docs.or | 5 | metadata | a CBOR map: `op` and its fields (section 4), strings except a keyring's `proof` map, in 520-byte pushes (Orgchain keeps it under 2048 bytes) | | 3 | parent | the inscription id of the node that authorizes the event; exactly one, except for `found` | | 1 | content type | `text/plain;charset=utf-8`; the body is a short label such as `birth time` (a keyring's is its statement), ignored by the rules | -| 2 | pointer | puts a child's inscription in its own output when the parent is spent first | +| 2 | pointer | puts a child's inscription in its own output when the parent is spent first, and a belt on its recipient's sat (section 7) | The body, delegate (tag 11) and properties (tag 17) carry no meaning here; properties may later carry display traits -such as a belt's colour, never authority. Unknown odd tags are ignored. Never use unknown even tags: ord treats such an -inscription as unbound, so it has no location. +such as a belt's colour, never authority. Nor do ord's charms, such as a belt's (section 7). Unknown odd tags are +ignored. Never use unknown even tags: ord treats such an inscription as unbound, so it has no location. A reveal is a script-path spend whose tapleaf commits to the envelope script's exact bytes (BIP-341). Orgchain's reveals before v1.9 committed to a re-encoded script; real Bitcoin rejects those, and Orgchain's local chain still loads them. @@ -55,7 +55,7 @@ the inscription moves the authority. | --- | --- | --- | --- | | `found` | none | `name` | a holding; no active holding may already have that name | | `birth` | an active holding, org or graduated agent | `name`, `kind` (`org` or `agent`, default `org`) | a child; the parent may not already have an active child of that name | -| `award` | an active holding, org or graduated agent | `to`, `skill`, `belt` (`white`, `green` or `black`) | `to` (any other active node, in any holding) holds that belt in that skill, replacing its earlier belt in it | +| `award` | an active holding, org or graduated agent | `to`, `skill`, `belt` (`white`, `green` or `black`) | `to` (any other active node, in any holding) holds that belt in that skill, replacing its earlier belt in it; the belt is bound to `to`, whoever holds its inscription (section 7) | | `decide` | an active node | `title` (required), `why` (optional) | a decision on the node's record | | `make` | an active node | `name`, `note` (optional) | an item, made and first held by the node; a node makes one item per name | | `keyring` | the node itself, active | `taproot`, `segwit`, `nostr`, `ethereum`, and `proof`: each key's signature | the node's keys are bound to it, replacing its earlier keyring (section 8) | @@ -128,7 +128,8 @@ by one of its derived descendants; an award and its recipient's close; two found graduation or close that retires it; two keyrings that list the same key; a join or adoption and a graduation, close or birth that changes the moving node or its new parent. Orgchain keeps a keyring and the graduation that would retire it a block apart, and it freezes a tree that is listed or sold (section 7), so nothing in it acts, and nothing above it -graduates or closes it, before its buyer adopts it. +graduates or closes it, before its buyer adopts it. An Orgchain award spends its recipient's inscription as well as its +issuer's (section 7), so an award and its recipient's close are chained, in a fixed order. ## 7. Ownership, items and deals @@ -157,11 +158,21 @@ In Orgchain a deal on a tree goes like this: lot's own first, and pays them into one output at the lot's key, with a coin of the seller's last for the fee, so no inscription's sat pays it. The ask signs that output, and withdrawing the ask splits it back. - After the `join` and the `adopt`, the buyer splits the output it bought: one transaction with an output for each - inscription, running from its sat to the next one's (the first from the output's start), to the node's new key, or, - for an item, to the new key of the node that held it, which the deal records as its layout. + inscribed sat, running from it to the next one (the first from the output's start), to the new key of the node whose + inscription is on it, or, for an item, to the new key of the node that held it, which the deal records as its layout. + A sat's inscriptions never part, so a node's belts stay on its sat. - While a tree is listed or sold it is frozen: nothing in it acts or moves money, nothing above it graduates or closes - it, nothing in it sells alone, and a listed holding mines nothing. The records of a tree's events (decisions, belts, - keyrings and the like) are not part of it: they carry no authority, and stay where they landed. + it, nothing in it sells alone, and a listed holding mines nothing. The records of a tree's events (decisions, + keyrings and the like) are not part of it: they carry no authority, and stay where they landed. Its nodes' belts ride + their sats (below), so they come along. + +A belt is soulbound: it belongs to the node it names, whoever holds its inscription, and is never a lot. Orgchain +inscribes it on that node's own sat, so it goes wherever the node goes. The award's reveal spends three outputs: the +one holding `to`'s inscription, which its holder signs, accepting the belt; the issuer's, the parent; and the commit, +which pays the fee. It returns the first two unchanged, and its pointer (tag 2) is the offset of `to`'s sat in the +first, so the belt lands on that sat, a reinscription. ord charms it ♻️ reinscription and ❤️‍🔥 vindicated: a pointer, +or an envelope past the first input, would have cursed it before the jubilee. Orgchain's belts from before v1.14 sit +with their issuers, and count the same. ## 8. Keys and keyrings @@ -220,9 +231,10 @@ chain's own wallets sign a message. ## 10. Conformance -`tools/regtest` rehearses Orgchain's sample on Bitcoin Core regtest, byte for byte, keyrings, asks, offers and whole -trees changing hands included (bundled outputs and their splits too), and `bin/lineage-index.mjs --compare` checks that -ord and the lab tell the same story: the same events in the same beats, the same metadata and parents, the same trees -and keyrings, and every inscription in the same output. `tests/indexer.test.js` replays a recorded run. +`tools/regtest` rehearses Orgchain's sample on Bitcoin Core regtest, byte for byte, keyrings, belts, asks, offers and +whole trees changing hands included (bundled outputs and their splits too), and `bin/lineage-index.mjs --compare` +checks that ord and the lab tell the same story: the same events in the same beats, the same metadata and parents, the +same trees and keyrings, and every inscription on the same sat (ord's satpoint), with the same ♻️ reinscription and +❤️‍🔥 vindicated charms. `tests/indexer.test.js` replays a recorded run. `tests/keyring.test.js` checks the proofs against BIP-322's published vectors, the key tree page's Ethereum vector, and values cross-checked with bip322-js, ethers and nostr-tools. diff --git a/index.html b/index.html index 6ab6401..7ff351e 100644 --- a/index.html +++ b/index.html @@ -103,7 +103,7 @@