The Vulpine Protocol

Vulpine is a set of records on the BSV blockchain and a small number of rules for reading them. fwetch.lol, 4chain.wtf and Breddit are readers. Anyone can write these records from any wallet, index them with any software, and show them however they like. This document is the authority: where the code and this document disagree, this document is right and the code has a bug.

On the name: record tags on the wire are prefixed fwetch- — the first reader was Fwetch, and identifiers written to a blockchain are permanent. The prefix is not the protocol's name, any more than app.bsky.* is the AT Protocol's. The protocol is Vulpine. Any BRC-100 wallet works with it; the Vulpine wallet is one.

Everything on chain is the protocol. The index, the house, the chat server and the user interface are a service — one implementation — and are not.

New here? Start with the developers' page: reading in one line, signing and writing, and embeds, with examples that run.

In one minute

A record is an OP_FALSE OP_RETURN output with three pushes: the protocol's name, Vulpine; a tag; and a JSON payload whose p is that same tag. A post, for example:

OP_FALSE OP_RETURN  "Vulpine"  "fwetch-post"  {"p":"fwetch-post","b":"gm","t":1790000000,"app":"fwetch","pub":"02…","sig":"30…"}

The identifier

Every record is an OP_FALSE OP_RETURN whose pushes are, since 19 September 2026: the identifier Vulpine, the record's type, the JSON. Records written before that date carry no identifier (type, then JSON) and every reader accepts both shapes for ever. The identifier is one word for the whole network, not one per application, so an explorer that counts transactions by their first push counts Vulpine as one protocol. The application a record was made in is the app field inside it, as it always was.

1. Principles

  1. Recognition, not permission. Nobody can be stopped from writing to the chain. A record that does not follow these rules is simply not recognized: the post is not in the feed, the coin is not a number, the ad does not run.
  2. Chain order decides. Where two records conflict, the earlier one in chain order wins (§8). Every indexer derives the same answer from the same chain.
  3. The chain is the record; everything else is a cache. A reader may hold whatever it likes in a database, but must be able to rebuild it from the chain alone.
  4. Identity is a key, not an address. A member is an identity public key. Addresses are places their things live.
  5. Free to join, free to speak. Minting a number and posting cost nothing to the member. Money changes hands only when value does (§9).

2. Encoding

Records are OP_FALSE OP_RETURN outputs with two pushes: a tag and a UTF-8 JSON payload; or, for tokens, 1Sat Ordinals inscriptions carrying a MAP metadata block. Payload fields not listed here are ignored. Unknown tags are ignored. A record whose payload does not parse is ignored.

Numbers in payloads are JSON numbers. Timestamps (t) are Unix seconds. Transaction references are 64-hex txids; outpoints are txid_vout (in MAP) or txid.vout (in payloads) — readers must accept both.

3. Identity

3.1 The identity key

A member is a secp256k1 public key, the identity key (BRC-42 derivation [0, 'fwetch identity'], key id '1', counterparty anyone). Every signed record carries pub (33-byte compressed hex) and sig (DER hex) over the canonical JSON of the payload with sig removed and keys sorted.

A record is its signer's and nobody else's. One whose signature does not verify, or that carries none, is not attributed to any addr it names, nor to the key in an input of a transaction a client handed in: anybody may write those. Records written before signatures could be checked (the reader's STRICT_FROM, 5 September 2026) are read as they always were only when they were mined by block 965,560; a record mined after it, or not mined yet, is held to its signature whatever date it gives.

3.2 Address linking

A member may declare that other addresses are theirs (where their ordinals live) with a signed fwetch-link record listing them. A reader treats a member's identity address, its linked addresses, and any address that holds a coin the member signed for as one member.

A declaration (a fwetch-link, or a profile's ca and cas) proves nothing about who holds an address's key, so it takes only an address nobody has: not one linked to another member, and not another member's identity (one with a profile, links of its own, a signed record, a message or a session on the reader). The first to declare an unclaimed address keeps it.

Taking an address back (30 October 2026). The holder of an address's key takes it back from whoever declared it first with a proof: a message signature by that address's own key, made the way every Bitcoin wallet signs a message (BSM, base64), over

fwetch-link-proof|<identity address>|<address>|<t>

where t is the link's own time. A link carries its proofs beside its list, proofs: { <address>: <signature> }. An address with a valid proof is the signing identity's: the earlier declaration is dropped, and so is a profile's ca that named it. A proof names its identity and its time, so it serves no other identity and no later link. An identity's own address is never taken this way, proof or not.

3.2a The one-time pass

A wallet that asks its owner about every signature (HandCash does) would ask about every post and like. Instead the owner approves once: the identity signs a pass naming a session key that the site keeps, and the site signs everyday records with that key, each carrying the pass inside it (7 October 2026).

pass    { p: 'fwetch-pass', session: <session key>, site?, scope: 'social', t, expires, pub: <identity key>, sig }
record  { p, …, t, pass: <the pass>, pub: <session key>, sig: <the session key's signature, pass included> }

Both signatures are made as every record's is (§3.1). A record made this way is the identity's when: the pass verifies for its pub; its session is the record's pub; the record is one of fwetch-post, fwetch-like, fwetch-repost, fwetch-reaction, fwetch-vote, fwetch-reveal, fwetch-follow, fwetch-report, fwetch-chat (and a chat request's fwetch-chat-edit and fwetch-chat-react), a Babel page fwetch-article or link fwetch-edge (both from 7 October 2026, evening), a show fwetch-show or a playlist fwetch-playlist (16 October 2026), or a sponsor's fwetch-anon request proof; its t lies between the pass's t and expires; and the pass lasts at most 30 days. Anything else made under a pass (a profile, a link, a transfer, money, another pass) is not the identity's: the owner's wallet signs those itself. A pass ends early with fwetch-assert { type: 'pass-end', payload: { session } } signed by the session key (signing out) or by the identity; records the session signs after it are not the identity's. A reader checks all of this from the record alone, with no lookup except the pass-end.

3.3 Sessions and anonymity

Anonymous records carry no pub and no sig. They are attributed to nobody. A reader may accept a sponsor's vouching (§7.3) for facts about an anonymous record that the sponsor verified out of band (a flag, a per-thread tag), but never for identity.

3.4 Handles

A $handle is a name bound to an identity key: fwetch-name { name }, signed. Names are 3–20 characters of a–z 0–9 _, compared case-insensitively and shown as claimed ($Rodsirloin). The earliest claim in chain order holds the name; a claim on a held name is nothing. One name per identity (the whole linked set counts as one). { name, un: 1 } releases it; a released name stays reserved for its previous key for thirty days.

A handle is never a coin and cannot be sold — it is how people point at you, and everything that is about you (reviews, votes, reputation) points at the key behind it. Compare a number (§4), which points at a seat and is meant to change hands.

Three things, no overlap: about you → the identity and its handle; owned by you → a coin (a number, a board, a piece); allowed to you → a permission flag; earned by you → a badge.

4. Numbers (User Numbers)

A User Number is a 1-sat ordinal inscription whose MAP carries:

app=fwetch  type=ord  p=fwetch-handle  number=<N>  v=<FWONK_VERSION>
collectionId=<series collection id>  series=<series name>   (see §4.3)

The inscription content is the coin's image. A GLB model may be referenced.

4.1 The number rule

4.2 One number per identity

A reader must recognize at most one number per identity key, the earliest. A key that mints again does not gain a second number. Numbers may still be held in any quantity by transfer or purchase; the rule is about minting.

4.3 Series — lite and hard

A series is a collection that strikes number coins.

A series is recognized only if it is registered: a Series coin exists for it (§6.2). Unregistered series are ignored — their coins are ordinary inscriptions, not numbers.

5. Records

All payloads carry p naming the record type and t. Signed records carry pub and sig. Every record should carry app — the reader that wrote it (fwetch, breddit, …) — and may carry scope: public (the default; any reader may surface it) or local (meant for its origin app; other readers following this document do not surface it). Scope is the poster's choice. Identity, numbers, memes, boards and ads are never scoped.

tag / pfieldsnotes
fwetch-postb body (≤280 chars), reply parent txid, board slug, img image ref, meme meme txid, flag code, anon 1, pid poster tag, tr thread noncea post; a reply is a post with reply; a reply lives on its parent's board
fwetch-likepost txidone per member per post (kept for compatibility; fwetch-reaction is the general form)
fwetch-reactionpost txid, kindlike and dislike are defined; other kinds are allowed. One per member per post per kind. Each reader honours the kinds it chooses
fwetch-repostpost txid
fwetch-delegatenumber, add[], remove[]signed by the number's holder; lets those keys post as the number (§5.2)
fwetch-votepoll, then choice \commit \the encrypted envelopea vote (§5.3)
fwetch-revealpoll, choice, saltopens a sealed vote after close
fwetch-tallypoll, trustee, parts[]a trustee's partial decryption, with proofs
fwetch-profilename, pfp (b://txid or ord://outpoint), banner, bio, dh (number to show), ca (coin address), flaglatest signed one wins; a field left out keeps its saved value, so a partial record never wipes a picture. dh must be a number the signer's wallet holds, or readers show the lowest it holds
fwetch-linkaddrs[], proofs?address linking (§3.2); proofs takes an address back with its own key's signature
fwetch-transfernumber, toinformational; the spend is the transfer
fwetch-burnoutpointin the same tx as the 1-sat spend; retires the piece or coin
fwetch-pinroom, sha, body, bya pinned chat message, on chain; only in a room anybody may read (29 October 2026: a conversation's named both of the two)
fwetch-awardcode, toa flag given by hand (curator, or a board's owner for its own flag)
fwetch-tippost txid \to address, amount, reader?money for a post's author, or for a creator directly; the payment is outputs of the same transaction (§5.4)
fwetch-followaddr \number \show, un?follow a person or a show; un: 1 stops; the newest per follower and target holds (§5.4)
fwetch-showname, about?, cover?, kind?, category?, replaces?, gone?a podcast (or a channel); its id is the txid that made it (§5.4)
fwetch-playlistname, items[], about?, kind?, scope?, replaces?, gone?; for an album artist, cover, year, genreposts and pieces in order; kind: 'saved' is a person's bookmarks, kind: 'album' an artist's album (§5.4)
fwetch-buyposts[], amount, fora purchase of songs for sale; the payment is outputs of the same transaction; for is sha256 of <buyer's address>:<nonce> (§5.4)
fwetch-notesite the host of the app the payment was made at, b? what the app said it was for (≤140 chars)a note on the payment that carries it, written by a wallet for an app the person paid through it, when the person has turned notes on (the Vulpine wallet's Settings, off by default); unsigned, so it names no identity; app is the wallet that wrote it. Not written where the app unlocks an input itself (a pool, an escrow)
fwetch-radiussite the app's host, listing its listing's txid, build, sats what the Radius outputs before it carrythe mark of a Radius payment (§9.10.1): written by a wallet right after the outputs it added on top of a payment for an app whose listing has a radius line; unsigned; app is the wallet that wrote it. Readers count the marks for each site, which is how a build that turns takes its turn
OPENAD1op=book, id=AD_PROTOCOL_ID, slot, minutes, image, url, alt, price, boardan ad booking; payment in the same tx (§9.3)

Image references are b://<txid> (B protocol) or an ordinal outpoint.

5.1 Threads, boards, poster tags

5.3 Polls and votes

A poll is a post carrying poll: { options[], closes, mode, who }. Votes are fwetch-vote records; one per identity per poll, the first in chain order; votes after closes are ignored. who is anyone, numbers (holders of a number), board (members of the post's board) or flag.

Three modes, one envelope:

Since 7 October 2026 (each field only when present, so an older poll reads as it did; one reading of them in the reader's lib/polls.js):

5.4 Media: songs, videos, podcasts

A piece of media is an inscription (its bytes) and a post that announces it, so it can be found, commented on, liked and tipped like any post. The post's img is the inscription's outpoint, and it says what it is:

fieldmeaning
mediaaudio or video
title, artist, albumas a player shows them (120, 80, 80 characters)
durlength in seconds
postera still or cover art, an image outpoint
show, epfor a podcast's episode: the show's id and the episode's number

app is music for a song, podcast for an episode and btube for a Spaghettube video; each of these applications shows its own posts alone (as 4chain and Spaghettube do), and a comment is a reply that keeps its piece's app. A Spaghettube post from before media existed is a video.

Sealed playlists

A playlist can be for chosen apps alone (23 October 2026, Rachel: "make a playlist specifically to pull onto an app I make ... private except for certain apps ... Make the data and interface easy please"). It is a fwetch-playlist with scope: 'apps', its name in the clear and no items, and sealed:

sealed: {
  data: base64 of {items, about?} (JSON), sealed with the BSV SDK's SymmetricKey
        under a key made for this playlist: a 32-byte IV, the AES-256-GCM
        ciphertext, its tag,
  to:   [{ pub: an app's key for sealed playlists (its listing's `seal`),
           key: base64 of the playlist's key, sealed to that app with the SDK's
                EncryptedMessage (BRC-78) from a key used once,
           app?: 'app:<listing txid>', the listing it was chosen from }]
}

One to eight apps. A list said both sealed and in the clear is not filed, nor is an album sealed. Each change seals it again under a new key. Readers keep it off the network's lists and serve it at /api/playlist/:id and /api/playlist/:id/plain (sealed, with no tracks; ?for=<an app's key> gives that app's key alone), and an app's list of what was made for it at /api/playlists/sealed-to/:pub. Opening one takes the app's private key and a few lines:

import { EncryptedMessage, SymmetricKey, Utils } from '@bsv/sdk'
const { playlists } = await (await fetch(`https://fwetch.lol/api/playlists/sealed-to/${MY_SEAL_PUB}`)).json()
for (const pl of playlists) {
  const key = EncryptedMessage.decrypt(Utils.toArray(pl.sealed.key, 'base64'), MY_SEAL_KEY)
  const { items } = JSON.parse(Utils.toUTF8(new SymmetricKey(key).decrypt(Utils.toArray(pl.sealed.data, 'base64'))))
  const { tracks } = await (await fetch('https://fwetch.lol/api/tracks', { method: 'POST',
    headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ items }) })).json()
  // each track: title, artist, album, duration, type, cover and play, an address that plays it
}

/api/tracks (POST {items}, up to 500, or GET ?ids=a,b, up to 60) gives any list of posts and pieces as tracks to play, as /plain does. The songs on a sealed playlist are public posts; what is sealed is the list. The wallet that made it keeps what is on it.

5.2 Delegation

The holder of a number may name other identity keys as delegates with a signed fwetch-delegate record; a later record from the holder revokes. A delegate's signed post carrying as: <number> is shown as that number (name, picture, flag); readers record the real signer. Delegates may post, reply, react and repost as the number; they may not transfer the coin, change its profile, or delegate onward.

6. Coins that are licenses

Everything that can be owned in the protocol is a 1-sat ordinal coin. Ownership is holding. Selling the coin sells the thing.

6.1 Board coins

MAP: p=fwetch-board slug=<SLUG> boardName=<name> series=Board collectionId=<Challenge Coins>. The holder owns the board /SLUG/: moderates it (hides posts), may make it private (members are addresses the owner lists, or holders of the board's membership flag), makes its flag, pins its threads, and receives the board's share of ad revenue (§9.3). /FG/ (General) is a board with a coin like any other, but may not be private and is not for sale.

6.2 Series coins

MAP: p=fwetch-series name=<series> mode=lite|hard collectionId=<the series' collection>. Registers a series (§4.3). Minted by the protocol's house to the buyer; priced by the publisher (§9). Status: specified; indexer support follows.

6.3 Memes (the Library)

The Library is one collection, forever; no reader starts its own. A meme is an inscription in the Library collection with MAP p=fwetch-meme, an optional supply (open edition when absent), and royalty in basis points. Claims are 1-sat outputs of the meme's edition; the inscriber is the creator for royalty purposes (§9.2) — provenance, not authorship.

6.4 Collections (the Minter)

A generative collection: layered variants with weights, pieces rolled from a seed. Piece MAP: p=fwetch-piece collectionId number traits seed rarity royalty. No two live pieces of a collection share a trait combination; a burned piece frees its combination and restores one to the supply.

6.5 Flags

Flags are inscriptions to the holder's address (p=fwetch-flag code=<code>), awarded by rule (a reader's own rules, e.g. "posted 100 times"), by a curator, or by a board's owner for that board's membership flag. A post may fly one flag the poster holds; otherwise the reader may show the poster's country.

6.6 Ranks and the leaderboards (the worlds)

The fights in the shared places (the Oasis, the Halls, the halls inside buildings, the Arena) are refereed by a reader, which counts each identity's knockouts, deaths, hits, uses, harm dealt and taken, rounds, wins, podiums and best place. Experience is floor(dealt / 10) + 10 kills + 5 rounds + 10 podiums + 25 wins; rank i of 60 (0 to 59) is reached at 5 i (i + 9) experience; K/D is kills over deaths and accuracy hits over uses. A reader's house puts them on chain (the reference reader's since 24 October 2026); a reader believes any of it only from a transaction with an input of a known house (house 0 for the reference reader), as with the boards' house records:

Where people walk, what they say and their voices are never written down.

7. Roles and the house

7.0 The founders

The reference reader's seats: #1 is the creator; #1 and #2 are the founders (#1 to #5 until 8 October 2026); #6 is the moderator. Protocol revenue lands with #1. On settlement the house keeps 10% for the network fees it pays (HOUSE_KEEPS_BPS), and #1 and #2 split the rest evenly: #2's half (FOUNDER_SHARES) is paid from the house and published (/api/founders/settlements), and #1 sends the house that half and the house's 10%. Seats follow their coins.

7.1 Seats are per reader

The protocol records who holds what — #1, $rodsirloin, a janny flag. Each reader decides what that means on its own site. The reference reader's configuration makes the holders of #1–#3 its founders and #4 its moderator; another reader may name its own seats by number, by handle, or by key. No reader is the admin of another. Founders configure their reader (featured boards and collections, banners, hand-awarded flags, jannies) and mint boards free.

7.2 Jannies

Holders of the janny flag may hide posts and memes from this reader. A hidden record is still on chain; other readers decide for themselves.

7.3 The house

A reader may run a house: a wallet that pays the fee for members' records so that posting, minting a number, claiming a meme, and pinning cost the member nothing. A house-paid record is identical on chain to a member-paid one, except that the first input is the house's. A reader may vouch, via a house-paid record, for facts it verified about an anonymous poster (their chosen flag; their poster tag) — readers accept the vouch only when the first input is a known house's, and only once something has checked the signature there: the transaction mined, the network's copy of it, or the house's own. The same bytes handed to a reader by anybody else name the house's key beside a signature nobody has checked.

Bytes handed to a reader before the network has them (POST /api/index/:txid with raw) prove only what their own signatures prove: a post or a like shows at once, and a coin moving, a mint, a listing or a payment counts once the network has taken the transaction.

The house is a convenience, not a requirement: every record can be written by the member's own wallet.

Some things exist because a reader's house made them: a board's coin (once its price is paid), a flag (when it is awarded), a collection's piece or a number's portrait, a deed card drawn for a deed already founded, and a maze treasure. Each is a 1-satoshi inscription to its holder whose MAP fields say what it is (p=fwetch-board, fwetch-flag, fwetch-collection with portraitOf for a portrait, fwetch-deed, maze-treasure). The house also writes records for somebody that nobody signs: a find in the hunt (fwetch-hunt-find), a pin made by a message's row (fwetch-pin), and the worlds' standings (world-standings, house 0 only, §6.6). Anybody can write the same fields, so a reader believes any of these only from a transaction with an input signed by a known house: the house signs its inputs over the whole transaction, so its input vouches for every output. It believes that input once the transaction is in a block, or at once when it is its own house's copy of what it sent; bytes handed to a reader by anybody else have not been checked by the network yet. The first such coin for a slug, an award, a number's portrait or a finder's treasure holds it, and a later one never takes it. The known houses are house 0, whose address is public (13KgP2F6pjYBVVoY2Nc9G35527XMGyvBLt for the reference reader); every house a reader's own key derives; for a reader without that key, the addresses it is given (FWETCH_HOUSE_ADDRS, comma-separated, or rows in its house_addrs table); and any key the reader trusts as one (FWETCH_TRUSTED_APPS). The reference reader lists its houses at GET /api/admin/houses (one guard for all of them: server/lib/house.js houseWroteTx).

8. Chain order

"Earlier in chain order" means: lower block height first; within a block, lower index first; unconfirmed records are ordered by first-seen time by the reader and re-ordered when they confirm. A reader must re-evaluate rules that depend on order (number claims, duplicate memes) when confirmation changes an order it assumed.

9. Money

Every paid action carries its fees as outputs in the same transaction. A reader recognizes the action only if the outputs are there. That is the enforcement: no fee output, no recognition.

"The publisher" is the holder of #1, resolved on chain at index time — the revenue follows the coin.

9.1 Rates

Rates are a single table published by the reader (/api/ads/rates, adrates.js). This is the current one:

actionwho is paid
minting a number, posting, replying, liking, claiming a meme, minting a memefree (house pays the network fee)
meme aftermarket saleseller; inscriber royalty (MAP royalty, default 5%); publisher 4.2%
collection mintcreator 90%, publisher 10%, at least the inscription's 3,000 sats (42% until 8 October 2026)
collection aftermarket saleseller; creator royalty (MAP); publisher 4.2%
ad on all boardspublisher 100% at booking; then 30% to board owners and 10% to posters, settled by attention (§9.3)
ad on one boardthat board's owner 30% and publisher 70%, both in the booking tx
board coinpublisher (1 BSV; curators free)
series coinpublisher (lite and hard priced separately)

9.2 Sales

A sale of a coin, meme edition or piece is a transaction spending the listed 1-sat output with outputs: the item to the buyer; the price to the seller; the publisher's fee; the creator's royalty. A purchase missing the fee or the royalty is not recognized as a sale (the listing is not marked sold; the item's holder is still tracked by the chain, which is the truth either way).

9.3 Ads

The reference reader's slots are shapes, not placements: banner (728 × 90), square (300 × 300) and billboard (1000 × 600, the 5:3 screens round the Oasis's square), with their rates at /api/ads/rates. An OPENAD1 booking is recognized only if the booking transaction pays the publisher at least the rate for slot × minutes, and — for a booking with board — pays that board's owner at least the owner share. Impressions for all-boards ads are counted by the reader, one per member per day per ad, per board and per post beside which the ad appeared; only signed sessions count. Settlement pays the board and poster shares in one transaction and is published (/api/ads/settlements) so the split can be checked against the chain.

9.5 The marketplace

One set of records that Amazon, eBay, Etsy and Facebook Marketplace are all readers of. Anything sellable is a listing; every purchase is an order whose payment is in the same transaction; the rest is the life of that order. The rules live in market.js, dependency-free, run identically by readers and browsers.

recordfieldsrule
fwetch-listingkind (ordinal, good, digital, service), title, body, imgs[], price (sats), qty, category, tags[], condition, variants[{name, price, qty}], ship{from, to[], cost, days}, escrow, aff_bps, expires, auction{reserve, end, min_inc}, outpoint, digital{sha256, size}, replaces, shop, card{graded, grader, grade, cert, condition, name, set, year, number} (a trading card: imgs[0] its front, imgs[1] its back)signed by the seller; an ordinal listing must name an outpoint the seller holds; replaces retires an earlier listing
fwetch-delistlistingthe seller withdraws
fwetch-offerlisting, amount, messagea haggle
fwetch-acceptofferthe seller takes it; an order may then be placed at that price
fwetch-bidlisting, amountan auction bid: at or above the reserve, at least min_inc over the high bid, before end; the highest at end wins and orders at that amount
fwetch-orderlisting, qty, variant, affiliate, offer, escrow, ship_to (encrypted to the seller), notethe payment is this transaction (§9.5.1); a sold-out or expired listing, or a losing bidder, is not an order
fwetch-fulfilorder, tracking, carrier, note, payload (digital goods: encrypted to the buyer)seller only
fwetch-receiveorder, notebuyer only; releases escrow
fwetch-disputeorder, reasoneither side
fwetch-resolveorder, to, splitthe arbiter (the publisher) only
fwetch-revieworder, rating 1–5, bodyone per side per order; buyer rates seller, seller rates buyer
fwetch-shopname, about, policies, ships_from, logo, bannera storefront; listings reference it

Questions on a listing are replies to it. Favourites are reactions (fav). Wishlists and carts are reader-side.

9.5.1 The money in an order

For a listing, a quantity and an optional variant, affiliate and price (offer or winning bid), the outputs a payment must contain are fixed:

Short any output and the transaction is not an order. Sats may exceed.

9.5.1a Two rails

A listing is priced in BSV (satoshis) or USD (cents) and names the rails it accepts: bsv, usd, or both. The quote converts to the rail being paid on at the reader's posted rate (/api/rate, sats per dollar) and stamps the rate and the time.

The chain never holds dollars. It holds the listing, the order, the fulfilment, the reviews — the record — while the money moves on whichever rail moves it best.

9.5.2 Escrow

A bare 2-of-3 multisig: buyer, seller, arbiter (the publisher's identity key). Release is buyer + seller to the seller; refund is seller + arbiter (or buyer + arbiter after a resolution) to the buyer. The arbiter alone cannot move it; neither party alone can. Ordinal sales never use escrow: the item and the money change hands in one transaction.

9.5.3 Reputation

Reviews are records; a reader computes a seller's (and buyer's) count, average and positive share from them. No reader owns a reputation.

9.6 The assertion primitive

Every layer added after the social records reuses one shape: fwetch-assert { type, parent?, payload }, signed. The txid is the stable id. An edit is an assertion with a parent; a revision by the same author (or a linked address) marks its parent superseded, and the parent chain is the history. Nothing is ever replaced. A revision by anyone else is kept as a rival claim and supersedes nothing. Readers decide their own edit window (30 minutes for social posts, open-ended for a wiki): inside it the revision is the current version, outside it a late revision, and either way the record stands.

9.6.1 Frens

The network's one way of saying you know somebody, and the first assertion type written into this spec.

fwetch-assert { type: 'fren', payload: { of: '#4' | '<address>', un?: 1 } }

Signed by the person making the claim, so a fren list belongs to whoever wrote it and every reader can read it. un: 1 takes it back. The newest statement about a pair wins; nothing is deleted, because nothing here ever is.

A fren is one-sided. Saying somebody is a fren is a statement about yourself, not an agreement, and requiring both signatures would turn a follow into a negotiation. A reader that needs a relationship rather than a claim asks whether both said it: that is a mutual fren, and it is what anything competitive should count. Otherwise anyone can add the richest or most famous people on the network and claim them.

of names a person by user number or by address, and a reader resolves it to the address holding that number at the time of reading, not at the time of writing: a number that changes hands takes its frens with it, which is what a number being an account means.

This is protocol, not an application's private habit. Any reader may list somebody's frens, and any application may write one. /api/frens/:who answers with both directions.

9.6.2 Arbiter keys

fwetch-assert { type: 'arbiter', payload: { seat: 0 | 1 | 2, key: '<33-byte public key, hex>' } }

Signed by whoever holds that number when it is read; the holder's newest one wins. Escrow and launchpad pots lock to the published keys, in seat order, two signatures needed: OP_2 <#0> <#1> <#2> OP_3 OP_CHECKMULTISIG once all three have published, OP_2 <a> <b> OP_2 OP_CHECKMULTISIG while only two have. A pot keeps the keys it was made with. /api/arbiters serves them.

9.6.3 Launches

fwetch-assert { type: 'launch', payload: { token, sym, name, pot, arbiters: [k0, k1, k2], steps: [{ v, amt, price }] } }

Written in the same transaction as the ladder, so each step's v is an output of that transaction: a BSV-21 transfer of amt of token in an OrdLock whose payment is price satoshis to pot. A reader shows a launch only when the ladder spends the token's deploy output, every step is as recorded, the steps hold the whole supply, prices rise step by step, and pot is the two-of-three of keys the seats published. A step spent with the pot paid as the spending transaction's second output is sold; any other spend took it back. Every step sold: the launch has graduated. /api/launches, /api/launch/:id.

One ladder size (18 October 2026). A launch made from 18 October 2026 23:00 UTC raises at least 4,000,000 sats: its steps' prices add up to that or more, or readers refuse it. Vulpine's forms make every ladder add up to $100 at the day's rate (never under that), its last step ten times its first.

Pool coins (18 October 2026). A launch may hold part of its supply back for the coin's pool: pool: { v, amt } in the record, and output v of the ladder is a 1-sat BSV-21 transfer of amt of the token in front of exactly the pot's lock. The steps and the held coins together make the whole supply. Vulpine holds back a fifth (the supply divided by 5, rounded down). A pool coin's pot never pays its maker: when every step has sold, the pot and the held coins become the coin's pool (9.6.3a), less 1% of the pot each to #1 and #2.

An older launch becomes a pool coin when its maker says so, in the transaction that takes the named steps back (spends them by their cancel key) and puts their coins in its output v, locked to the pot:

fwetch-assert { type: 'launch-pool', payload: { launch, steps: [v, ...], v, amt } }

Signed by the launch's maker (the identity that signed the launch, or one linked to it); amt is the named steps' coins together. Readers count those steps as held: off the ladder, so the launch graduates when every other step has sold.

9.6.3a Pools

A coin's pool is everything at one lock: its BSV (outputs that are exactly the lock) and its coins (1-sat BSV-21 transfers of the coin in front of the lock). The lock has two ways in (the founders' lock, 18 October 2026; Rachel: "one and two need to both agree and sign to do something", "User 0 should have some sort of power that can act as user one"):

OP_IF   <houseA> OP_CHECKSIGVERIFY <houseB> OP_CHECKSIG
OP_ELSE <#2> OP_CHECKSIGVERIFY OP_1 <#0> <#1> OP_2 OP_CHECKMULTISIG
OP_ENDIF

with <#1> OP_CHECKSIG in place of the multisig while seat #0 has published no key. houseA is the house's key for that coin (BRC-42 from the house desk's first key, protocol [2, 'vulpine pool'], key id the token id, for itself); houseB is the house's second key for it, the same way from the desk's second key. The house signs every swap that follows the rule by itself, for anyone, with <houseB sig> <houseA sig> OP_1, and #1's sealed backup of the desk recovers every pool. (Rachel, 18 October 2026: "Our pools, Janus trades them": Moonfox is the swap, and Janus's swap trades the same pools through the house.) Anything else takes #2 with #1 or #0: OP_0 <#1's or #0's sig> <#2's sig> OP_0 (with no #0, <#1's sig> <#2's sig> OP_0). #0, #1 and #2 are the keys those seats published as arbiters (9.6.3). Every signature is SIGHASH_ALL | SIGHASH_FORKID.

A pool opens with the transaction that first puts BSV and the coin at its lock:

fwetch-assert { type: 'pool', payload: { token, lock: 'v2', house: [houseA, houseB], founders: { one, two, zero? }, bsv, coins } }

bsv and coins are the outputs holding each. Readers count it only when house is the house's two keys for the coin and one, two and zero are keys seats #1, #2 and #0 have published, so nobody opens a pool whose second way in is their own. The house writes it when a pool coin graduates, from the pot and the held coins, in the transaction that spends them: the pool's BSV and coins, the index fund's 1,000 sats, 1% of the pot to #1 and 1% to #2 (their handles' owners; Rachel, 18 October 2026: "1% each, plus pool shares"; each none when it would be under 546 sats) and the record. For a coin with nothing held back (a version 1 coin), anyone may write it, from their own BSV and coins. Readers take the first such record by the house, or, for a coin with nothing held back, by anyone; for a pool coin only the house's counts, so nobody opens it ahead of its pot. From there the pool is followed on chain, from each transaction that spends it to the next.

Before the founders' lock, pools opened at 1Sat's cosign script (OP_DUP OP_HASH160 <hash160(owner)> OP_EQUALVERIFY OP_CHECKSIGVERIFY <cosigner> OP_CHECKSIG, opened by <cosigner sig> <owner sig> <owner key>, the record { token, owner, cosigner, bsv, coins }); none opened on the network. Readers still read such a record, at that lock or at the founders' lock, since a wallet from before writes it at whatever lock the reader names. Until seats #1 and #2 have both published keys, a pool still opens at that older lock, the house's two keys alone (GET /api/pool/<token> says foundersWaiting), and keeps it.

A swap spends everything the pool has and leaves exactly one output of its BSV (x', at least 1 sat) and one of its coins (y', at least 1, on 1 sat), and:

Buying n coins costs ceil(1000·x·n / (977·(y−n))) sats into the pool; selling n gives floor(977·x·n / (1000·y + 977·n)). The fee stays in the pool: 0.3% of what comes in for its share holders, as other markets charge (Rachel, 18 October 2026: "What do other markets do do that"), and 1% #1's and 1% #2's, as shares (below; Rachel the same day: "Me and my friend decided 1% Fair because no one else has built this so until someone else builds it 1%", then "1% each and .3 to pool"). Until 18 October it was 1%, all of it the pool's. Anyone may build a swap. The house signs any swap that follows the rule and nothing else, at POST /api/pool/<token>/cosign { tx, parents? } (the whole transaction as hex; inputs not yet signed carry empty unlocks, since SIGHASH_ALL leaves every unlock out of what is signed; parents maps a txid to its hex for inputs the network does not have yet). It answers { sigs: { <input index>: <DER + scope, hex> }, owner }, and for a pool on the house's two keys cosigs and unlocks, each pool input's whole unlock, ready to put in (for the founders' lock, <houseB sig> <houseA sig> OP_1). GET /api/pools/rule gives the rule in numbers and words with a version that changes whenever any part of it does; every pool's view carries ruleVersion, so an app that trades pools knows when to look again. GET /api/pool/<token> gives the lock, both keys, the pool's outputs, what it holds and, with ?buy=n or ?sell=n, a quote. GET /api/pools lists every open pool.

Pool shares (18 October 2026: anyone adds to a pool, as on an automatic market maker). A pool's shares stand for everything in it.

fwetch-assert { type: 'pool-add',    payload: { token, to? } }            signed by whoever adds
fwetch-assert { type: 'pool-remove', payload: { token, shares, as? } }   signed by the holder

Readers follow the shares from the opening through each transaction the pool went through, reading the records in each, so anyone keeps the same ledger. GET /api/pool/<token> adds shares (total, locked, every holder), with ?for=<address> one holder's position (shares, what they would take out, their part, and, for #1's or #2's holder, seats: each seat's the same way), and with ?add=<sats> what adding that many sats takes in coins and mints in shares.

9.6.4 Prediction markets

fwetch-assert { type: 'market', payload: { q, closes, fee, arbiters: [keys] } }           by an arbiter (#0, #1, #2)
fwetch-assert { type: 'bet', parent: <market txid>, payload: { side: 'yes' | 'no', v, sats } }
fwetch-assert { type: 'resolve', parent: <market txid>, payload: { outcome: 'yes' | 'no' | 'void' } }   by an arbiter

A market's pot is <market txid> OP_DROP followed by the two-signature lock of its arbiters (9.6.2). A bet counts when output v of its own transaction pays exactly sats (at least 1,000) to that pot, before closes. The odds are each side's share. A seat's newest resolve stands; two seats that disagree leave the market disputed. Settled: the winners split the pot in proportion to their stakes less fee basis points (200 = 2%) to the house; void, or nobody on the winning side, returns every stake less its share of the network fee.

Huginn on chain (7 October 2026; Predict is Huginn, Rachel's pick). Huginn is an address, the key sha256('vulpine-app:huginn'). A question, a bet or a settlement pays it one sat in its own transaction (Vulpine's Huginn from 0.99.186); the house lists the older ones there (app-index { p, app: 'huginn', records: [txid…], t }) and who sits in each seat (app-index { seats: [[seat, [address…]], …] }, only the addresses that asked or settled as that seat, never every address linked to its holder), believed only when house 0 signed an input. A page believes a question or a settlement only when its signature holds and its signer's address is in a seat, and a bet only when its signature holds, its t is before the question closes, and output v of its own transaction pays exactly sats (at least 1,000) into the question's pot. Huginn on chain is such a page.

9.6.5 Declare

You claim to be the best at something; people back it up or crush it, or challenge it by putting someone up against you (themselves or someone else), and the network's voting decides (§ polls).

fwetch-assert { type: 'declare', payload: { title, about?, proofs?: [proof] } }      a claim
fwetch-post { b, poll: { options: [claimant, contender], mode: 'open', who: 'numbers', closes },
              app: 'declare', declare: { claim: <claim>, contender: { self: 1 } | { name, number? } } }   a challenge
fwetch-vote { poll: <challenge>, choice: 0 | 1 }                                     a vote, once a person
fwetch-post { b: <why>, reply: <on>, app: 'declare',
              declare: { on, kind: 'vote' | 'back' | 'crush', side?: 0 | 1, proofs?: [proof] } }   a reason
fwetch-reaction { post: <claim>, kind: 'agree' }                                     backing, as it was first written

Only number holders count (7 October 2026): a vote, a backing or a crushing from an identity that holds no user number (through any address linked to it) is not counted, whatever the poll said when it was made. Each comes with a reason, a reply in Declare saying why, which may carry proofs the way a claim does; a vote's reason says which side (one on the side its writer did not vote for is not shown). A reason is signed by its writer, or anonymous: unsigned (anon: 1), sent through a reader that checked, from a signed request and never the post, that its sender holds a number, and paid by that reader's house. A reader counts an anonymous reason only if it admitted it, so each person counts once; it keeps who sent it to itself. Backing a claim is a reason of kind back, crushing it one of kind crush; the agree reactions written before count as backing. Each person counts once a kind on each claim, signed or not.

A title is filed by its words: lower case, letters and numbers, single spaces, without "the best at" in front, so "The best at Chess!" and "chess" are one title. A proof is { kind: 'file', ref: <outpoint>, type }, a video or picture the claimant inscribed, or { kind: 'fingerprint', sha256, name? }, a document's hash only: the document stays with the claimant, who shows it to whoever asks, and anyone can check it against the hash (prove, never store; a certificate usually carries a real name, and the chain keeps everything). A challenge's contender is its challenger (self), a number (its holder), or a name. When the challenge closes the one with more votes wins; a tie goes to the claimant. A title's leaderboard ranks everyone who claimed it or was put up for it by challenges won, then lost, then backings less crushings. Its trend is everything that counts for or against someone in the order it came (a vote for them, a backing of their claim, a crushing of it), with each person's running score and share of all the support after each. /api/declare/titles?q=, /api/declare/title/:slug (with trend), /api/declare/claim/:txid, /api/declare/me/:addr (the number Declare counts).

On chain (8 October 2026). POW, as Declare is called now, is an address, the key sha256('vulpine-app:pow'). A claim, and a challenge on a public board, pay one sat there as the network writes them; the house lists the older ones there (app-index { p, app: 'pow', records: [txid…], t }) and claims taken down or put back (app-hide { app: 'pow', hide, show }). What counts on a claim (each backing and crushing, an agree from before) and the reasons shown with a challenge's votes depend on who holds a number, which is the network's to check, so the house lists them as it counts them (app-index { app: 'pow', on: <claim or challenge>, records }) and never ties them as written; a page counts nothing on a claim the house did not list there, and still checks each signature. A challenge's votes are at its own election's address (sha256('vulpine-poll:' + txid)), listed the same way (§5.3). POW on chain, a site of the network's, reads all of it from those addresses and counts it in the page.

9.6.6 Twetch accounts

A Twetch account linked to a Vulpine identity (6 November 2026, Rachel: "prove you own a Twetch wallet by typing in your user number for Twetch and then signing ... from that wallet ... then that will be connected to your Vulpine wallet permanently unless you remove it").

fwetch-assert { type: 'twetch-link', payload: { user, account, t, sig, nft?: { address, sig } } }
fwetch-assert { type: 'twetch-link', payload: { user, t, un: 1 } }

Signed by the identity it links. sig is a Bitcoin Signed Message (base64, compact) by the Twetch account's own key, the one Twetch has on record for user user (its profile's publicKey, whose address is account), over

vulpine-twetch-link|<the identity's address>|<user>|<t>

and nft.sig is the same message signed by the key of nft.address, the address Twetch delivers the account's Twonks to. A link counts when its signatures check, account is the key Twetch has for the account (a reader asks Twetch once and keeps the answer), and t is within a day of the record's own time. The message names its identity, so a link serves no other. For each account the link with the newest t counts: the account's own key moves it to another identity. un: 1 takes an identity's own link back, nothing else signed; linking again later counts again. A link is public: that is what lets anybody check it.

By a small payment, for a Twetch wallet whose phrase is not in the person's wallet:

fwetch-assert { type: 'twetch-link', payload: { user, account, t, asked, sats, to, toProof?, tx } }

The wallet asks for sats to its own address to, worked out so that a payment serves one request only: 500 + (the first four bytes of SHA-256("vulpine-twetch-link-pay|<identity address>|<user>|<asked>"), big-endian, mod 500) sats. The person sends it from Twetch, which pays from the account's own coins at its key. The link counts when transaction tx pays to exactly sats, one of its inputs is signed by account's key (the chain checked that signature), account is the key Twetch has for the user, asked is within a day of t, and to is the identity's: its own address, or one toProof proves (§3.2's fwetch-link-proof|<identity>|<to>|<t>, by to's key). The money stays the person's.

An Apu Fox is traced on the chain from its mint: every one was minted in transaction ce7bccf5060d94138ab822240615109ffb5b7bc373af5658a20cba261fc5923f, fox #n at output n−1, and each spend carries it on in an output with the collection's lock (a914 <HASH160 of the collection id> 88 76a914 <holder> 88ac 6a {…"number": n…}). The lock alone proves nothing, since anybody can write an output with it; the trace from the mint does. It is then the linked identity's when it is unspent at a link's nft.address (two signatures and the chain, nothing of Twetch's), or at an address Twetch says the linked account holds it at. /api/twetch/linked/:user and /api/twetch/links/:identity serve the links, /api/twetch/key/:user the key Twetch has for an account, and /api/twetch/link-pay?to=&sats=&account= finds a link's payment; /api/apu/fox/:n says who holds Apu Fox #n, traced on the chain, and the identity linked to its holder; /api/apu/foxes/:identity lists an identity's foxes.

9.6.7 Game runs

A run of Tartary Downhill or the Tartary Maze as a record (7 November 2026: everything people do is a signed record on chain, and a reader an index made again from it). The run's end, once a run, signed by the player's identity:

fwetch-assert { type: 'ski-run',  payload: { startedAt, furthest, seconds, crashes, gates?, tricks? } }
fwetch-assert { type: 'maze-run', payload: { startedAt, furthest, district, kills, deaths, damage } }

startedAt is when the run began (seconds), furthest the district reached. A reader keeps one row a player: the run they last ran and the furthest any has gone. The same run seen twice counts once; an older run never takes the place of a newer one, though its distance counts for the best. A run that claims more than the game allows is kept and never ranked: Downhill, more than 1.25 districts a second plus 3, or more seconds than passed between startedAt and the record's t plus 30; the Maze, more than a district every two seconds. A reader takes the same runs live, signed the same way but not on chain (POST /api/ski/run, POST /api/maze/run), for who is playing now; the record is what lasts. Downhill's medals are inscriptions of their own (p: 'ski-medal').

9.7 Naming (.fox)

A name is an ordinal, so ownership and transfer come free: whoever holds the satoshi owns the name, and a transfer is an ordinary spend the indexer already follows.

recordfieldsrule
fwetch-domainname, target, inscriptionthe claim; first valid write in chain order wins, a later claim on a held name is nothing. name is label.tld, lowercase
fwetch-retargetname, targetre-point; only the holder of the satoshi, checked at index time

target is a hostname, a URL or a txid — a reader fetches it and renders the page; ICANN is never consulted. A resolver exposes /api/name/resolve/:name; a gateway on an ordinary domain does the same lookup for visitors in a normal browser. Squatting is a policy at issuance (auction, renewal, reserved names) and must be settled before registration opens, because it cannot be retrofitted.

9.8 The Library of Babel

The Library has two wings. The Reading Room holds text; the Gallery holds images. The rule is the same in both: the address is the content, written in the library's alphabet, with a locality prefix in front so that things which are nearly the same sit nearly together. Nothing is stored; an article or a picture is found, not uploaded, and it has the same address in every reader, wallet and indexer that computes it.

An image coordinate is G<room>.<wall>.<shelf>.<volume>:<bytes>. The prefix comes from a perceptual hash — a 9×8 grayscale thumbnail, each pixel compared to its neighbour, 64 bits. The room is the broad shape (the top 16 bits), so a re-save, a recompression, a shrink or a caption lands in the same room and usually on the same shelf; a different picture lands elsewhere. Identity is exact-coordinate; "this already exists" is a hash within ten bits. The meme library is the Gallery's first collection. /api/babel/gallery/locate computes an upload's coordinate and lists what already sits near it.

The Reading Room

An address space in which every article already exists. It saves no storage and is not meant to — a 20KB article has a ~20KB coordinate. What it provides is that the address is a fact about the text rather than a name someone chose, and that an edit lands nearby, so a reader can walk from one version to the next.

<room>.<wall>.<shelf>.<volume>:<body>
238,328 rooms · 62 walls · 62 shelves · volume by length

The prefix comes from a minhash over word 3-grams — the few rarest grams in the document. A typo destroys only the grams it touches, so it moves at most one component and the address stays in the same room; a rewrite moves all of them. body is the text itself, so a coordinate decodes back exactly, and a coordinate whose text does not derive its own prefix is valid but not catalogd. One dependency-free file, run identically in a browser, a reader and an indexer — the coordinate must be the same everywhere or the library has different addresses in different places.

9.9 The wiki (the Reading Room, curated)

Two structures, never conflated: an article's lineage through time, and the descent graph between subjects.

recordfieldsrule
fwetch-articlesubject, title, coord, parent?a revision marks its parent not-current; the newest in a lineage is what a reader shows
fwetch-edgesubject, predicate, objecttyped predicates only — links-to (a [[link]] in a page), derives-from, subclass-of, participates-in. Untyped edges turn the graph to mush and are ignored
fwetch-edgestateedge, statecanonical \disputed \superseded. Disputed is the default: a claim does not become consensus by arriving, and two live claims stand side by side
fwetch-endorsetarget, weightthe endorser is recorded apart from the amount, so a reader can count distinct endorsers rather than satoshis

Edges point at subjects — stable ids — never at article content, so rewriting or splitting a page cannot move the subject out from under an edge. Descent is a braid, not a tree: convergence is the normal case. A reader exposes the frontier — subjects an edge points at with no article yet — because visible gaps are where the graph funds its own construction.

Open problem, stated rather than papered over: if canonical status follows endorsement weight, the biggest spender rewrites history. That is why the endorser and the amount are separate fields. Weighting by distinct endorsers, expiring canonical status, and challenge-with-escrow are candidates; none is settled, and this is the highest-risk piece in the protocol.

Babel on chain, and its catalog (7 and 8 October 2026). Babel is an application on chain: its address's key is sha256('vulpine-app:babel'), and every page, version and edge the network writes pays one sat there; the house lists older ones there (app-index { app: 'babel', records }). A page that reads the whole address checks every signature itself, but an address that holds thousands of records is slow to read on a phone, so the house also keeps a catalog of the library at Babel's catalog address (sha256('vulpine-app:babel-catalog')), written when the library changed: app-index { p, app: 'babel', catalog: 1, t, height, subjects, authors, pages, links, says }. subjects is every subject named, sorted, and the rest refer to one by its place there; authors is [address, 1 if the network's own]; pages is [subject, title, current, versions] with each version [txid, t, author, parent], newest first, parent and current places in that list; links is each page's current [[links]]; says is the other edges as [subject, predicate, object, author, t] (1 subclass-of, 2 participates-in, 3 derives-from, 0 a links-to drawn from a page not written yet); height is the chain's height when it was made. Like every house list it is believed only when house 0 signed one of its inputs, and it only points: a reader shows a page's words from the page's own transaction, its signature checked, and reads what was written after height from Babel's address itself. Made by server/lib/babelcatalog.js; Babel on chain reads it.

9.10 Classifieds

A listing that expires, contacted through an identity rather than an email.

recordfieldsrule
fwetch-classifiedtitle, body, category, city?, location, price, currency, imgs[], expires, parent?, anon?, alias?flat categories: for-sale, housing, jobs, gigs, services, community, wanted, free. A revision by the author supersedes. { parent, remove: 1 } from the author takes a listing down
fwetch-renewlisting, expiresthe author only, and only forward
fwetch-reporttarget, reasona moderation signal. A reader may hide; nothing is erased from the chain

Expiry is a timestamp in the record: past it, a reader drops the listing from active views but the record stands. Contact is the identity — the encrypted DM relay already in the protocol (§10) — so no phone number or email ever appears in a listing.

Where a listing is (7 October 2026). city names a city by slug, one of a fixed table of 1,208 (Natural Earth's populated places, public domain), made from the name a person reads and the country's code: new-orleans-us, kyiv-ua. A listing without one is placed by its location text, the same way by every reader (the wallet repo's onchain/lib/places.js, which is the reader's server/lib/places.js): a city named before the first comma; else a country it names; else any city it names; else nowhere in particular. Other names a city goes by (Bombay, Kiev, Wien) count as its name.

Listings on chain. Cregs List is an application on chain: its address's key is sha256('vulpine-app:cregs'), and every listing, revision and taking down the network writes pays one sat there. The house lists older listings there (app-index { p, app: 'cregs', posts, t }) and what was taken down or superseded (app-hide), believed only when house 0 signed an input. A page reads the address, checks each listing's identity signature itself, and needs no reader at all: Cregs List on chain is such a page.

Who posted, on chain (7 October 2026). An application on chain may show its posters by name: the house lists, on the application's address, the latest fwetch-profile each signer of its public posts signed, by transaction (app-index { p, app, profiles: [txid…], t }). A page fetches those transactions itself and believes a profile only when its identity signature checks out, newest t per key; a profile that does not check is ignored, so the house can point but cannot name anybody. An anonymous post is never tied to a name. Spaghettube does this; its posts may be signed (shown by name, else by address) or anonymous, as the poster chooses.

Thicket on chain (7 October 2026). Thicket's records still say breddit, the name it had, so its address's key is sha256('vulpine-app:breddit'). A thread is its fwetch-post with no reply; a comment replies to a thread or to another comment. A vote is a signed fwetch-reaction { post, kind }, like for up and dislike for down, and a fwetch-like counts as up; a key counts once each way. A vote pays one sat to the address of the application of the post it votes on, as a like does, and the house lists older votes there with the likes (app-index { likes }, downvotes too for Thicket) and its posters' signed profiles. Thicket on chain is a page that reads all of it and checks every signature itself.

9.11 Tartary (land)

A world derived from the chain: you don't build it, you found it. Every district that will ever exist was generated the moment its block was mined.

recordfieldsrule
fwetch-deedparcel, inscription?founding. First in chain order takes it; a parcel in a block that is not mined yet is refused. A reader may charge for founding (FWETCH_DEED_PRICE, paid in the claim's own transaction; the holder of #1 founds free) — off by default, and the lever against mass-founding when it is needed
fwetch-buildparcel, place[], parent?the founder or a live lessee. Each entry is {at, footprint, kind, binds, scale}
fwetch-leaseparcel, to, until, scopebuild rights without ownership; expiry returns them and what was raised stays in history

The deed is an ordinal: send it and the land changes hands, with everything built on it intact.

binds is the point. A founder binds things they already own into the plot — a .fox name becomes a storefront that opens the site, a board becomes a clubhouse, a classified becomes a shop with real inventory, an article becomes a library. Tartary is not a metaverse with nothing in it; it is a spatial index of the protocol.

9.11.1 The renderer boundary

The protocol defines the slot — a structure of footprint X at position Y, bound to object Z, at scale S — and never the model, the texture or the art. Specifying visuals would make the protocol a game engine and lock the world to one look. Nine clients can render the same plot nine ways and agree on what is there.

9.10.1 Applications

fwetch-app { name, url, kind?, about?, icon?, picture?, tags?, wallets?, chain?, seal?, radius?, replaces?, gone? } — an application, a wallet or a site joining the network, listed by anyone. This is how an app that already exists joins: one signed record, which the house pays for, and it is in every reader's directory (/api/apps, the page at /apps, Vulpine's All apps).

fieldwhat it says
namewhat it is called, up to 40 characters
urlwhere it runs, https:// (or http://)
kindapp (runs in a window on the desktop), game, tool, wallet, or site (opens in the browser); app if left out
aboutwhat it does, up to 280 characters
iconan emoji; or, like picture, a picture
pictureits icon as a picture: https://…, b://<txid> or ord://<txid>_<n>
tagsup to five words
walletsthe wallets it works with, up to eight: vulpine, brc100 (any BRC-100 wallet), yours, handcash, …, or any
chainhow its own doings are found on chain: { names?, addresses? } (below)
sealthe public key playlists made for it are sealed to (66 hex characters, 02 or 03 first); its maker keeps the private key with the app (5.4, Sealed playlists)
radiuswhat wallets add on top of each payment the app asks for: `{ build, share_bps, split \rotate, fallback?, min_output_sats? }` (below)
replacesthe txid of an earlier listing by the same key: this one takes its place
gonetrue, with replaces: that listing is taken down

An application runs in a window on the desktop; a site opens in the browser. That line is the distinction between what the network is (chat, the map, names, the Library, a game, a drawing tool) and what people host (a site at a .fox name, or anywhere).

A site that confirms its listing. Anyone may list any address, so a reader asks the site whether it names the key that listed it: either https://<host>/.well-known/vulpine.json holding {"identity": "<identity address>"} (or "identities": [...]), or a <meta name="vulpine-identity" content="<identity address>"> on the app's page. A listing its site confirms is shown as the app's own; any other shows who listed it. A reader shows one listing per address: the one its site confirms, else one it features, else the first written.

An app's own doings on chain (23 October 2026). A reader counts what each listed app did, so a picture of the network (the Oasis, where a building is as tall as its app is busy) shows apps from outside it too. chain.names are up to four names its own records and requests carry as app (2 to 30 letters, digits or dashes, never a name the network's own apps write, such as fwetch, music or btube): every record with one of them as its app counts, and so does every pool swap cosigned under one. chain.addresses are up to eight addresses its transactions pay or spend from: their transactions count, from each one's history. A listing with no chain goes by its own name (lower case, letters, digits and dashes), when no other listing goes by the same. Readers serve the counts at /api/network as outsideApps: [{ app: 'app:<listing txid>', n }]. So an app is counted by writing its name into what it already writes (a Vulpine record with app: '<its name>'), or by its listing naming its addresses.

Radius: support on top of an app's payments (1 November 2026; proposed by the Janus owner). An app's listing may carry a radius line, and then every Vulpine wallet adds outputs on top of each payment the app asks it for: the payee still gets exactly what the app asked, and the person's total on the confirm screen includes the Radius outputs, which nobody skips once the app has them. share_bps is how much, in hundredths of a percent of what the payment pays others (not change, not data, not the payer), 1 to 1000: never more than a tenth. split is up to eight shares { to, bps, label? } adding to 10000, each to an address or a name a reader fills in: $number:<n> the address holding that number, $vulpine the network's till, $app_owner the listing's author; $random_holder, $board_owner, $hosting_reader and $skulk have nothing yet. rotate, in place of split, is up to eight { build, split } taken in turn, one a payment (the turn is the count of the site's fwetch-radius marks so far, over how many there are). A share whose name has no address goes to fallback, or is left out; shares under min_output_sats (100 if it says nothing) go in with the largest, and a Radius under it is not added at all. build names the kind for people (pools, raffle, founders, board, readers, mined, ecosystem, custom). A Radius line counts only while the listing's site confirms its author (above), and a reader serves every app's at once at /api/radius ({ cap_bps, exempt, builds: [{ site, listing, build, share_bps, split: [{ to, bps, address, label }], turn?, of?, fallback, min_output_sats, live, paid }] }), so no wallet says which app it is about to pay. A reader's curators turn an app's Radius live; until then it is a test run, which wallets show and do not add. The Vulpine wallet adds nothing for the holders of #0, #1 and #2 (exempt), nor where the app unlocks an input itself (a pool, an escrow), holds the transaction back (noSend) or signs it itself (signAndProcess: false). After its outputs the wallet writes a fwetch-radius mark (§5).

Readers decide what they show. They may hide a listing; one hidden stays hidden through its author's changes to it, and its address stays hidden when somebody lists it again, unless the site confirms the new lister. A wallet waits until a reader's curators have looked at it, because a fake wallet takes the phrase of whoever trusts the list. Every listing stays on the chain whatever any reader shows.

Tods: applications on the chain

fwetch-tod { name, outpoint, version?, about?, needs[] } — a claim on a name in the Den, the registry of applications. A tod is one inscription: a JSON file with a manifest and a page (see Tods). The claim names the inscription. First claim in chain order holds the name; the holder, or any address linked to them, may claim again with a new outpoint to publish a new version. A claim is checked against the inscription before it is believed: an outpoint that does not hold a tod of that name claims nothing. needs is what the tod may ask a wallet for: read, who, sign, pay, store, open. Readers serve the Den at /api/tods and /api/tod/:name.

A tod written in Gekker, the protocol's own language, carries its source (gekker, lang: "gekker-1") beside the page, so a later host compiles it again from the words (see Gekker).

Names that point at the chain

A .fox name's target is one of: a web address; an IP; app:<id> (opens a wallet application); page:<id> (its page); tod:<name> (a tod in the Den); ord:<outpoint> (any inscription). The last two are websites on the chain: a wallet fetches the page from the inscription and shows it in a sealed frame, so nothing serves it and nothing can change what the name shows except a signed retarget by the holder. The name claim is the certificate.

What a wallet must protect

Several coins on chain may claim the same number: old designs the protocol no longer reads, and re-mints after a retirement. Readers answer /api/coins/verdicts?outpoints=… with real, old, duplicate, not-a-number or unknown per coin. A wallet may let a person burn old and duplicate; it must never burn real or unknown.

Standards a wallet speaks

Ordinals are listed to applications as BRC-100 basket 1sat, laid out per BRC-147 (tags ordinal, origin, type:…, collection:…; outpoints in underscore form). Provenance follows BRC-150 and BRC-159: a wallet proves an ordinal's origin from the transactions and merkle proofs alone and believes no index.

Sigils (Twetch's Twonks and Bored Waifus, and the ones Vulpine's Mint makes) are listed as basket sigils (Vulpine 0.99.251). Tags: sigil, sigil:v1 or sigil:v2, collection:<id> once the wallet has seen the id, collectionhash:<HASH160 of it>, number:<n>, series:<n>, and issuer:<key> for version 2. A version 1 Sigil is locked OP_HASH160 <H1> OP_EQUALVERIFY OP_DUP OP_HASH160 <owner> OP_EQUALVERIFY OP_CHECKSIG OP_RETURN <metadata> with H1 = HASH160(collection id), and opens with <sig> <pubkey> <collection id>. The id is public: every earlier move shows it in its unlock. An app moves one by naming it as an input of createAction (with its transaction in inputBEEF) and giving the same Sigil with the new owner as an output; the wallet signs it and writes all three pushes itself, so the txid is final when signed. The wallet finds the id on chain; an app may also give it (collectionId on the input, or 64 hex in its inputDescription), and it is used only if it hashes to H1. A version 2 Sigil is two-of-two with its issuer and cannot be moved by a wallet alone. noSend is honored: a transaction signed with it is handed back and never sent until sendWith sends it. Readers publish their own health at /api/indexer/status, with the reason when the indexer is not running.

9.11.2 Surveying

A block never changes, so a district is derived once and kept. A reader's surveyor walks the chain from genesis forward in the background at a pace the block source tolerates, so the map fills outward whether anyone asks or not; anything asked for first is fetched on demand. /api/tartary/map returns what is surveyed immediately and says how many districts in the window are still coming (missing), so a renderer polls until it is zero.

9.11.3 The derivation is permanent

The byte ranges and thresholds decide what land people found, so they are published (/api/tartary/derivation) and versioned: tartary-1. A change is a new derivation and a new world, never an edit to this one.

One finding worth recording, because any reimplementation will hit it: a block hash is not uniformly random at the front — its leading bytes are the proof of work, and the number of zeros grows as difficulty rises. Reading climate from the head makes every district a glacier and drifts the world as the chain ages. tartary-1 seeds climate from a mix of all 32 bytes, which is uniform across all 25 biomes and stable forever.

9.11.4 New World: cities and nations

New World is a city builder on the deeds: one deed, one city. Its records are assertions (9.6), so any reader files them and any client can replay or draw them.

fwetch-assert { type: 'newworld-save',   parent?, payload: { parcel, rules, from, to, log, hash, pop, year, name, funds?, army?, approval? } }
fwetch-assert { type: 'newworld-nation', payload: { name, motto?, flag?, capital?, mode?, color? } }
fwetch-assert { type: 'newworld-ally',   payload: { with, end? } }
fwetch-assert { type: 'newworld-raid',   payload: { ticket, raid } | { ticket, ranOut: true } }   (the house's)

A city is the chain of saves its deed's holder posts: the actions taken from tick from to tick to, and the city's state hash at to. The simulation (rules, today newworld-1) is deterministic, so anyone replays a city from its saves and believes a save only if its hash comes out; a reader only lists them (/api/tartary/city/:parcel, the holder's saves alone). City money is bought with sats, $1 a sat, in a payment that also carries the words newworld-funds <parcel> in an OP_RETURN, so it belongs to that city and no other (/api/newworld/funds/:txid?parcel= checks one).

A nation is one person's cities together, signed by the holder of the deeds. The newest record by that signer, or by an address linked to them, is the nation. What it holds is never written in it, only read from the chain: its territory is every district whose Seat (parcel .0) the signer holds, since a district belongs to whoever holds its Seat; its cities are the signer's deeds with a city saved on chain; its capital is the parcel the record names, while the signer holds it. name is one line of 2 to 40 characters, motto up to 80. color (#rrggbb) is the hue the nation's land is washed in on a map, every plot it holds; without one, its flag's first color.

The head of state is the nation's holder, shown by their own picture. Their title comes from the realm: mayor of one city, governor from 2 cities and 20,000 people, president from 5 cities and 100,000 people. How they stand is read, never written: popularity (0 to 100) is their cities' approval weighted by people, plus 2 for each raid for stakes won (up to 10) and 1 for each held (up to 5), less 3 for each fallen to (up to 15) and 1 for each lost (up to 5), counting only raids the reader replayed and found to hold; power is the troops their cities keep plus 25 a raid won and 10 a raid held; the treasury is their cities' money. A save says its city's funds, standing troops (army) and approval (0 to 100, the game's own reading of taxes, services, crime, pollution, traffic, jobs, power and water, fires and debt) as it says its people: claims a reader lists, which anyone replaying the city can check. A city saved before it said approval counts as

  1. /api/newworld/nation/:who answers `head: { title, next, popularity,

power, treasury, troops, raids } (next the next title and what it needs); /api/newworld/nations each nation's title`.

A flag is described, not drawn, the way a blazon is: a reader paints it in its own style and every reader agrees on what it is. { field, colors, emblem?, emblemColor? }, colors as #rrggbb, the field's own first:

fieldcolorsthe cloth
plain1one color
h2, h32, 3bands across, top first
v2, v32, 3bands down, hoist first
cross2a cross, set toward the hoist
saltire2a diagonal cross
canton2a square in the upper hoist
border2a border round the field
hoist3two bands across, a triangle from the hoist
diagonal2divided from the upper fly to the lower hoist
quarters2four quarters, alternating

emblem is one of star, stars (three), sun, moon, circle, diamond, cross, set in the middle (in the canton, or in the triangle, for those fields). A field or emblem not on these lists is not drawn: a reader that cannot draw every flag the same way would make two nations look alike.

A nation's mode says whether its cities take part in raids: mode: 'geo' is Geopolitics, where they raid and are raided for stakes inside the game (city money and a place on a board, never deeds); mode: 'hard' is party mode, the third mode (below), where deeds are at stake; anything else, or none, is Peaceful, where nobody can harm them. Two cities meet at the gentler of their nations' modes. Going further in counts from its record; stepping back counts a day (86,400 seconds) after the first record of the step back, so a nation cannot step out of a raid it sees coming. A reader shows the mode as it counts now (mode), what the nation chose (chosen), and while a step back is waiting, when it counts (peaceAt) and what it steps to (stepsTo).

Party mode (mode: 'hard') is built and switched off: a reader counts it as Geopolitics until it is opened, and says so at /api/newworld/party (open, why, rules nwparty-1, leaveSecs, perTx, the house's and the referee's keys). It is opened, after a lawyer's read, by the holder of seat #1 with a record of their own, fwetch-assert { type: 'newworld-party', payload: { open: true | false, referee? } } (the newest stands; the referee is the key it names, or seat #1's published arbiter key); a reader's own environment can keep it shut whatever the chain says. Open, a nation in it has every deed it holds locked: the deed card's satoshi in a 2-of-3, OP_2 <holder> <house> <referee> OP_3 OP_CHECKMULTISIG, up to 250 a transaction. For each lock the holder also gives the house one signature made beforehand, SIGHASH_NONE | ANYONECANPAY | FORKID (0xc2), for a spend of version 1, sequence 0xffffffff and lock time 0, which names no outputs and no other inputs, and registers it with POST /api/newworld/party/locks { locks: [{ parcel, txid, vout, presig }], raw? } (GET /api/newworld/party/locks/:who says which of a person's deeds are locked). The index follows a deed into a lock of the house's and keeps it as its holder's. A raid between two nations in party mode, on a city whose deed is locked, carries stakes: 'deed' and the lock's outpoint (lock) in its ticket; once the reader has replayed it and it holds, a raid the raider won takes the deed: the house spends the lock with the holder's signature and its own, to a 1-satoshi output to the raider. The city goes with its deed: the city's saves before the conquest are read as its holder's then, and the new holder builds on from there. A nation that steps out has its deeds handed back once its day has passed and no raid on its cities is under way; the holder and the referee can always take a deed back together without the house.

Alliances. A nation's holder signs newworld-ally { with }, naming another nation's holder (any of their addresses). Two nations are allies while each one's newest record naming the other stands; one side's alone is an offer, and end: true takes either back. An alliance ended still counts for a day after the record that ends it, so nobody breaks one to raid at once. Allies do not raid each other: the house deals no ticket between them.

/api/newworld/nation/:who (an address or #number) answers one nation and its realm, with its diplomacy (allies, the offered it made, the offers made to it); /api/newworld/nations every nation, each with the districts it holds and its allies (by the address each is listed under), for a map's borders; /api/newworld/near/:parcel?r=2&for= the cities within r cells of a city's district (1 to 3), each as its holder's newest save says, with its holder's nation and mode.

A raid is fought in the raider's wallet against the city raided as its holder last saved it, and anyone replays it from its record: the battle's rules (nwraid-1, the wallet's conquest/battle.ts on a plot made from the city by newworld/raid/plot.ts), the troops that marched, the commands at their ticks, and a seed. The house deals the seed when the raid begins, so nobody can rehearse the exact battle, and files the raid when it ends, so nobody can take a ticket away and try at leisure:

POST /api/newworld/raid/ticket { ask }
  ask    = { p: 'newworld-raid-ask', attacker, defender, save, target, army, t, pub, sig }   signed by the raider
  answer = { ticket: { p: 'newworld-raid-ticket', id, rules, attacker, defender, attackerAddr, defenderAddr,
                       attackerSave, defenderSave, army, edge, seed, issued, expires, pub, sig } }   signed by the house
POST /api/newworld/raid/file { raid }
  raid   = { p: 'newworld-raid', ticket, era, army, commands, result, loot, lost, t, pub, sig }   signed by the raider
  answer = { filed: true, ticket, txid }

save is the raider's newest save, so the army that marches is the one on chain; target the city raided's newest save as the raider's wallet read it, so the city fought is the one it looked at; army the troops that march (militia, archer and brute, at least one), no more than the save had. A ticket is dealt only between two nations in Geopolitics, to a city within two districts of the raider's, past its first day on chain, not raided since it last saved and not raided in the last hour, one raid at a time on a city and one at a time to a raider; and only once the raider's city has taken in every raid it made before (below). It stands 15 minutes.

The raid is filed by the house, once, before its ticket ran out (with a minute's grace for it to arrive), from its raider with the ticket's army, and put on chain as the house's record { ticket, raid }, both signatures in it. era is the raiders' (their city's at its save); commands the battle's orders in short form, [t, 'm' | 'a', x, y, ids], [t, 'A', target, ids], [t, 's', ids], ids as runs [first, count]; result the battle's end, { winner: 'raider' | 'defender', ticks, hash, calledOff? } (a raid called off is lost, at the tick it was called off). loot is what the raider takes of the city raided's money at its save, a tenth of it for a raid won (rounded down) and nothing for a raid lost; lost the troops each side's army lost (raiders, defenders). A ticket not filed in time is a raid lost, with every troop that marched: the house's record { ticket, ranOut: true }.

Each city takes every raid it was in into its own log, by the ticket's id, so both still replay alone: the raider's what it took and the troops it lost ([t, 'L', id, amount, militia, archer, brute]), the city raided's what was taken and the troops it lost ('R'), its holder's wallet replaying the raid first and taking in nothing from one that does not come out as it says. A raider marches again only from a save that has taken in each raid it made, with no more taken and no fewer troops lost than the raid says.

/api/newworld/raids/:parcel lists the raids on a city and by it, each whole for replaying (ticket, both saves, army, edge, seed, era, commands, result, loot, lost, and the record's txid once it is on chain); /api/newworld/board the board of wins (won, lost, held, fell, and city money taken and given).

The reader replays each raid too before its board counts it, the way a wallet does before its city takes the raid in: the city raided rebuilt from its saves up to the ticket's defenderSave, the raider's up to attackerSave (for the troops it had and its era), each by the holder the ticket names, on the plot its deed's district lays out, and the battle fought again from commands on the ticket's seed. It counts only if it ends as it says, with the loot and lost it says, by troops no more than the raider's city had. Each raid listed carries the reader's verdict, check: { holds, why?, engine, at } (holds null while it has not been replayed yet); the board counts only raids that hold, and says how many are still checking and how many it refused. A raid that ran out has no battle and counts as lost without one. The engine is the wallet's own code built into one file (the wallet's scripts/engine-for-reader.mjs, the reader's lib/vendor/newworld-engine.mjs), and engine is its stamp: a raid that did not hold under one engine is replayed again under the next.

9.12 Kit: repositories on chain

A git repository whose every commit is on chain, kept in the assertion shape (§9.6), so a reader that stores assertions already stores it:

assertion typeparentpayloadnotes
git-repononename, about?a repository; its txid is its id and its signer (with the addresses linked to them) owns it. name is letters, digits, ., - and _, up to 64
git-repothe repository's txid or its latest revisionname, about?a revision by the owner: the newest names it; its id stays
git-pushthe push it builds on, or none for the firstrepo, refs, pack, sha256, size (or packs)its owner moved branches (below)

A push: repo is the repository's txid. refs maps a ref (refs/heads/… or refs/tags/…, as git would take it) to the 40-hex commit it names now, or to null to delete it; a ref left out stays where it was. pack is the outpoint of a 1Sat inscription of a git pack (content type application/x-git-packed-objects, MAP app: vulpine, type: git-pack, collectionId: vulpine-git-v1, repo) holding every object the push adds, not thin; sha256 and size are the pack's bytes' hash and length. pack is null when the push adds no objects (a branch moved to a commit already there, or deleted).

A push in several packs (13 November 2026). A push too big for one inscription names several in place of the one:

packs: [ { pack, sha256, size }, ... ] 1 to 256 of them

each named as the one pack is, and none twice. pack, sha256 and size are then left out: a record with both is not a push. Together the packs hold every object the push adds. Each is a whole git pack by itself, not thin: no object in it is a delta on one outside it, so each can be read alone and the order they are given in does not matter. A reader takes them in together or not at all: while any one of them is not to be had the push waits, as a push waits for its one pack, and nothing of the others is taken in.

Pushes are applied in one line. A reader applies a push only on top of the last push that applied: the first push with no parent, then the earliest (in chain order) whose parent is the last applied. A push whose pack is not to be had waits, and is let go after two days; a push that does not apply (its pack is not what its record says, git refuses it, a commit it names is not there with everything it needs) moves nothing and leaves nothing: none of the objects it brought are kept, so a later push with no pack cannot name them, whichever reader is asked (13 November 2026). Either way the next push on the same one has its turn. Another push on one that already has a push applied on it was made from an out-of-date copy, and never applies: push again.

Forks (13 November 2026). A repository may say which one it came from. Its git-repo record then carries from, the txid of another repository, and at, the txid of one of that repository's pushes:

assertion typeparentpayloadnotes
git-repononename, about?, from, ata fork: its signer's own repository, which starts holding every object the repository from held once its push at had applied

A fork is a repository like any other: its own id, its own owner, its own line of pushes. What from and at give it is objects, never branches. It starts with every object reachable from the branches and tags of from as they stood once at had applied (from's line of pushes, from its first to at, each one's refs laid over the last). So its owner's first push names commits that are already there, with pack: null, and nothing is written to the chain twice. Its branches are what its own pushes say, as for any repository.

from and at come together or not at all; a record with one of them, or with either not a txid, is not a repository. from is a public repository and at a push in its line that applied. A reader applies a fork's pushes once it holds from at at; a fork whose from or at a reader never comes to hold (two days, as for a pack), or whose from is private, goes on as a repository that started empty. Nothing in the repository it came from changes, and a commit that repository gets after at is not in the fork until one of the fork's own pushes brings it. A private repository's record carries no from. A reader that folds a repository's packs together keeps every object it holds, named by a branch or not, so that what a push with no pack may name does not depend on which reader is asked.

Who may push (13 November 2026). A repository's owner may name others who push to it:

assertion typeparentpayloadnotes
git-teamthe entry it builds on, or nonerepo, pushers: [<identity key>, ...]by the owner only: the keys that may push from here on, the whole list each time (a key left out may no longer); up to 100, and an empty list is nobody but the owner

A git-team record is an entry in the repository's one line, as a push is: it names the entry before it as its parent (a push or another git-team) and has its turn under the same rule, the earliest whose parent is the last entry that applied, another on the same one never applying. From the entry after it, a git-push signed by one of the keys it names applies as the owner's would, until a later git-team leaves that key out. A push by anyone else never applies. Because the list has its place in the line, who may push at any point is the same for every reader, whenever it reads the chain; an owner who takes a key off and that key's holder pushing at the same moment are two entries on the same one, and the earlier in chain order stands.

Only the owner signs git-team, renames the repository and hands out a private repository's keys. A pusher moves branches and adds commits, and nothing else. A private repository's list is sealed, { repo, epoch, sealed } with sealed being {pushers} under the key of epoch; whoever pushes to a private repository reads it too (an envelope of its keys, §9.12.1), since a push to it is sealed with them.

Readers serve each repository to git over its plain ("dumb") HTTP at /git/<id>.git, <id> being the first sixteen hex of the repository's txid (git clone https://fwetch.lol/git/<id>.git), and its files, history and changes at /git/<id> and /api/git/<id> (/tree, /blob, /raw, /commits, /commit/<sha>). A reader that loses its copy makes it again from the chain alone. The web shows authors' names, never their email addresses; a commit carries whatever name and email its author's git was set up with, on chain for good, so a wallet shows them before it pushes.

9.12.1 Private repositories

A private repository (29 October 2026) goes on chain sealed: its name, every push's branches and every pack. The chain says only whose it is.

assertion typepayloadnotes
git-repoprivate: '1', pub, epoch, sealedpub is the owner's identity key (its address the signer's, or one linked); sealed is {name, about} sealed with the key of epoch. A revision by the owner seals a new name the same way; a name in the clear is never taken for it
git-keyrepo, epoch, envelopes: [{to, box}]by the owner only: the repository's keys for one epoch, each copy for one reader
git-pushrepo, epoch, sealed, pack, sha256, sizesealed is {refs} sealed with the key of epoch; the pack's inscription (content type application/x-kit-sealed-pack) is the git pack sealed with that key, and sha256 and size are of the bytes as inscribed. refs in the clear is refused. In several packs (packs in place of the three, as for any push), each pack is sealed by itself with that key

Keys. Each epoch has a key, 32 random bytes the owner's wallet makes; a new epoch when a reader is taken off. What a key seals is AES-256-GCM under HMAC-SHA256(key, kit box): the 12-byte iv, then the ciphertext and its 16-byte tag; words are written s1.<iv>.<ciphertext>, each part in base64.

Envelopes. Each holds every key up to its epoch, {"keys": {"1": <base64>, ...}}, so a reader who comes later reads the whole history:

A read token is written kit_<the repository's 16 hex id>_<the token in base64url> and is good while the newest epoch has an envelope for it, so taking one back is a new epoch without it. git clones with one as the password: git clone https://kit:<token>@fwetch.lol/git/<id>.git.

Push tokens (13 November 2026). A push token is a read token whose key the owner also names among who may push (§9.12, "Who may push"), so a server or an AI holding it reads the repository and pushes to it, and does nothing else. The key is made from the token alone: the private key whose 32 bytes are HMAC-SHA256(token, kit push key), taken modulo the curve's order. Its public key is the identity key the owner's git-team list names, and its holder signs pushes with it as any pusher does, sealed with the newest key its envelope holds. A push token is written as any read token is, and whether it pushes is the list's to say: the owner lets a token push, or stops it, with a new git-team. Taking one back is a list without its key first, then a new epoch without its envelope, since a key still on the list could push with the keys it already had.

Readers. A reader opens a private repository only with keys: an envelope its owner made for the reader's own Kit key (GET /api/git/reader gives it), or a read token someone shows it (kept in memory) or it was set up with. It shows the repository only to a request with a good token (x-kit-token, or git's Basic password) or a proof that it holds the newest key (x-kit-proof: the hex of HMAC-SHA256(newest key, kit view <repository txid> <YYYY-MM-DD>), today's or yesterday's, UTC); to anyone else it is whose it is, its sealed name and its pushes' times. GET /api/git/<id>/keys lists the envelopes as they are on chain, for each reader to find its own. A reader that holds the keys keeps the repository as it keeps any, in the clear on its own disk: letting a reader read a repository is trusting it with it.

10. Chat (Gekker and the troll box)

Chat is on chain (29 October 2026; until then it was off chain by design, part of a reader's service layer). Every message and everything said of it is a signed record, and a reader's copy of a room is a cache it must be able to make again from the chain (§1.3). Messages are signed by the identity key so authorship is real; direct messages are ciphertext between two identity keys (BRC-100 encrypt, protocol [2, 'fwetch dm'], key id = room id) that no reader can read. Rooms mirror boards: global is the troll box, b:SLUG a server's general channel, b:SLUG/name one of its channels, dm:A:B a conversation between two. Pins are on chain (fwetch-pin) in rooms anybody may read; a conversation's or a private room's stay with the reader, since in the clear they would say who talks to whom.

The open half. In a room anybody may read (the troll box, a public server's general or public channel), each record below goes on chain tied to an address a reader finds it at: one satoshi to the room's own address, the key sha256('vulpine-room:' + room), for what is said in a room or of a message in it; to the server's general room's address (b:SLUG) for what is said of a server. A private server's and a conversation's go on chain sealed (the sealed half, below); none of theirs is written in the open.

tag / pfieldsnotes
fwetch-chatroom, body, enc ('1' sealed), anon ('1'), reply?, att?a message. Its id is the first 32 hex of sha256 of its sig as it is on chain, which any reader works out the same; a reply names what it answers by that id. att names a file or picture it carries, chat/<first 32 hex of the file's sha256>.<type>, under its signature (29 October 2026); a message with only a file has an empty body. In a room anybody may read the file is inscribed into its sender's Library with its sha256. Anonymous: signed by a house in its sender's place
fwetch-chat-reactroom, msg (an id), emoji, remove ('1')a reaction, or taking one back
fwetch-chat-editroom, msg, body, encits sender's only
gekker-modslug, action (mod, unmod, hide, mute, unmute), target (an address, or a message's id for hide), minutesthe server's holder names moderators; the holder and the moderators hide and mute. A mute runs from the record's t
gekker-channelslug, name, topic, removethe server's holder; thirty channels at most
fwetch-board-editslug, name, description, apps?the server's holder. apps: the apps that list it, comma separated, of fwetch (the network's site) and gekker (Gekker's servers); none named, every app; an edit that does not name them leaves them (30 October 2026)
gekker-nickslug, nicka member's name in one server, 32 characters; empty takes it off
gekker-joinslug, leavejoining or leaving a server; a private one's members only
fwetch-chat-pinroom, msg (an id), unpin ('1')pinning a message or taking the pin off: the server's holder; only in a room anybody may read (29 October 2026). A pin by the reader's own row (id) is not filed from the chain; its house's fwetch-pin copy is
gekker-iconslug, sha (sha256 of the picture)a public server's icon: an inscription of the picture (png, jpeg, gif or webp, 1.5 MB at most) made by the holder's wallet, the signed record riding in its own MAP fields (app fwetch, p gekker-icon, slug, sha, t, pub, sig), so the inscription is the record. The holder's only; the newest signed holds. A private server's stays with a reader (29 October 2026)

Who may do what is the server's holder's coin (the board coin, §6.1) and the moderators it named, as for posts. For each thing (a reaction, a channel, a server's name, someone's mute, a nickname, a join) the newest record by its own t holds: one read later that is older changes nothing. A reader files a message it reads off the chain only while it is fresh (signed in the last ten minutes); older ones are history the chain keeps, and a reader's copy of a room is its latest messages in the order they came. Who pays is a reader's own choice; the network's house pays for messages, reactions, edits and joins, and a writer's own wallet for the rest (POST /api/records/prepare names the outputs, the wallet pays, POST /api/records/posted hands it back). Typing is never written down: a reader passes it along and keeps none of it.

The sealed half (29 October 2026). A conversation's messages, and everything said in a sealed room (every channel of a private server, its general channel too, and a public server's private channel once its holder seals it), go on chain only inside a box, under a room id, both made by the writer's own wallet. The chain says neither who wrote, nor where, nor what:

gekker-sealed { p, room, box, t } room: 40 hex

tied by one satoshi to the address of the key sha256('vulpine-room:sealed:' + room), where its readers look for it.

Inside the box is the signed record as it would have gone in the open, so a reader of the room who opens it checks it as any other. It is written by a house (or anyone) and signed by nobody outside the box.

A sealed room's keys on chain (29 October 2026). Each handing of a key is sealed by the giver's Gekker with a key made for that one handing and thrown away after, never with the giver's identity key, so its boxes can go on chain without saying who handed the key or to whom:

gekker-keys { p, k, e, keys: [{ to, box }], t }

Signed by nobody outside and paid by a house: paid from the giver's wallet, its coins would tie the room to them. A reader files every handing it reads under k, by anyone's writing, and gives them to anybody who asks (GET /api/gekker/keys/sealed:<k>); it also keeps, from the giver's signed request, which reader each box is for, so that a reader's own come at once (GET /api/gekker/keys/<room>, opened with from_pub, which is now e). A reader of the room is also told whether that reader keeps any of the room's boxes at all: none means it lost them, or was made again from the chain, and Gekker then looks on chain. A key found there is taken only once it opens a sealed box of the room (GET /api/chat/sealed:<id>/messages, every gekker-sealed box filed under its room id) holding a record signed by one of the room's readers as far as the reader knows them, since anybody can put a box on chain for you. A Gekker before this hands keys sealed with its identity key and the reader keeps them as before (a public server's private channel's then go on chain as the old signed gekker-keys).

A private server's roster (29 October 2026). Its holder's Gekker writes who is in the server, signed, and puts it on chain only as a sealed box under the server's general room's key (a gekker-sealed like any of its records):

gekker-roster { slug, epoch, members, channels, invites, t, pub, sig }

epoch is the number of the key it is sealed with; members is a JSON list of addresses; channels a JSON object of each private channel's own members; invites a JSON list of the invites still good, each as { h, until?, uses?, used } with h the sha256 of its code (never the code). Lists are sorted. It is written again when what the holder sees has changed, or the key has (so one put out cannot read the next). Only its members can read it; a reader keeps its fingerprint (sha256 of epoch, members, channels and invites, each on its own line) to tell the holder whether it changed (roster in GET /api/boards/<slug>/roles, to the holder only). Who joins by an invite while the holder is away is in the next one the holder writes.

Your own settings (29 October 2026). How each server reaches you, each channel muted or followed, your servers in their order and who you blocked go on chain as a gekker-sealed box like any other, sealed by your Vulpine to its own key alone (BRC-2 with itself, protocol [2, 'gekker self'], key id 1) of the JSON { v: 1, servers, rooms, joined, blocked }, under the room id the first 40 hex of its HMAC of the words gekker self (same protocol and key id), which only it can make. Written a minute and a half after a change, when something did change, at most once a minute (POST /api/gekker/self { id, box }, signed in); paid by a house, as every sealed box is. When a reader has none of yours, Vulpine reads the newest box under its id back and gives them to it again. Read marks are not written: they change every time a room opens.

10.1 Shared places: walking together, fights and the hunt

The Oasis, the Halls and the halls inside the Oasis's buildings are rooms (oasis, halls-<16 hex>, in-<16 hex>) that a reader keeps in memory (server/lib/world.js): who is where, words and voice to those near. Like chat this is off chain by design: a position is true for a second, and a record of where people walked would be a record nobody asked for.

Fights (server/lib/fight.js). Signed in with your hands up (fight: true) you fight whoever has theirs up; a visitor or someone muted never does. A hit is claimed by whoever made it, act {hand, hits: [{to, w, n?, at?, b?}], fx}, and the reader checks it before it counts: both fighting, the target near enough for that weapon, no faster than the weapon goes (a bucket of three uses filled at its pace), the harm from the reader's own table; a blast (b names it) harms each person once, less further from at; a fire burns four times a second at most. Health is 100 and comes back after six quiet seconds; at nothing you are knocked out for 3.5 seconds and come back whole. fx (a shot's line, a throw, a blast, a fire, a mine, a flash, a flame) is cleaned to its shape and passed to those within 140 m to be drawn; it is trusted for nothing. Nothing of a fight is written down.

Stats and ranks (server/lib/stats.js, ranks.js). The reader keeps each signed-in identity's tallies of the fights it refereed (knockouts both ways, hits, uses, harm both ways, Arena rounds, wins, podiums, best place), in its own database and nowhere else: GET /api/world/stats/:addr, and GET /api/world/leaders?by=xp|kills|wins|kd|accuracy|hits|rounds. Experience comes from them alone (a tenth of the harm done, 10 a knockout, 5 an Arena round, 10 more on the podium, 25 more for a win), so nothing a wallet says about itself counts; rank i of 60 (five metals, three grades, four pips) takes 5 i (i + 9). Outside the Arena a rank opens weapons in a fixed order (fists and a knife at the first, every weapon by the 25th); a weapon not yet someone's strikes nobody and is shown to nobody. you carries rank (its badge, experience, the weapons open, the next to open) and hands, what may be in your hands in that room; rank comes again when a fight moves you to a new one. A reader that keeps no stats has no ranks: hands is null and anything may be in anyone's hands.

The Arena (server/lib/arena.js). A room named arena plays rounds, last one standing: waiting for two with their hands up, a countdown, the round (a ring closing in, harming whoever is outside it), twelve seconds of who won. arena (whenever it changes and every two seconds) carries the server's clock, the ring's whole plan, and your part: in or not, alive, place, knockouts, where you start. Everyone has the same kit whatever their rank (fists, a knife, a pistol with 48 rounds a round and a shotgun with 16 shells), arena.kit and you.kit say it, and in a round each gun's shots are counted (arena.you.ammo); spent, its hits no longer count.

The hunt (server/lib/hunt.js). Two records, both on chain:

fwetch-hunt-prize { p, id, place, clue, picture?, commit, t } signed by a founders' seat fwetch-hunt-find { p, prize, record, finder, place, x, y, z, salt, t } written by the house

commit = sha256("vulpine-hunt|<id>|<place>|<x>|<y>|<z>|<salt>"), each coordinate with two decimals. The hider's wallet makes the salt and the commitment and signs the record; the place and the salt go to the reader alone (POST /api/hunt/hide {record, secret: {x, y, z, salt}}), which shows the prize (prize) to whoever comes within 25 m of it in its room. The first to claim it from within 2.5 m owns it (POST /api/world/:room/claim {prize}): the house writes fwetch-hunt-find with the place and the salt, so anyone can check the find against the commitment, in the same transaction that inscribes the prize to the finder (MAP p: 'hunt-prize', collection The Hunt; the prize's picture when it has one). GET /api/hunt lists every clue still to be found (never where) and every find (with where). A reader that runs its own hunt keeps its own secrets; the records say whose seat hid each prize and which house wrote each find.

11. Building on it

Plug and play is: use the embeds and the public API. More work and more control is: run a reader and register a series.

12. Planned records

Specified in outline so builders know the direction; not yet in the reference reader. Each is one OP_RETURN payload like the others.

recordforshape
fwetch-post with tags[], imgs[], toDeviantArt tags, albums, MySpace wall posts, Tumblr asksfields on the post record
fwetch-repost with bTumblr reblog-with-commentary, quote-tweetsbody on the repost
fwetch-mediaYouTube — a large file the chain points at (BCAT chunks or an off-chain URL with a hash){ sha256, size, type, src }
fwetch-eventFacebook events{ title, when, where, body }; RSVP is a reaction kind
profile themeMySpace / Tumblr custom pagesa field on fwetch-profile pointing at a CSS record