A hamster-powered proof-of-work toychain on Ethereum

How Squeekchain turns a hamster's wheel into $SQK on Ethereum: the system that records the work, the economy built on it, and what you have to trust.

Squeektoshi, a hamster, runs on the WHEELY9000. Each time the wheel's magnet passes its sensor counts as one unit of work. SqueekCore settles that work on Ethereum into Squeek blocks. Once mining starts, SqueekMining issues $SQK for every completed block and funds Staking, which streams it to the accounts that stake Squeeks and $SQK. { .wp-lede }

In active development Squeekchain is still being built. Parts of this paper, the pool in particular, describe contracts that haven't been deployed yet and can change before they ship. Values that aren't set yet are marked TBD, and values proposed for launch are marked proposed.

The System

Introduction

Squeekchain has one source of work, the WHEELY9000; one unit, an accepted magnet passage; one ledger, SqueekCore on Ethereum; and one token, $SQK. This paper describes it in three parts. The System follows work from the wheel to Squeek blocks on Ethereum. The Economy covers $SQK, its pool, the Squeeks and how accounts earn with them. Trust covers who can change what, what the system proves and what happens when a part fails.

Figure 1 follows one round of work from the wheel to a wallet.

--8<-- "f01-journey.md"

Only the WHEELY9000 records work, and only SqueekCore settles it. The website, the livestream and this paper show copies.

The parts and how they relate

Each part of Squeekchain has a narrow job. Work moves along one path, from the device to SqueekCore, and every other surface reads copies of that path's records. A copy can be shown, cached or rebuilt, but it can't change the record it came from.

--8<-- "f02-system-map.md"

Measuring work

The WHEELY9000 has a magnet on the wheel and a Hall sensor beside it. A small controller, the Pico, reports each time the sensor turns active or inactive. The Pi decides which of those changes count, and saves every accepted passage before doing anything else with it. One accepted passage is one work unit.

The rules are strict on purpose. The sensor has to read inactive for at least 10 ms before it can count again, accepted passages are at least 60 ms apart, and a magnet that stays in front of the sensor counts once. If the clock, storage or sensor stream becomes uncertain, the device stops counting rather than guess.

--8<-- "f03-signal.md"

Work is grouped into rounds of exactly 600 seconds, ten minutes, counted from a fixed starting point. When a round ends, the device saves its total, including rounds with no work, and it never moves work from one round to another. A round can hold at most 10,000 work units, which is exactly as many as the 60 ms spacing allows in ten minutes. The cap is a safety limit: a passage beyond it would be rejected, and the device would stop counting until an operator steps in.

--8<-- "f04-rounds.md"

Counting doesn't depend on the internet. If the connection drops, the device keeps counting and closing rounds, and holds its signed upload until the Oracle answers.

One accepted passage is one work unit. Nothing downstream can add, remove or move it.

From the wheel to Ethereum

Each upload is signed over its exact bytes by the device's Trust M chip. The Oracle checks the signature before it reads anything else, then accepts, rejects or quarantines the upload. Only accepted rounds can be settled: a rejected upload leaves evidence behind, but no work.

Every five minutes the Reporter looks for accepted rounds that are ready. It builds a batch that moves the frontier, the last round settled so far, forward. Rounds with work are listed, at most 16 of them, and every round in between that has no work is certified as zero. The Reporter signs the batch with a one-use number, the nonce, and a deadline, and a separate relayer pays the gas to send it.

SqueekCore checks the signature, the nonce, the order and the limits. If any round breaks a rule, the whole transaction fails and nothing changes. A successful batch uses up its nonce, so it can't be replayed. Public views wait for 12 Ethereum confirmations before they show the result.

--8<-- "f05-batch.md"

A batch settles in full or not at all. SqueekCore never trims, caps or repairs work.

Difficulty and Squeek blocks

A Squeek block isn't a fixed amount of running. SqueekCore keeps a running total of block units, and every billion block units completes one Squeek block. Squeek blocks are SqueekCore's own count; they have nothing to do with Ethereum's blocks.

Difficulty is the work that 1,000 Squeek blocks cost. Each round with work is first priced at the difficulty that earlier rounds set. Then, if it had at least 40 work, it moves difficulty one-thirtieth of the way toward the level at which its own work would have earned exactly 40 blocks. Rounds with less than 40 work earn progress but leave difficulty alone, and rounds with no work change nothing.

--8<-- "f06-block-maker.md"

Exact rule

blockUnits += floor(w × 10^12 / D)
D_next = floor((29 × D + floor(w × 1,000 / 40)) / 30) when w ≥ 40
D_next = D when w < 40
height = floor(blockUnits / 10^9)

w is a round's work and D is the difficulty, in work per 1,000 blocks. Difficulty never falls below 1,000, one work unit per block. These integer expressions are the definition: any other implementation must use them exactly.

--8<-- "f07-difficulty-sim.md"

Earned block units are never repriced. A change in difficulty only prices later work.

The Economy

The economy at a glance

The contracts run on the Sepolia testnet for testing; the proposed values deployed there are listed on the Developers overview.

The economy has one token, $SQK; 9,999 Squeeks; one Staking contract; and one pool where $SQK trades against ETH. As the hamster completes Squeek blocks, they issue $SQK on a three-year schedule that halves every year. All of it goes to Staking, which streams it to accounts in proportion to their power. Your power comes from the Squeeks you deposit there and the $SQK you stake, and each Squeek multiplies what your staked $SQK is worth. Trades in the pool pay a 1% fee, and $SQK taken out of Staking pays an exit fee that's burned.

--8<-- "f19-flows.md"

$SQK

Lifetime cap2.1B2.1 billion $SQK Premined for liquidity, 10%210M210 million $SQK Issued by SqueekMining, at most1.89B1.89 billion $SQK Years of issuance, halving every year33 years

$SQK, the Squeek token, has a lifetime cap of 2.1 billion. 10% of it, 210 million $SQK, is created up front when the token launches, and all of it goes into the pool as its starting liquidity. That's the only $SQK that doesn't come from the hamster's work.

SqueekMining creates the other 1.89 billion over three years, paced by completed Squeek blocks from the moment rewards start. Each year issues half as much as the year before: 4/7 of the base in the first year, 2/7 in the second and 1/7 in the third. On top of that, a proposed launch bonus of 105 million $SQK is spread over the first 97,020 blocks.

A year here is a proposed 393,470 blocks: 365 days at the 1,078 blocks a day the wheel has averaged so far. Difficulty steers every busy round, one with at least 40 work, toward 40 blocks, so a busier hamster finishes a year sooner and a quieter one later, while each block issues the same.

--8<-- "f08-supply.md"

Rewards start once, on a date announced in advance, TBD. Before then, the admin connects Staking to SqueekMining and Staking opens for deposits. Earning begins with the next full round after the start; blocks completed before that earn nothing.

Whenever a checkpoint issues $SQK, SqueekMining funds Staking with all of it immediately.

Inside Squeekchain, you can stake $SQK to earn power, or trade it in the pool. $SQK leaves circulation when it's burned: every exit fee is burned, and any holder can burn their own. Burned $SQK stays counted against the cap, so it never makes room for more.

When issuance ends after year three, no new $SQK is earned. Anything Staking already holds for accounts can still be claimed.

Only the premine and SqueekMining's schedule ever create $SQK, and never more than 2.1 billion in all.

Liquidity and fees

Premine in the pool210M210 million $SQK LP fee on every swap1%1% Sniper tax on buys at launch, falling to zero99%99%

$SQK launches in a single Uniswap v4 pool against ETH, seeded with the whole 210 million $SQK premine. Every trade pays the pool's 1% LP fee, which goes to its liquidity providers, at first the protocol.

To keep bots from grabbing $SQK at launch, buys start with a 99% sniper tax that falls to zero within minutes. After that, buys and sells pay only the 1% fee.

Squeeks

Squeeks9,9999,999 Squeeks Sale allocation, IDs 1 to 8,8888,8888,888 Squeeks For the protocol1,0001,000 Squeeks For the team111111 Squeeks

Squeeks are NFTs, and there are 9,999 of them. Squeeks 1 to 8,888 are the sale allocation, and 8,889 to 9,999 go to the protocol, which keeps 1,000 and gives 111 to the team. No more can ever be created.

A Squeek adds power while it's deposited in Staking, for the account that deposited it. Holding one in your wallet adds nothing.

Every Squeek starts at level 1 and rises by merging, up to level 10. Its level, and when it can next merge, are stored with the Squeek itself in SqueekNFT, a contract that can't be upgraded, so they follow it through sales, deposits and withdrawals. Staking sets how much power each level is worth, and each level is always worth more than two of the level below.

A deposited Squeek gives you power in two ways. It adds its level's Squeek power, and it multiplies the power of the $SQK you stake: every 1,000 of Squeek power adds 1 to the multiplier, so a single level 1 Squeek doubles it. Power at level L is 1,000 × 2.2L−1 (proposed), rounded, so each merge makes the survivor worth 10% more than the pair.

There will only ever be 9,999 Squeeks. A burned Squeek's ID is never minted again.

Earning and staking

All the $SQK the hamster's blocks issue goes to Staking, and Staking streams it to accounts in proportion to their power. Each new batch is streamed over the following 20 minutes, counting only time when someone is staked, and a new batch rolls whatever is left of the last one into a fresh 20 minutes. If your account has 1,000 power and everyone else together has 99,000, you receive 1% of what's streamed while those numbers hold.

--8<-- "f09-share.md"

Squeeks are the main source of power. Each deposited Squeek adds power set by its level, and multiplies what your staked $SQK is worth. $SQK staked without a Squeek earns at a base rate, and there's no limit on how much you can stake, so your power grows with both.

Power rule

c is the $SQK that earns one unit of power at the base rate: a proposed 40 $SQK. P_ref is the Squeek power that doubles an account's $SQK power: a proposed 1,000, one level 1 Squeek. 1,000 $SQK staked alone gives 25 power; with one level 1 Squeek deposited, it gives 50, and the account's power is 1,050.

Your deposited Squeeks, staked $SQK and everything they earn belong to your account. Any change, whether you deposit, withdraw, stake, unstake or merge in Staking, takes effect immediately, and what you'd earned up to that moment is kept.

You can withdraw a Squeek at any time and it comes back immediately. Your $SQK stays staked, and the Squeek's power, along with its boost to your $SQK, stops at that moment. You'll need to withdraw a Squeek before you can sell it, and what your account earned stays with your account.

Newly staked $SQK starts earning immediately, and can be unstaked from the next round, for an exit fee.

--8<-- "f10-staking.md"

Power counts from the moment it's added, and Staking only streams $SQK that SqueekMining already funded it with.

Exit fee

Unstaking $SQK costs an exit fee, and every fee is burned in full: none of it goes to the protocol or the team. Withdrawing Squeeks and claiming rewards are free.

The fee works like congestion pricing. It follows exit pressure, the share of the stake unstaked over the past week: ordinary exits cost 2%, and as more of the stake leaves at once, the fee climbs, slowly at first and then steeply, to 60% when a fifth leaves within a week. That makes a sudden rush expensive and keeps Staking steady for those who stay.

• Your exit counts too. The fee is worked out as each $SQK leaves, so a large exit raises its own fee, and splitting it into smaller exits doesn't make it cheaper.
• It eases day by day. The week counts whole days in UTC. Each day's exits stop counting at midnight a week later, so the fee steps down as older exits drop out.
• No queue, no surprises. Unstaking is always open, and your transaction never charges more than the fee you accept.

Checkpoints and claims

Settled blocks turn into $SQK when someone calls the checkpoint. Anyone can, and the Keeper service does so routinely. A checkpoint works through settled rounds in order, issues the $SQK their completed blocks earned, and funds Staking with all of it immediately.

Because Staking streams each batch over the 20 minutes after it arrives, a checkpoint that runs late, after an outage, pays whoever is staked at that point rather than whoever was staked while the blocks were earned.

--8<-- "f11-checkpoint.md"

Claiming sends the $SQK you've earned from Staking to your wallet, or you can claim it directly into your stake. You can also name one claim recipient; from then on only that address can claim for you, and claiming into stake is off. You can change or clear your claim recipient at any time. Earnings stay with your account, not with a Squeek, so selling a Squeek leaves them with you. Claiming, withdrawing, unstaking and changing your claim recipient all keep working through any pause.

--8<-- "f12-claims.md"

Claims only move $SQK that a checkpoint already issued. They never mint.

Merging Squeeks

Merging combines two Squeeks of the same level into one Squeek a level higher. You choose which one survives: it keeps its number and image and rises a level, and the other is permanently burned. Your $SQK and rewards stay where they are. Both Squeeks need to be below level 10 and past their cooldown, and the survivor then starts a new one. Merging opens when the admin switches it on, and the admin can switch it off again.

You can merge in two places. Squeeks in your wallet merge directly in SqueekNFT, as long as you own both yourself. The survivor keeps its new level, and its extra power counts once you deposit it. Squeeks you've already deposited merge through Staking, and your power goes up immediately, by 10% of the pair, which also lifts the multiplier on your staked $SQK.

A level 1 Squeek has no cooldown. After a merge, the survivor waits a set number of completed Squeek blocks before it can merge again, longer at each level: proposed from 3,000 at level 2 to 49,000 at level 9. These waits are fixed in SqueekNFT when it launches and can never change. They count completed Squeek blocks, the same clock as issuance, so they pass faster when the wheel is busy.

--8<-- "f13-merge.md"

A merge can't be undone: the donor is burned.

Flywheels

Three loops follow directly from the rules above: two that compound and one that balances. The schedule sets how much $SQK each block issues however much power exists, so the loops change how it's divided, never how much is issued. They describe what the rules do, not what prices will do.

Earn and stakeAn account can stake the $SQK it earns, in one step if it claims directly into stake. The stake raises its power, more power takes a larger share of what Staking streams, and that share can be staked again. Each deposited Squeek multiplies the stake's power and stake has no cap, so the loop keeps going. Accumulating power, by buying Squeeks, merging, staking and selling to someone who wants more, is the intended game, and the concentration it brings is intended too. MergeMerging is the only way a Squeek's level rises, and the only way a Squeek leaves circulation. Each merge burns the donor and makes the survivor worth 10% more than the pair, in Squeek power and in the $SQK multiplier, so as Squeeks grow there are fewer of them. Cooldowns count completed Squeek blocks, so the wheel sets how soon the next merge can happen. Exit feesEvery exit fee is burned. It's 2% when exits are quiet and rises to 60% in a bank run, so the more stake leaves together, the more each exit costs and the more $SQK leaves circulation.

Trust

Who can change what

Squeekchain is a new idea: proof of work powered by a hamster. With little precedent to learn from, its trust model balances two needs: rules that no one can change, and a careful, public way to fix problems if they appear.

Most of Squeekchain can't be changed by anyone. The $SQK token and the Squeeks are fixed for good: the 2.1 billion cap, the premine, the level table and the merge cooldowns will always be what they are today, and no one can move $SQK or Squeeks out of your wallet.

Three contracts can be improved over time:

• SqueekCore, which records the hamster's work
• SqueekMining, which issues $SQK
• Staking, which holds what you stake and streams rewards

Upgrades to them follow clear conditions:

• Only the admin can upgrade them, and only through a Timelock, a contract that publishes each change onchain and holds it for a set time before it can run.
• Every upgrade is visible before it applies, and withdrawing and unstaking stay open in the meantime.
• Trust is still involved: an upgrade can change how the upgraded contract works, including how Staking holds what's deposited in it.

The Guardian is a safety switch. If something looks wrong, it can pause specific actions, such as settlement or new deposits, but it can't move $SQK or Squeeks or change a rule, and claiming, withdrawing and unstaking keep working through every pause. The table lists every power each role has.

--8<-- "f14-authority.md"

Difficulty has no setter. Only settled work changes it.

What the system proves

Each step adds a specific, limited guarantee.

--8<-- "f15-evidence.md"

A work record says a passage was accepted under the device's rules. It doesn't identify the animal, show the wheel's direction or establish what made it move. A round with no work means no passage was accepted, which could also mean the device was off. The livestream shows the wheel, but cameras never create, confirm or correct work.

A signature proves which chip signed the bytes, not that the measurement is true.

When things fail

Squeekchain is built to stop rather than guess. Each part fails on its own, and the parts that hold records keep them.

--8<-- "f17-ladder.md"

--8<-- "f17-failures.md"

Recovery never edits work, skips a round or reuses a nonce.

Risks

Squeekchain records a hamster's work. Nothing in this paper promises a price, a return or liquidity.

• One source of work. All work comes from one hamster on one WHEELY9000. While the wheel is still, no blocks complete and no $SQK is issued. A year of issuance is a number of blocks set from a few days' measured pace, so a slower hamster stretches it.
• Concentration is intended. Power grows with an account's Squeeks and its stake, with no cap, and each Squeek multiplies the stake, so a few large accounts can receive most of the issuance.
• Staking decides who earns. A bug in Staking, or an upgrade to it, could miscount power and send $SQK to the wrong accounts. Staking's connection to SqueekMining can't be redone, so a fault would be fixed by upgrading Staking or SqueekMining.
• Late checkpoints pay later stakers. Staking streams each batch over the 20 minutes after it arrives. After an outage, the $SQK for every delayed block goes to whoever is staked when the checkpoint finally runs, rather than to whoever was staked while the blocks were earned.
• After year three. No new $SQK is issued, and stakers don't share the pool's fees, so staking stops earning new $SQK.
• Values not yet set. The starting difficulty and the date rewards start are TBD, values marked proposed can change before launch, and the designs in this paper can change before they ship.
• Markets. $SQK's price and the trading in its pool are set by the people who trade it, not by the protocol.
• Errors. The contracts and the device can contain errors that testing hasn't found.

Parameters

Every value this paper uses, in one place. The contracts, their events and a public API are open to anyone building on Squeektoshi's work; the developer documentation lists them.