+0readme
enchnt is one ERC-721 contract on Robinhood Chain that runs a forge. You get a +0 blade, free in the first hour or with any purchase of scrolls. A strike burns a scroll on the blade: it climbs one level, up to +15, or it breaks. Any blade from +1 up melts back into ETH at once, at a fixed price per level, paid by the forge that every purchase fills. This page is the contract in words, with every number it holds.
- blade +0..+15. scroll 0.001 ETH, blessed scroll 0.004 ETH.
- free blade in the first hour, one per wallet. after that one with every purchase.
- strike odds 95 % at +0 down to 10 % at +14.
- a plain scroll that fails leaves shards. a blessed one that fails drops one level.
- 4 shards make a scroll, 12 a blessed scroll.
- melt +1..+15 any time. +11 to +15 all pay 0.3674 ETH. never more than 70 % of the forge.
- every payment: 70 % forge, 25 % author, 5 % referrer.
- plain wallets only. no owner, no pause, no premint. ETH only.
+1the blade and the kinds
One collection holds four kinds of token, numbered together from one up.
| kind | code | how it appears | transfers |
|---|---|---|---|
| blade +0 | BLADE | claim() in the first hour; one with every purchase | no |
| blade +1..+15 | BLADE | a strike that succeeds | yes, unless under the hammer |
| scroll | SCROLL | bought for 0.001 ETH; 4 shards | yes |
| blessed scroll | BLESSED | bought for 0.004 ETH; 12 shards | yes |
| shards | SHARDS | a plain scroll fails; they keep the level | no |
- A blade is a line. Its line number and art seed stay with it for life. Every change of level burns the token and mints a new id with the same line to the owner: the picture stays the blade, and old marketplace orders on the old id die with it.
- What transfers: blades +1..+15 that are not under the hammer, scrolls and blessed scrolls,
through the ERC721-C validator. What does not: +0 blades and shards (
Soulbound), and a blade under the hammer (Locked). - The art is on chain.
tokenURI(id)returns a 48 x 48 pixel SVG drawn by the renderer contract: the same pixels as the blades on this page. The seed is the hash of the previous L2 block, the line and the owner at the blade's first mint. It picks the look, never the odds.
+2the free hour
claim()one +0 blade, free
whenblock.timestamp < openedAt + CLAIM_WINDOW
3,600 s: the first 60 minutes after the deploy block
whoonce per wallet, claimed(address)plain wallets only (+8)
- The hour starts with the deploy itself.
openedAtis the timestamp of the deploy block. This deploy opened 2026-10-06 10:24:50 UTC; its free hour closed 2026-10-06 11:24:50 UTC. Later:ClaimClosed. Twice:AlreadyClaimed. - After the hour, every paid buy drops a blade. Each purchase,
mint(uint256 qty)ormintBlessed(uint256 qty)of 1..20 scrolls, also mints one +0 blade, whatever the quantity. A paid strike buys a scroll, not a blade. - Prices never change. Send at least the price: the change comes back in the same call, less reverts
Underpaid. More than 20 at once:BadQty.
+3the strike
A strike burns one scroll on one of your blades below +15 and records the next L2 block as its target. The hash of that block decides, against the odds of the level:
uint256(keccak256(abi.encode(hash, line, strikeNo))) % 10000
hash: of the target L2 block
successroll < odds(level)odds in basis points
successblade +k becomes +k+1a new id
plain failsblade +k becomes shards that died at +ksoulbound
blessed failsblade +k drops to +k-1; +0 stays +0a new id
| from | bp | odds | success | plain fails | blessed fails | reach from +0, plain only |
|---|---|---|---|---|---|---|
| +0 | 9,500 | 95 % | +1 | shards +0 | +0 stays | 100 % |
| +1 | 9,000 | 90 % | +2 | shards +1 | +0 | 95.0 % |
| +2 | 8,500 | 85 % | +3 | shards +2 | +1 | 85.5 % |
| +3 | 8,000 | 80 % | +4 | shards +3 | +2 | 72.7 % |
| +4 | 7,000 | 70 % | +5 | shards +4 | +3 | 58.1 % |
| +5 | 6,000 | 60 % | +6 | shards +5 | +4 | 40.7 % |
| +6 | 5,000 | 50 % | +7 | shards +6 | +5 | 24.4 % |
| +7 | 4,500 | 45 % | +8 | shards +7 | +6 | 12.2 % |
| +8 | 4,000 | 40 % | +9 | shards +8 | +7 | 5.49 % |
| +9 | 3,500 | 35 % | +10 | shards +9 | +8 | 2.20 % |
| +10 | 3,000 | 30 % | +11 | shards +10 | +9 | 0.769 % |
| +11 | 2,500 | 25 % | +12 | shards +11 | +10 | 0.231 % |
| +12 | 2,000 | 20 % | +13 | shards +12 | +11 | 0.0577 % |
| +13 | 1,500 | 15 % | +14 | shards +13 | +12 | 0.0115 % |
| +14 | 1,000 | 10 % | +15 | shards +14 | +13 | 0.00173 % |
| +15 | the top: odds 0, a strike reverts MaxLevel | 0.000173 % | ||||
- Two ways to strike.
enhance(uint256 blade, uint256 scroll)burns a scroll or blessed scroll you hold.enhancePaid(uint256 blade, bool blessed, address ref)buys one and burns it in the same call: send 0.001 or 0.004 ETH. - Plain scrolls only, a fresh blade takes about 5 strikes before it shatters on average; 5.49 % reach +8 and 0.769 % reach +10.
- Every strike rolls fresh.
strikeNocounts the strikes of the line, so two strikes in the same block roll differently. The seed never enters the roll. - Struck in block n, the target is block n + 1. Odds of the top: 0.
+4one signature
Struck
n + 1its hash decides; nobody could know it when you signedthe target
n + 2the history serves that hash: the outcome is known and the game shows itabout 0.2 s after the strike
latersettled on chain by your next strike or melt of that blade, or by SETTLEevent Revealed
too latemore than 393,168 blocks after the target the hash is gone: the strike counts as a failabout 11 hours
- The outcome is fixed by the L2 block after the strike and read from the EIP-2935 block hash history
at
0x0000F90827F1C53a10cb7A02335B175320002935. Anyone can compute it from block n + 2 on:previewReveal(id)returns(ready, success, level)by the same code the settlement runs. - Shown at once, settled later. On chain the blade stays under the hammer until it is settled. Your next strike or melt on it settles the last strike first, in the same transaction, so a run of strikes is one signature each.
- SETTLE for selling.
reveal(uint256 blade)settles on its own. A blade under the hammer cannot move (Locked), so settle before you list or send it. - Anyone may settle anyone's blade, contracts included. It cannot change the outcome, and the new id always goes to the owner. If someone settles yours, your next strike or melt signed on the old id follows it to the new one.
- Unsettled outcomes past the window count as a fail. The history serves the last 393,168 L2 blocks, about 11 hours at about 10 blocks a second. Settled after that, a plain strike shatters and a blessed one drops a level, whatever the hash said. Waiting can only lose.
- When there is nothing left to strike. If the settlement on the way leaves shards or a +15,
the new strike does not happen:
enhancekeeps your scroll,enhancePaidsends the whole value back,meltpays 0.
Take the hash of the target block from any explorer or eth_getBlockByNumber, the line
from lineOf(id), strikeNo and the target from pendingOf(id) or the
Struck event. Computed in your browser, nothing is sent.
needs JavaScript
+5shards and trade-up
tradeUp(uint256[] shards)exactly 4 or 12 ids, else BadTrade
4 shardsone scroll0.001 ETH: 0.00025 a shard
12 shardsone blessed scroll0.004 ETH: about 0.000333 a shard
- Any shards of yours count the same, whatever level they died at. The art keeps the blade's own pieces and its level.
- Shards never move between wallets and never melt: their one use is the trade-up.
+6melt
melt(uint256 blade) burns a blade of yours from +1 up and pays you in the same
transaction:
min(meltValue(level), forge * MELT_CAP_PCT / 100)
MELT_CAP_PCT = 70
- The cap. The table stops at +11 (
MELT_TOP_LEVEL): +11 to +15 all pay the +11 value, 0.3674 ETH. The levels above it are for the art and the market, not for a bigger melt. - The forge cap. No melt pays more than 70 % of the forge at that moment. While the forge is
shallow it cuts first.
meltNow(id)quotes the exact payment, both caps included. - A floor.
melt(uint256 blade, uint256 minPaid)revertsMeltTooLowinstead of paying less thanminPaid, say when another melt drained the forge first. No melt burns a blade for 0. +0 does not melt (NothingToMelt). - Under the hammer, a blade is settled first. If that leaves nothing to melt (shards, or a blessed fail
to +0),
meltpays 0 and the settlement stays; with a floor it revertsNothingToMelt. - Best play: plain scrolls up to +5, blessed scrolls from +6. That mix reaches each level for the least expected spend: the spend column, shards traded back at their scroll value.
- Why no strategy returns more than 75 % of what it spends. Up to +11, each melt value is 75 % of the cheapest expected spend to reach its level, rounded down to the micro-ETH. That cheapest spend works as a price for a blade at each level, and no strike, plain or blessed, from any level, adds more to it on average than it costs. So whatever you do, expected melts stay below 75 % of expected spending; the best is 74.9998 % at +11. Referring yourself from a second wallet hands back the 5 %: 78.9 % at most. Above +11 the cap only lowers the return: reaching +12 costs 1.307 ETH on average, +15 costs 191.3, and both melt for 0.3674.
- A floor for the market. Anyone can buy a +8 below 0.046206 ETH and melt it, while the forge allows.
+7the forge and money
| one payment | ETH | forge | forge, no referrer | author | referrer |
|---|---|---|---|---|---|
| scroll | 0.001 | 0.0007 | 0.00075 | 0.00025 | 0.00005 |
| blessed scroll | 0.004 | 0.0028 | 0.003 | 0.001 | 0.0002 |
- Every payment splits as it lands, purchases and paid strikes alike: 25 % to the author, 5 % to the referrer, the rest to the forge.
- The referrer comes in the calldata:
mint(uint256 qty, address ref),mintBlessed(uint256 qty, address ref),enhancePaid. Paid in the same transaction with 30,000 gas; if it refuses, its share goes to the forge and the purchase goes through.Bought.refPaidshows what arrived. No referrer, or yourself as referrer: the forge takes 75 %. The author's share is the same either way. - The author's share waits in
authorOwed()untilpayTreasury()sends it totreasury(), fixed at deploy. Anyone may call it; the money can go nowhere else.Paid(address treasury, uint256 amount). - The forge pays melts and nothing else. No owner, no pause, no premint, no withdrawal, no upgrade. ETH
only: plain ETH sent to the contract is refused. On chain the balance is
forge() + authorOwed(), more only if someone forces ETH in. - Royalties 5 % to the treasury (
royaltyInfo, 500 bps) on trades of blades +1..+15, scrolls and blessed scrolls, enforced with ERC721-C: the Limit Break V5 transfer validator, fixed at deploy (setTransferValidatorrevertsValidatorFixed).
+8plain wallets only
msg.sender == tx.origin and no code at the addresselse NotPlainAddress
forclaim, mint, mintBlessed, enhance, enhancePaid, tradeUp, meltevery action that plays
openreveal, payTreasuryanyone, contracts too
- Contracts and EIP-7702 delegated wallets cannot play. An account with a delegation carries code,
0xef0100followed by the delegate's address, so it is refused like a contract. Remove the delegation and it is a plain wallet again. - How to tell: read
mintBlock(address who)on the explorer: 0 it can play, when it sends the transaction itself; 1 it has code (a contract or an EIP-7702 delegation); 2 it is on the deny list. The list is fixed at deploy and empty on this launch:deniedCount()is 0, soisDeniedis always false. - Holding is open to all. A smart wallet or a delegated account can hold the tokens that move, and the ERC721-C policy lets it move its own; but only a plain wallet can strike, melt or trade up. To melt a blade held by a smart wallet, send it to a plain one first.
+9fairness and limits
- Nobody can see the hash when the strike is signed. The target is the block after the one the strike lands in, and the strike is already in the chain when that block is made.
- The sequencer is centralized. Robinhood Chain has one sequencer. It orders the transactions and knows each block's hash before anyone else, so in principle it could steer outcomes. That is the trust every game on this chain gives the chain.
- Block-hash grinding is bounded, not gone. A player with their own node who lands alone in a target block could try many versions of that block to pick its hash. The melt table stops at +11 to bound what that can win: no melt pays more than 0.3674 ETH, and none more than 70 % of the forge.
- Gas cannot pick an outcome. A settlement gives the history call all its gas but 5,000, needs
40,000 left before it (else
LowGas), and inside the window a history that does not answer reverts the call (ChainRead) instead of guessing a fail. The referral needs 70,000 gas left, so a tight gas limit cannot quietly skip it. - No keys, no fixes. Nobody can change the odds, the prices, the table, the shares, the treasury or the validator, and nobody can patch a bug. The contract was audited twice and played through on the testnet (46630) before the mainnet.
- The house edge is the table. On average the forge pays back less than it takes: no strategy returns more than 75 % of what it spends. It is a game of chance; play with what you can lose.
+10the contract
0x2Dc2c2fdF17edE225353eC3445759eEf5af8C75cenchnt, ERC-721, source on Sourcify
renderer0x185D48990DEDf2E9501Ee5A28B78c226344466EFtokenURI and contractURI, source on Sourcify
0xe38f69287697eE7D1Bff7E6c41feefbEE17a8f9athe blade scene
0x08f5Fc300fA52c0A433Aefcb99789011Bd467EE1the shards scene
0x990034Be7e75BcF74aA391D813eeEB4A9043eD44the scroll pictures
validator0x721C008fdff27BF06E7E123956E2Fe03B63342e3ERC721-C transfer validator V5 (Limit Break)
history0x0000F90827F1C53a10cb7A02335B175320002935EIP-2935 block hash history
ArbSys0x0000000000000000000000000000000000000064the L2 block number (arbBlockNumber())
treasurytreasury()on the collection, fixed at deploy
openedL2 block 81557677, 2026-10-06 10:24:50 UTCopenedAt() = 1791282290
compilersolc 0.8.28, evm shanghai, via-ir, optimizer 200 runs, bytecode hash nonethe settings Sourcify matches against
claim()free +0 blade, first hour, once. Claimed(address to, uint256 blade)
mint(uint256 qty) mint(uint256 qty, address ref) payable1..20 scrolls and one +0 blade; returns (firstScroll, blade).
mintBlessed(uint256 qty) mintBlessed(uint256 qty, address ref) payablethe same with blessed scrolls. Every payment emits Bought(address buyer, address ref, bool blessed, uint256 qty, uint256 price, uint256 refPaid, uint256 firstId); a paid strike with qty 1 and firstId 0.
enhance(uint256 blade, uint256 scroll)strike with a scroll you hold; settles a pending blade first. Returns the id under the hammer, 0 if it shattered. Every strike emits Struck(uint256 blade, uint8 scrollKind, uint256 targetBlock, uint256 strikeNo).
enhancePaid(uint256 blade, bool blessed, address ref) payablestrike with a scroll bought in the call.
tradeUp(uint256[] shards)4 shards for a scroll, 12 for a blessed scroll. TradedUp(address owner, uint256 id, uint8 kind, uint256 shards)
melt(uint256 blade) melt(uint256 blade, uint256 minPaid)burn and get paid now. Melted(uint256 id, uint8 level, uint256 paid)
reveal(uint256 blade)settle a pending strike; the new id goes to the owner. Every settlement, here or on the way, emits Revealed(uint256 oldId, uint256 newId, bool success, uint8 level); a shattered blade also emits Shattered(uint256 oldId, uint256 shardsId, uint8 diedAt).
payTreasury()send authorOwed() to treasury().
odds(uint256 level) meltValue(uint256 level) meltNow(uint256 id)odds in basis points (0 at +15); the table in wei (0 at +0); what a melt pays now.
infoOf(uint256 id) pendingOf(uint256 id) previewReveal(uint256 id)one token: kind, level, line, strikes, pending, blessed, target, seed, melt; the pending strike; what a settlement would do now.
kindOf(uint256 id) levelOf(uint256 id) diedAtOf(uint256 id) lineOf(uint256 id) seedOf(uint256 id)0 for an id that is burned or never was.
forge() authorOwed() openedAt() claimed(address) totalSupply() treasury() art()the state; totalSupply counts the live tokens.
mintBlock(address who) isDenied(address who) deniedCount() deniedAt(uint256 i) denyListHash()the plain wallet rule (+8).
tokenURI(uint256 id) contractURI() royaltyInfo getTransferValidator() getTransferValidationFunction() supportsInterfacemetadata from the renderer, ERC-2981, ERC721-C, ERC-165 (also ERC-4906).
SCROLL_PRICE BLESSED_PRICE MAX_QTY CLAIM_WINDOW MAX_LEVEL MELT_TOP_LEVEL AUTHOR_PCT REF_PCT MELT_CAP_PCT ROYALTY_BPS TRADE_SCROLL TRADE_BLESSED REF_GAS HISTORY_WINDOW BLADE SCROLL BLESSED SHARDS MAX_PER_CHUNK VALIDATOR_OPTIONSthe constants, readable on chain (+11).
name() symbol() balanceOf ownerOf approve getApproved setApprovalForAll isApprovedForAll transferFrom safeTransferFrom setTransferValidatorERC-721; events Transfer, Approval, ApprovalForAll, MetadataUpdate (on every strike), BatchMetadataUpdate, TransferValidatorUpdated (once, at deploy).
| reverts with | when |
|---|---|
NotPlainAddress DeniedAddress | the sender is not a plain wallet (+8), or is denied |
ClaimClosed AlreadyClaimed | the free hour is over; this wallet claimed |
BadQty Underpaid | quantity 0 or above 20; less ETH than the price |
NotOwner WrongKind NoToken | not your token; not the kind the call takes; no such token |
MaxLevel NotPending TooEarly | +15 cannot be struck; nothing to settle; the target block has no hash yet |
BadTrade | not exactly 4 or 12 shards |
NothingToMelt MeltTooLow | +0, or nothing left after a settlement with a floor; the payment would be 0 or below minPaid |
Soulbound Locked | shards and +0 blades do not move; a blade under the hammer does not move |
ChainRead LowGas | the L2 block number or the hash history did not answer; too little gas left (+9) |
PayFailed Reentrancy | a payment to the sender or the treasury failed; a call came back in |
NotAllowed ZeroAddress BadReceiver | ERC-721: not approved; the zero address; a receiver that refuses |
ValidatorFixed BadArgument BadDenyList | the validator cannot change; deploy checks |
+11numbers
| constant | value | what |
|---|---|---|
SCROLL_PRICE | 1,000,000,000,000,000 = 0.001 ETH | a scroll, in wei |
BLESSED_PRICE | 4,000,000,000,000,000 = 0.004 ETH | a blessed scroll, in wei |
MAX_QTY | 20 | scrolls one purchase can take (one +0 blade per purchase) |
CLAIM_WINDOW | 3,600 | seconds from openedAt in which claim() is open |
MAX_LEVEL | 15 | the top level; odds 0 there |
MELT_TOP_LEVEL | 11 | the top of the melt table: above it a blade melts as +11 |
AUTHOR_PCT | 25 | percent of every payment to the treasury (through payTreasury) |
REF_PCT | 5 | percent of every payment to the referrer, else to the forge |
MELT_CAP_PCT | 70 | a melt pays at most this percent of the forge |
ROYALTY_BPS | 500 | royalty in basis points (ERC-2981) |
TRADE_SCROLL | 4 | shards for a scroll |
TRADE_BLESSED | 12 | shards for a blessed scroll |
HISTORY_WINDOW | 393,168 | L2 blocks the hash history serves back |
REF_GAS | 30,000 | gas the referral call may use |
HISTORY_GAS internal | 30,000 | gas for an art seed's history read; the least left before any |
ARBSYS_GAS internal | 20,000 | gas for the ArbSys read |
BLADE | 1 | kind code of a blade |
SCROLL | 2 | kind code of a scroll |
BLESSED | 3 | kind code of a blessed scroll |
SHARDS | 4 | kind code of shards |
ODDS_BP internal | 0x3e805dc07d009c40bb80dac0fa01194138817701b581f4021342328251c | odds of +0..+14 in basis points, 16 bits each |
MELT_LO internal | 0x61ab0000333500001c2f0000111700000af0000006840000030800000000 | melt table +0..+7 in micro-ETH, 32 bits each |
MELT_HI internal | 0x59b2800028ca600014e070000b47e | melt table +8..+11 in micro-ETH, 32 bits each |
ARBSYS internal | 0x0000000000000000000000000000000000000064 | Arbitrum ArbSys precompile: the L2 block number |
HISTORY internal | 0x0000F90827F1C53a10cb7A02335B175320002935 | EIP-2935 block hash history |
VALIDATOR_V5 deploy script | 0x721C008fdff27BF06E7E123956E2Fe03B63342e3 | the transfer validator the collection is deployed with |
MAX_PER_CHUNK | 1,228 | MintGuard: addresses one deny list data contract can hold |
VALIDATOR_OPTIONS | 6 = (1 << 1) | (1 << 2) | ERC721-C policy: holders with EIP-7702 or smart wallets may move their own tokens |
TOKEN_TYPE_ERC721 internal | 721 | token type registered at the validator |
| margin before the referral code | REF_GAS + 40,000 | or LowGas |
| margin before a history read code | HISTORY_GAS + 10,000 | or LowGas |
| gas a settlement keeps code | 5,000 | the history read gets the rest |
| the roll code | keccak256(…) % 10,000 | against ODDS_BP |