Permanent supply destruction, on a rhythm.

Overview

Most supply burns are announcements: a team promises to buy back later, a multisig holds the keys, a forum argues about how much. GLOWTHERY cuts the promise out. Every letscash token gets a burn address, and that address exists before anyone deploys the token.

Point money at that address — yours, your fees, or your community's — and it goes straight to work. Half of your share buys the token at market and burns it, so totalSupply falls permanently. The other half is committed as market-making inventory. Both legs run on a rhythm anyone can watch, on Robinhood Chain (chain 4663).

Quickstart

There are two ways in. If you just want to watch supply leave, everything is on the homepage as a live overlay — no install, no SDK, no wallet. If you want data, the read API is one fetch away.

From the browser

1. 1 · Open a token

   Paste any letscash token address into the Console. Its vault page shows the state, the fuel left, and how much supply is already gone.

2. 2 · Fund the vault

   Send ETH to the vault address from any wallet on chain 4663. No connection needed — it works straight from the chain.

3. 3 · Pick prepaid or perpetual

   Prepaid burns down over the schedule you set. Perpetual points the token's own fee stream in, so the vault refills itself.

4. 4 · Watch the beat

   Open Explorer, pick a recent beat, and run Explain last burn to have the engine narrate what it bought and burned, in plain English.

From code

Read the latest beat over the public REST API. No auth for read endpoints.

curl https://glowthery.xyz/v1/beat/latest

const res = await fetch("https://glowthery.xyz/v1/beat/latest");
const beat = await res.json();
console.log(beat.number, beat.receipt.summary);

import requests
beat = requests.get("https://glowthery.xyz/v1/beat/latest").json()
print(beat["beat"], beat["receipt"]["summary"])

That's the live read API. The full endpoint list is in API Reference.

How it works

The engine runs a single repeating beat. Each pass buys once and burns once. There is no discretion between steps, nobody deciding whether this is a good moment, and no way to skim the middle. The bytecode owns the whole cycle.

1. 1 · Derive

   Every letscash token has one burn address, derived before the token is deployed. Nobody assigns it and nobody can move it.

2. 2 · Fund

   ETH arrives, prepaid or perpetual. From here it is fuel, committed to the schedule and spent beat by beat.

3. 3 · Arm

   A fresh vault reads enough price history before it trades, so the first buy lands at a fair price instead of blind.

4. 4 · Buy

   On the beat, half of your share buys the token at market. The size comes from the pace and the fuel left, not from anyone's opinion about price.

5. 5 · Burn

   Everything bought goes to the burn address. Supply is destroyed: totalSupply falls and never recovers.

6. 6 · Commit

   The other half stays as market-making inventory and works the book from the very first beat, tightening the spread around the token.

Anatomy of a beat

A trimmed trace of one beat, as the Console shows it:

The same stream is visible live on the homepage Console — this is not a render of stored logs, it is the engine working.

The Split

GLOWTHERY is five cooperating layers. The vault holds the money that can't leave; everything below it exists to spend it on the beat, record what left supply, and show it to anyone.

The Console and Explorer ship on the homepage as live overlays. The same data that powers the Explorer is exposed over REST — see API Reference.

The Economy

Every path through the engine takes a house cut: 10% on tokens with a 1% tax, 33% above that. Of what the house takes, 5% buys this project's token and burns it. The rest of your share is yours: half burned, half market-making inventory. The cut is capped in bytecode and lowerable only — check it yourself.

The split and the cap live in the bytecode, not in a policy doc. The cut can be lowered and never raised, and you can read the limit on-chain instead of trusting this page.

Receipts & proof

Every beat leaves a receipt: what was bought, what was burned, and what stayed as inventory. The interesting part is that you do not have to believe it. Supply destroyed is visible in totalSupply(), which only ever goes down.

Burned supply and market-making inventory are two different things, so they are reported separately. Each number stands on its own, exactly as the chain recorded it.

Anatomy of a receipt

Pull recent receipts from GET /v1/receipts — see API Reference. The destruction is permanent. It can't drift from the numbers, because the chain holds both.

API Reference

GLOWTHERY exposes a small REST surface over the vaults. Read endpoints need no auth. All responses are JSON; addresses are hex; beats are integers. The base URL is https://glowthery.xyz.

GET /v1/beat/latest

Returns the newest closed beat. The receipt is embedded so a single round-trip gives you both the numbers and the wording.

curl -s https://glowthery.xyz/v1/beat/latest | jq .

const r = await fetch("https://glowthery.xyz/v1/beat/latest");
if (!r.ok) throw new Error(`glowthery ${r.status}`);
const beat = await r.json();

import requests
r = requests.get("https://glowthery.xyz/v1/beat/latest", timeout=10)
r.raise_for_status()
beat = r.json()

{
  "beat": 2834,
  "vault": "0x0000000000000000000000000000000000000000",
  "tx": "0x9eK2bB4cT7vQ1mNqR8sWfYxZ3dGhJ5pLnV6uA2cE9rD",
  "burned": 41203,
  "mm_volume": 0.000130,
  "state": "charging",
  "receipt": {
    "summary": "Bought and burned 41,203 tokens. Supply is down permanently.",
    "total_supply": 888726000,
    "supply_destroyed": "11.1274%"
  }
}

POST /v1/explain

Hand the engine a beat reference and get back a narration — the same thing the Explorer's Explain last burn runs.

curl -X POST https://glowthery.xyz/v1/explain \
  -H "content-type: application/json" \
  -d '{"beat":"latest"}'

const r = await fetch("https://glowthery.xyz/v1/explain", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ beat: "latest" }),
});
const { narration } = await r.json();

import requests
r = requests.post(
    "https://glowthery.xyz/v1/explain",
    json={"beat": "latest"},
)
print(r.json()["narration"])

{
  "beat": 2834,
  "narration": "The engine bought 41,203 tokens at market and sent them"
              "to the burn address. Supply is down 11.1274% and does not"
              "recover. The other half was committed as inventory.",
  "total_supply": 888726000
}

These endpoints are live and open, no auth for reads. The burn address never changes either — it is derived, not assigned.

Machines

GLOWTHERY is meant to be read by machines first. Anything a human sees on screen has a JSON twin a bot can parse. You check destroyed supply as data, never as a screenshot.

Discover the engine from one file

A bot bootstraps by reading the descriptor, then follows the endpoints it advertises:

# 1. read the machine-readable descriptor
curl -s https://glowthery.xyz/.well-known/glowthery.json
# 2. read the LLM brief
curl -s https://glowthery.xyz/llms.txt

// bootstrap: descriptor → endpoints → latest state
const desc = await (
  await fetch("https://glowthery.xyz/.well-known/glowthery.json")
).json();
const latest = await (await fetch(desc.endpoints.latestBeat)).json();
console.log(latest.receipt.summary);

import requests
desc = requests.get(
    "https://glowthery.xyz/.well-known/glowthery.json"
).json()
latest = requests.get(desc["endpoints"]["latestBeat"]).json()
print(latest["receipt"]["summary"])

The machine-native files (/llms.txt, /.well-known/glowthery.json) ship alongside the site so any model can find its way around the engine on its own.

Examples

Copy-paste recipes for the three things people do most: read the latest beat, ask the engine to explain a burn, and check what a vault is doing right now.

Fetch the latest beat

async function tip() {
  const r = await fetch("https://glowthery.xyz/v1/beat/latest");
  const b = await r.json();
  return `#${b.beat} — ${b.receipt.summary}`;
}
tip().then(console.log);

import requests
b = requests.get("https://glowthery.xyz/v1/beat/latest").json()
print(f"#{b['slot']} — {b['receipt']['summary']}")

curl -s https://glowthery.xyz/v1/beat/latest \
  | jq -r '"#\(.slot) — \(.receipt.summary)"'

Explain a burn

const r = await fetch("https://glowthery.xyz/v1/explain", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ beat: 2834 }),
});
console.log((await r.json()).narration);

import requests
r = requests.post(
    "https://glowthery.xyz/v1/explain",
    json={"beat": 2834},
)
print(r.json()["narration"])

curl -s -X POST https://glowthery.xyz/v1/explain \
  -H "content-type: application/json" \
  -d '{"beat":2834}' | jq -r .narration

Check a vault

// is this vault BURNING or STALLED right now?
const r = await fetch("https://glowthery.xyz/v1/engine");
const { state, task } = await r.json();
console.log(state, task);

import requests
a = requests.get("https://glowthery.xyz/v1/engine").json()
print(a["state"], a["task"])

curl -s https://glowthery.xyz/v1/engine \
  | jq -r '"\(.state) — \(.task)"'

The Console, Explorer, and funding panel also open as overlays on the homepage — bookmark it and you have the whole engine in one tab.

Security

The security model is the design: every guarantee lives in the bytecode, where it holds on its own instead of resting on anyone's word.

• Rug-proof by construction. A vault has no payout function, so there is no path for anyone — team, treasury or us — to drain it. That is not a policy, it is the shape of the code.
• Fixed split. Half burned, half market-making is set in bytecode. Nobody can retune it mid-flight to send more of your money somewhere else.
• Cap lowerable only. The house cut can be reduced and never raised. The ceiling is in the contract, so you do not have to trust this page for it.
• Supply is checkable. Destroyed supply shows up in totalSupply(), which only moves down. You can verify every claim on this site against the token itself.
• Runs on the chain itself. The vault address takes ETH from any wallet on chain 4663 and keeps burning on schedule, entirely on-chain.

Governance

Almost everything a governance page usually argues about is already settled in bytecode: the split, the burn address and the cap ceiling. What is left is small, and it is stated plainly.

• The pace is yours. Whoever launched the token sets how often it burns and for how long, right from the vault page.
• The cut can only fall. 10% on 1%-tax tokens, 33% above. It is capped in bytecode and lowerable only.
• Every beat leaves a receipt. What was bought, what was burned and what stayed as inventory — each reported on its own, straight from the chain.
• Audit it against the token. Anyone can compare the numbers here to totalSupply() and see them line up, beat for beat.

As more vaults come online the surface grows — and the rule stays the same: every wei moves through the burn or the book.

FAQ & disclaimer

Where does my ETH go?

Straight to work, on the next beat. Half buys the token at market and sends it to the burn address, half is committed as market-making inventory that tightens the spread.

What does "permanent supply destruction, on a rhythm" actually mean?

Tokens are bought at market and sent to a burn address, so totalSupply falls and never recovers. "On a rhythm" means it happens on a fixed beat — every minute, every hour, or whatever pace the launcher set — not in one announcement.

What is the market-making half for?

It works the book as inventory, tightening the spread around the token. Inventory and burned supply are different things, so both numbers are shown on their own. More on the cut in Governance.

Is the Console real or a replay?

Real. The fund → arm → buy → burn → commit beat you see is the engine running as you watch, not a recording.

Is there an API I can build on?

Yes, a small REST surface over the vaults. See API Reference for endpoints and Machines for the machine-readable descriptor and /llms.txt. Everything a human sees on screen has a JSON twin.

Where is the token contract?

It appears in The Economy and in the top bar across the site the moment it goes live — that is the one to trust.