what is obsrvtry

a sky without an edge. an observatory on a mountain logs the night one star after another, with no pause and no last number. you can find a star with your browser for free, or buy a dim one for a few dollars. every star ever recorded after yours pays you a share.

obsrvtry is an NFT collection on Robinhood Chain. every token is an observation: a real object of the deep sky, a star, a double, a cluster, a galaxy, a nebula. what it is, what colour it has and where it sits on the map all come from one thing: the hash that made it. nothing is uploaded, nothing is drawn by hand; the contract draws the plate itself.

three things obsrvtry does not have: a gate, a token, a watchman. nothing waits for a timer, nothing needs a bot to run, nothing is minted by the team ahead of you. the contract has no owner and no pause button. the one thing that reads the time is the fever, and it only ever makes the sky cool down.

quick start

for people who want a star and do not care how the sausage is made.

1. open the map and press connect. a wallet with Robinhood Chain is needed (MetaMask, Rabby, and friends). the site offers to add the chain if your wallet has never seen it.
2. press observe. your browser starts looking for a star. the status line shows the speed and how long it should take at this pace. on the first rings a phone finds one in seconds, a laptop in a blink.
3. sign the transaction when a star is found. gas on Robinhood Chain costs a fraction of a cent. that is all a found star costs: gas.
4. see it on the map. the site flies to your new star, opens its plate and puts a gold frame around it. its number, class, brightness and position are yours for good.
5. come back and press collect whenever you like. every purchase made after your star put a share in your waiting. it never expires.

in a hurry, or the pace is too slow for your device? press or buy one. a bought record is a dim dwarf with a place on the map like any other, and it earns like any other record of weight 1.

why it has value

the honest question about a collection with no last number: why would a star be worth anything if there can always be another one? four answers.

1. the sky gets darker

every 500 records, one ring of the galaxy, the mark doubles. ring 0 wants about a million hashes, a phone does that in a couple of seconds. ring 10 wants a billion, a phone needs most of an hour. ring 20 wants a trillion, a farm needs twenty minutes and a phone a month. ring 30 wants a quadrillion. the sky has no edge, but past a point nobody can reach it. the supply is bounded by physics, not by a number in a contract, and every star that exists sits on the near side of that wall.

2. every later star pays every earlier one

70 percent of every purchase and half of every royalty is split, at once, among all records that already exist: half of it equally, one share per record, and half by weight. every star gets a share, a bright star gets a bonus. the earlier your star, the more purchases happen after it, the more it earns over its life. an early star is a claim on the whole future of the sky. that is the same engine that put a floor under prspct: a paper that pays does not go to zero.

3. the object is the hash

class, colour, shape and place come from the hash, and the hash comes from work. a quasar or a planetary nebula cannot be bought, chosen or minted by the team: it can only be found, and only with a hash at least eight bits below the mark. the rare things are rare because they are hard, not because a table says so.

4. the map is the product

one galaxy grows record by record. early stars sit near the core, late ones on the outer arms. your star has an address you can send as a link. a collection that people open to look at, not only to trade, holds attention longer than a grid of thumbnails.

a sky without an edge

records are numbered from 1 upward without end. there is no total, no sold out, no phase two. the only gates are openAt, the moment the sky starts taking records, and the mark, which rises forever.

rings

500 records make a ring: on the map they lie in one ring of the galaxy around the core, and the plate carries the ring's number. on the border of a ring two things step: the mark doubles (one more zero bit) and the price grows by fifteen percent. the ring is a label, not a gate. record 501 can be made in the same block as record 500.

what stops it

nothing stops it. the mark has a ceiling far beyond any hardware (200 bits above the base) and the price stops climbing after ring 64 (about 2.3 ETH per record). long before either, the pace of new records falls to a trickle: each new star is a real achievement or a real purchase, and both pay everyone who came before.

work: find a star

the site builds a 120 byte message and hashes it with keccak256 over and over, changing only the last eight bytes (the nonce), until the result is below the mark. that is the whole miner. it runs in web workers, one per core minus one, so your browser stays usable.

message  = "obsrvtry" | chainId (32 bytes) | observatory (20) | ringSeed (32) | you (20) | nonce (8)
star     = keccak256(message)
found    = star < 2^256 / 2^(baseBits + ring + fever)

the message holds your address, so a star found by you cannot be filed by anyone else. it holds the ring seed, a block hash taken the moment the ring opened, so nobody can mine the next ring today. when you sign observe(nonce) the contract recomputes the hash and checks it against the mark of that moment.

what work costs

gas and electricity. on Robinhood Chain a record costs well under a cent of gas. the electricity is the real price of a late star, and that is the point: it is what keeps the sky scarce.

buy: a dim one

send the price of the moment with observe and the contract records a purchase instead of checking a hash. change comes back. observeMany(n) buys up to ten in one transaction, each at the price of its moment (the site adds them up for you, including a ring border inside the batch).

a bought record has brightness 0 and weight 1. it gets a hash of its own (from the ring seed, its number and the buyer), and that hash picks its class from the bottom rung of the ladder, exactly like a found star of brightness 0: a dwarf, a star, a double, or now and then a comet. it has a place and a colour like any other record and it earns like any record of weight 1. what it cannot be is bright or rare.

who buys? people on a phone past ring 10, people who want ten records in one go, people who value their time over their electricity. and every purchase is the event that pays everyone else.

brightness and weight

brightness (magnitude on the plate) is how many zero bits your hash has above the mark. a hash that just scrapes under the mark is brightness 0. one that is twice as small is brightness 1, four times is 2, and so on. each step is twice as unlikely: a brightness 8 star is one in 256 among stars found at the same mark.

weight is 2 to the brightness, capped at 8 bits: 1, 2, 4, 8, 16, 32, 64, 128, 256. weight is your share of the weighted half of the till. the other half is split equally, one share per record, so a brightness 8 star earns 256 times what a dwarf earns from the weighted half, and exactly the same from the equal half.

the cap matters: a farm that finds a hash 20 bits below the mark gets weight 256, not a million. one lucky hash cannot own the sky.

overhype: the sky runs hot

the rings set the long slope of the night. the fever handles the bursts. every record, found or bought, adds 10 heat to the sky. heat cools by 20 every second. every 300 heat that has not cooled puts one more zero bit on the mark, twelve bits at most. heat itself is capped at 4 000, so no burst can leave a wall standing for longer than three minutes after it stops. that is the whole rule.

the map shows a red overhype chip with the extra bits and the seconds until the sky is cool. your browser keeps looking through a fever; if the mark moves while a star is on its way, the site simply looks again. the price is never touched by the fever: buying stays open at the ring's price, and every purchase pays the sky.

heat      = min(4000, max(0, heat - 20 * secondsSinceLast) + 10 per record)
fever     = min(12, heat / 300)
bits      = baseBits + ring + fever

objects and rarity

the last byte of the hash picks the class from a ladder that depends on brightness. the brighter the hash, the more of the ladder is open. a bought record draws from the bottom rung, like a found star of brightness 0. fourteen classes:

colour is the spectral class, O B A F G K M, weighted toward the middle like a real sky. tilt, arm count, the gap of a double, the pillars of a nebula, the tail of a comet: all from bytes of the hash. two records of the same class never look the same.

the plate is 96 by 96 pixels, drawn by the contract from integer arithmetic on the hash. the site draws the same object on the map with the same code; the prototype lives in the repository as art/plate.py and the contract must match it byte for byte.

the map

one galaxy, growing. record number n lies at a radius proportional to the square root of n, on one of four spiral arms chosen by its hash, with a little scatter also from the hash. early records crowd the core; the newest are always on the rim. the galaxy gets bigger as the night goes on and never runs out of room.

• drag to pan, wheel or pinch to zoom. far out, records are coloured points by class and brightness; close in, they become their plates.
• click an object for its card: plate, class, brightness, ring, weight, position, holder, waiting.
• find: type No. 421 to fly to a record, or paste an address to list what it holds.
• my stars: every record your wallet holds, with waiting per record, one click to fly, one to collect all.
• the address bar keeps your place: #No.421 or #x,y,zoom. send it to a friend.

the map reads the chain directly through two public views, sky() and stars(from). no server, no indexer, no account. the whole site is one file.

how the money flows

there is no pot that waits. every purchase is split the moment it arrives:

"equally" means the money is divided by the number of records; "by weight" means it is divided by the total weight and each record gets its weight's worth. the contract keeps two running numbers, perRecord and perWeight, the wei one record and one unit of weight have been owed since the beginning. your record's earnings are the growth of those numbers since it was made, times one and times its weight. this is why a purchase costs the same gas whether the sky holds ten records or ten million.

a new record does not share in its own purchase. the very first purchase of the sky goes to the observatory in full, because there is nobody to share with yet.

collecting

earnings sit in the contract until the holder takes them. collect(ids) pays out everything owed on the records you list, in one transfer. the card shows waiting for one record; my stars shows the sum and has collect all.

earnings belong to the paper, not to the person. sell a star and its future earnings, and whatever is still waiting on it, go to the buyer. that is deliberate: it is what makes a star with a history worth more than a fresh one, and it is what puts a floor under the price.

trading and royalties

obsrvtry is a standard ERC-721 with ERC-2981 royalties of 5 percent and the ERC721-C transfer validator that the marketplaces on Robinhood Chain honour. list and trade on any marketplace that supports the chain; OpenSea is the first.

half of every royalty is shared with every record in existence, forever, and half goes to the observatory. a lively secondary market is therefore income for every holder, not only for the author. the plate's earned trait updates live and shows what a record has made in its life.

every number

farms, bots and the first hour

yes, farms will come. a GPU farm at 1 GH/s clears ring 0 in milliseconds per star and stays comfortable until page 20. the rules assume that and make it fair rather than pretend it will not happen.

• the first hour after the first record allows 3 records an address. a farm can rotate addresses, but each costs gas and time, and the hour ends. it exists to give humans the core of the galaxy, not to stop farms.
• the weight cap means a farm earns by making many records, not by one absurd hash. many records means many gas payments and, past ring 15, real electricity.
• the equal half of the till does not care about weight at all: a phone's dwarf and a farm's brightest star get the same coin from it. the farm's edge is only in the weighted half and in how many records it can make.
• farms pay everyone before them. every star a farm finds is a new mouth at the till, and its purchases (if it buys to keep up) pay you. a farm on ring 30 is the best thing that can happen to a record from ring 0.
• the fever is the only clock in the sky, and it only runs hot: bursts above two records a second raise the mark within seconds, and it falls back within minutes. a farm cannot sprint; it can only walk at the sky's pace, and the sky's pace is set by the rings.
• the seed is set the moment a ring opens, so nobody can precompute the next ring. the ring closes in the same transaction as the 500th record; a bot watching for RingOpened gets the new seed as fast as anyone.

write your own miner if you like. the message layout is above, the target is target(), the seed is in sky(). send observe(nonce) from the address in the message.

formulas and ABI

// the mark
ring      = count / 500
heat      = min(4000, max(0, heat - 20 * dt) + 10 per record)
fever     = min(12, heat / 300)
bits      = baseBits + min(ring, 200) + fever
target    = type(uint256).max >> bits

// the price
price     = 0.0003 ether * 1.15 ^ min(ring, 64)

// brightness and weight
brightness = zero bits of the hash above the mark
weight     = 2 ^ min(brightness, 8)

// sharing: half of the till equally, half by weight
perRecord += (till / 2) * 1e18 / count
perWeight += (till / 2) * 1e18 / totalWeight
owed(id)   = (perRecord - debtR(id)) + weight(id) * perWeight - debt(id)

function observe(uint64 nonce) payable          // work, or a purchase when msg.value >= price()
function observeMany(uint8 n) payable          // up to 10 purchases
function collect(uint32[] ids)                 // take what your records earned
function keeperCollect()                       // the observatory takes its share

function sky() view returns (uint32 count, uint256 price, uint256 target, uint256 totalWeight,
                             uint256 perWeight, uint256 perRecord, bytes32 seed, uint256 heat, uint256 fever)
function heatNow() view returns (uint256)
function fever() view returns (uint256)
function coolsIn() view returns (uint256)
function stars(uint32 from) view returns (bytes32[] hashes, bytes magnitudes)  // 500 at a time, 255 = bought
function waiting(uint32 id) view returns (uint256)
function starHash(address observer, uint64 nonce) view returns (bytes32)
function target() view returns (uint256)
function price() view returns (uint256)

event Observed(uint32 indexed id, address indexed observer, bytes32 star, uint8 magnitude, bool bought, uint256 paid)
event RingOpened(uint32 indexed ring, bytes32 seed, uint256 price, uint256 target)
event Shared(uint256 eth, uint256 perWeight, uint256 perRecord)
event Collected(uint32 indexed id, uint256 eth)

contracts

chain: Robinhood Chain, id 4663. explorer: robin.etherscan.io. the contracts are verified and have no owner functions beyond naming the transfer validator on the ERC-721.

the observatory

a mountain observatory at the end of the nineteenth century, one long clear night. the logbook is open and the entries go in one after another, and nobody knows how long the night will last. whoever wants a line in the almanac either sits at the eyepiece and finds a star (work), or pays the keeper for a line (a purchase). the keeper splits the money on the spot among everyone already in the book: the brighter your star, the bigger your cut of every line that follows. every five hundred lines the keeper draws one more ring on the chart: the telescope is stopped down, the sky is darker, the stars are further, the line costs more, but the pen does not stop.

faq

is there a whitelist, a presale, a team allocation?

no, no, and no. the team finds stars like everyone else, after openAt, under the same first hour cap.

what does it cost to mint?

gas, if you find a star. gas plus the price of the moment, if you buy.

can i lose my star?

only by selling or sending it. the contract cannot take it back; nobody can.

what if my browser finds a star and the transaction fails?

the site keeps the nonce and shows it. send again while the ring is the same. if the ring closed, the star is void and you look again.

why is a bought record always dim?

because brightness is proof of work, and a purchase has none. a bought record draws its class from the bottom rung (dwarf, star, double, comet), earns like any weight 1 record, and has its place and colour like any other.

does the collection ever end?

no. it gets darker. by ring 40 nobody alive can find a star and a purchase costs 0.08 ETH; new records slow to a trickle and each one pays everyone before it.

where does the art live?

in the contract. the plate is drawn from the hash on every tokenURI call. no IPFS, no server.

can i run my own miner?

yes, see farms and formulas above. the site's miner is just the convenient one.

why is the royalty receiver a contract, and what happens to WETH royalties?

so that half of every royalty reaches the sky without anyone's hands on it. the price of that is real: the contract only understands native ETH, so royalties paid in WETH (offers) or USDG are lost. list in ETH, buy listings in ETH, and the sky gets paid.

is the site a server?

no. one HTML file on static hosting that talks to the public RPC. you can download it and open it locally.

glossary