Docs

One mechanic, written plainly. Every number on this site is read from the chain; every claim below says who stands behind it.

Contract = enforced by code anyone can read. Team = a promise by people, which the contract cannot enforce.

Overview

You fold your coins into the TsurukamiFold contract. Each UTC day a folded position adds one crease; after 30 creases the paper crane is complete. ETH sent to the contract is split among all folded coins in proportion to amount × level. A new fold starts at 1×; a finished crane counts 3×. Only coins inside the contract count, not coins sitting in a wallet.

The token has no other function here and no price is promised. The contract is the whole product: no owner, no pause, no upgrade. The one admin-looking function, setToken, can be called once, by the deployer, and only for a token that exists in the Pons factory.

Fold

Contract fold(amount) pulls amount coins into the contract and opens a new position (a crane) with its own id and its own age. Minimum 1 coin. Folding again later never changes an older crane; it makes a new one. Approve the contract first (the site does both steps). The amount is measured by the balance change, so what counts is what actually arrived.

Levels: one crease a day

Contract Weight per coin is 30 + 2 × min(age in days, 30), so level = weight / 30 runs from 1.00× on the day you fold to 3.00× on day 30. Days are UTC days counted from the contract's START (00:00 UTC of its deploy day). The last crease lands on day 30; after that the level stays at 3×.

Claim

Contract claim(ids) pays out everything your cranes have earned so far, in ETH, in one transaction (the site claims up to 50 cranes at a time). Claiming does not unfold anything and does not reset the level. Claim whenever you like.

Contract Use a wallet that can receive ETH (normal wallets, Safe and smart accounts are fine). A contract with no receive() cannot claim or unfold once it has pending ETH.

Unfold

Contract unfold(id) pays what is owed, returns all the coins of that crane and deletes the position. There is no partial unfold. If you fold again you start from 1×: that is the product, and it is why the site asks you to confirm.

Where the ETH comes from

Contract 100% of the ETH that arrives at the contract (through deposit() or a plain transfer) is divided among the folded coins by weight at that moment. There is no cut, no team share and no admin withdrawal in the contract.

Team The token launches on Pons with a 2% tax that goes to the creator wallet. The team forwards part of it to the contract by hand: funded by hand from creator fees, not automatic, no amount promised. Each forwarded transfer is a public transaction; the table on /proof lists every one from the creator wallet.

Contract Anyone can top up the cranes by sending ETH to the contract. Such transfers are shown separately as top-ups.

What this means in practice: the size of any payout depends on how much ETH is sent and how many coins are folded. Neither is guaranteed. Holding the token in a wallet pays nothing.

The first fold

Contract If ETH arrives while no coins are folded, it is held as waiting and handed to the first crane when it is folded. So the first crane also receives whatever arrived before it. Anyone may try to be first; the team intends to fold first at launch (Team).

The math, briefly

The contract keeps a running total weight W (sum of amount × weight for every crane). When v wei arrives, it adds v × 1e36 / W to a global accumulator acc, and the same amount times the current day to a second one. Every UTC day, W grows by 2 × (coins still creasing) in one step, with no loop over holders. A crane's claimable ETH is read from the two accumulators and its own snapshot, with one split at its day-30 checkpoint, so it equals what you would get by summing each deposit separately with the weight you had that day. Rounding is floor; at most about one wei per claim stays in the contract. The test suite compares the contract with a plain per-deposit model; there is no third-party audit.

Long gaps

Contract Every action first catches the contract up to today, at most 400 UTC days per call. If nobody touched it for longer, anyone can call sync() repeatedly, or syncDays(n) to advance exactly n days in one call, until it is current. Example: cast send <FOLD> "syncDays(uint32)" 100 --rpc-url ….

Addresses

Chain

Robinhood Chain (4663)

Fold contract

published at deploy

Deployer (calls setToken once)

published at deploy

Creator wallet (receives the Pons 2%)

published at launch

Pons factory (existence check only)

0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e

Multicall3

0xcA11bde05977b3631167028862bE2a173976CA11

RPC used by this site

https://tsurukami.live/rpc (a plain relay to https://rpc.mainnet.chain.robinhood.com; any public Robinhood Chain RPC returns the same values)

Source is verified (exact match) on Sourcify and Blockscout; every event is on /proof. No owner, no pause, no proxy. The token address is written once and cannot be changed.

Try it from a terminal

No wallet needed. Read the live total weight and a crane's claimable ETH:

cast call <FOLD> "totalWeight()(uint256)" --rpc-url https://robinhood-rpc.publicnode.com

cast call <FOLD> "pending(uint256)(uint256)" <id> --rpc-url https://robinhood-rpc.publicnode.com

curl -s https://robinhood-rpc.publicnode.com -H 'content-type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<FOLD>","data":"0x96c82e57"},"latest"]}'

Send ETH to the cranes (anyone): cast send <FOLD> "deposit()" --value 0.001ether --rpc-url … --private-key …

The token

The contract address of the coin is published at launch on 3 November (UTC), on this site and on @tsurukamiRH only. Until then the contract has no token set and folding is locked. The coin that gets folded is that same coin; there is nothing else to buy. Current value: 0x0000000000000000000000000000000000000000

Risks

• The ETH that reaches the contract depends on the team forwarding creator fees by hand. The contract cannot make anyone do that. Compare the creator wallet with the forwarded table on /proof.
• Your share is a function of volume, of what the team decides to forward, and of how many others fold. It is a game of levels, not a return, and it may be small.
• The first crane receives all ETH that was waiting. People may race for it at launch.
• Folded coins cannot be sold without unfolding, and unfolding erases the level.
• The contract was tested (unit, fuzz, invariant, fork) and reviewed internally. It has had no third-party audit. Smart contracts can have bugs.
• Token prices can fall to zero. Nothing here is financial advice.