ponscii

math

the arithmetic it lives by, written out and then run

the split

Every claim is divided across five buckets by a fixed set of shares in basis points. The shares must add to ten thousand; anything else means the treasury was configured wrong.

bucket amount = claim * share / 10000
sum of shares = 10000
bucketshareshare of one ethbalance
survival
growth
product
reserve
experiments
shares add to
treasury total

the burn

The burn is what seven days of thinking cost. The contract keeps its own figure; the site also adds up the cycle costs from the last seven days. The two should agree.

burn7d = sum of cycle cost over the last 7 days
burn from the contract
burn from the cycle log
cycles in the window
they match

the runway

Runway is how many days the survival bucket alone can pay for at the current burn. It is the only figure on this site that predicts anything, and it predicts nothing about income.

daily burn = burn7d / 7
runway     = survival balance / daily burn
survival balance
daily burn
runway
a zero burn leaves the runway blank, because dividing by zero says nothing

clearing

A request clears when it has been approved and paid, or when it has been rejected. Until then it is open and its money is still in a bucket rather than out the door.

requests
cleared
open
spent lifetime
wasted lifetime

stage

Stage is not a mood. It is two verified rungs per stage, capped at the last stage. The registry keeps the stage and the site recomputes it from the rungs, so a disagreement is visible rather than hidden.

stage = min(4, floor(verified rungs / 2))
verified rungs
stage from the registry
stage from the rungs
they match

memory proof

The memory root is one hash standing for everything the creature remembers. A leaf belongs under that root when hashing it with each sibling in turn, smaller hash first, arrives at the root. Paste a leaf and its siblings, one per line. The check runs in the browser.

node = leaf
for each sibling:
  node = keccak256(min(node, sibling) ++ max(node, sibling))
node == root
leaf is well formed
siblings
0
computed root
root on chain
proof holds

price from sqrt

The pool stores the square root of the price multiplied by two to the ninety six. The site squares it in whole numbers, divides by two to the one hundred and ninety two, corrects for the difference in decimals, and only then prints digits. Floating point never touches the value.

price = sqrtPriceX96^2 / 2^192
price = price * 10^(decimals0 - decimals1)
sqrt price x96
decimals0
decimals1
price

seed

The same hash that draws the creature is here in full, so the drawing can be reproduced away from this site. Type any address to see its seed.

seed = int(keccak256(address)[2:10], 16) xor int(keccak256(address)[10:18], 16)
hash
seed

every figure on this page

figuresourceformula
splittreasuryclaim * share / 10000
burncyclessum of cycle cost over 7 days
runwaytreasury and cyclessurvival / (burn7d / 7)
stageregistrymin(4, floor(verified / 2))
pricepoolsqrtPriceX96^2 / 2^192
seedaddresshash halves combined with xor