enchnt tech doc · live on Robinhood Chain 4663

the rules of the forge

Free blade. Paid scrolls. Every strike can make it legend or dust. Melt it any time: the forge pays the board.

live on Robinhood Chain 4663. The collection is 0x2Dc2c2fdF17edE225353eC3445759eEf5af8C75c, source on Sourcify. No owner: nothing on this page can change.
  1. +0 · 95 % to +1 · no melt at +0
  2. +4 · 70 % to +5 · melts for 0.004375 ETH
  3. +7 · 45 % to +8 · melts for 0.025003 ETH
  4. +10 · 30 % to +11 · melts for 0.167078 ETH
  5. +13 · 15 % to +14 · melts for 0.3674 ETH
  6. +15 · the top · melts for 0.3674 ETH

+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.

tl;dr
  • 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.

kindcodehow it appearstransfers
blade +0BLADEclaim() in the first hour; one with every purchaseno
blade +1..+15BLADEa strike that succeedsyes, unless under the hammer
scrollSCROLLbought for 0.001 ETH; 4 shardsyes
blessed scrollBLESSEDbought for 0.004 ETH; 12 shardsyes
shardsSHARDSa plain scroll fails; they keep the levelno
  • 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

callclaim()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. openedAt is 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) or mintBlessed(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:

rolluint256(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
frombpoddssuccessplain failsblessed failsreach from +0, plain only
+09,50095 %+1shards +0+0 stays100 %
+19,00090 %+2shards +1+095.0 %
+28,50085 %+3shards +2+185.5 %
+38,00080 %+4shards +3+272.7 %
+47,00070 %+5shards +4+358.1 %
+56,00060 %+6shards +5+440.7 %
+65,00050 %+7shards +6+524.4 %
+74,50045 %+8shards +7+612.2 %
+84,00040 %+9shards +8+75.49 %
+93,50035 %+10shards +9+82.20 %
+103,00030 %+11shards +10+90.769 %
+112,50025 %+12shards +11+100.231 %
+122,00020 %+13shards +12+110.0577 %
+131,50015 %+14shards +13+120.0115 %
+141,00010 %+15shards +14+130.00173 %
+15the top: odds 0, a strike reverts MaxLevel0.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. strikeNo counts 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

block nyour strike lands: one signature, one transactionevent 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: enhance keeps your scroll, enhancePaid sends the whole value back, melt pays 0.
check a roll

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

calltradeUp(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:

paidmin(meltValue(level), forge * MELT_CAP_PCT / 100) MELT_CAP_PCT = 70
levelmelt, ETHspend to reachmelt / spend
+150.3674191.30.192 %
+140.367423.261.57 %
+130.36744.5967.99 %
+120.36741.30728.10 %
max melt · 0.3674 ETH from +11 up
+110.36740.489974.99 %
+100.1670780.222874.99 %
+90.0855110.114074.99 %
+80.0462060.0616174.99 %
+70.0250030.0333474.99 %
+60.0131090.0174874.99 %
+50.0072150.00962174.99 %
+40.0043750.00583574.98 %
+30.00280.00373474.98 %
+20.0016680.00222474.99 %
+10.0007760.00103574.96 %
  • 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) reverts MeltTooLow instead of paying less than minPaid, 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), melt pays 0 and the settlement stays; with a floor it reverts NothingToMelt.
  • 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

70 % forge25 % author5 % referrer or forge
one paymentETHforgeforge, no referrerauthorreferrer
scroll0.0010.00070.000750.000250.00005
blessed scroll0.0040.00280.0030.0010.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.refPaid shows 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() until payTreasury() sends it to treasury(), 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 (setTransferValidator reverts ValidatorFixed).

+8plain wallets only

rulemsg.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, 0xef0100 followed 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, so isDenied is 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

chainRobinhood Chain (4663)explorer robin.etherscan.io collection0x2Dc2c2fdF17edE225353eC3445759eEf5af8C75cenchnt, 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
players call
claim()

free +0 blade, first hour, once. Claimed(address to, uint256 blade)

mint(uint256 qty) mint(uint256 qty, address ref) payable

1..20 scrolls and one +0 blade; returns (firstScroll, blade).

mintBlessed(uint256 qty) mintBlessed(uint256 qty, address ref) payable

the 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) payable

strike 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)

anyone calls
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().

views
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() supportsInterface

metadata 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_OPTIONS

the constants, readable on chain (+11).

the standard kit
name() symbol() balanceOf ownerOf approve getApproved setApprovalForAll isApprovedForAll transferFrom safeTransferFrom setTransferValidator

ERC-721; events Transfer, Approval, ApprovalForAll, MetadataUpdate (on every strike), BatchMetadataUpdate, TransferValidatorUpdated (once, at deploy).

reverts withwhen
NotPlainAddress DeniedAddressthe sender is not a plain wallet (+8), or is denied
ClaimClosed AlreadyClaimedthe free hour is over; this wallet claimed
BadQty Underpaidquantity 0 or above 20; less ETH than the price
NotOwner WrongKind NoTokennot 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
BadTradenot 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 Lockedshards and +0 blades do not move; a blade under the hammer does not move
ChainRead LowGasthe L2 block number or the hash history did not answer; too little gas left (+9)
PayFailed Reentrancya payment to the sender or the treasury failed; a call came back in
NotAllowed ZeroAddress BadReceiverERC-721: not approved; the zero address; a receiver that refuses
ValidatorFixed BadArgument BadDenyListthe validator cannot change; deploy checks

+11numbers

odds, +0..+14+0 95 %, +1 90 %, +2 85 %, +3 80 %, +4 70 %, +5 60 %, +6 50 %, +7 45 %, +8 40 %, +9 35 %, +10 30 %, +11 25 %, +12 20 %, +13 15 %, +14 10 % melt, ETH+1 0.000776, +2 0.001668, +3 0.0028, +4 0.004375, +5 0.007215, +6 0.013109, +7 0.025003, +8 0.046206, +9 0.085511, +10 0.167078, +11 0.3674; +12..+15 as +11
constantvaluewhat
SCROLL_PRICE1,000,000,000,000,000 = 0.001 ETHa scroll, in wei
BLESSED_PRICE4,000,000,000,000,000 = 0.004 ETHa blessed scroll, in wei
MAX_QTY20scrolls one purchase can take (one +0 blade per purchase)
CLAIM_WINDOW3,600seconds from openedAt in which claim() is open
MAX_LEVEL15the top level; odds 0 there
MELT_TOP_LEVEL11the top of the melt table: above it a blade melts as +11
AUTHOR_PCT25percent of every payment to the treasury (through payTreasury)
REF_PCT5percent of every payment to the referrer, else to the forge
MELT_CAP_PCT70a melt pays at most this percent of the forge
ROYALTY_BPS500royalty in basis points (ERC-2981)
TRADE_SCROLL4shards for a scroll
TRADE_BLESSED12shards for a blessed scroll
HISTORY_WINDOW393,168L2 blocks the hash history serves back
REF_GAS30,000gas the referral call may use
HISTORY_GAS internal30,000gas for an art seed's history read; the least left before any
ARBSYS_GAS internal20,000gas for the ArbSys read
BLADE1kind code of a blade
SCROLL2kind code of a scroll
BLESSED3kind code of a blessed scroll
SHARDS4kind code of shards
ODDS_BP internal0x3e805dc07d009c40bb80dac0fa01194138817701b581f4021342328251codds of +0..+14 in basis points, 16 bits each
MELT_LO internal0x61ab0000333500001c2f0000111700000af0000006840000030800000000melt table +0..+7 in micro-ETH, 32 bits each
MELT_HI internal0x59b2800028ca600014e070000b47emelt table +8..+11 in micro-ETH, 32 bits each
ARBSYS internal0x0000000000000000000000000000000000000064Arbitrum ArbSys precompile: the L2 block number
HISTORY internal0x0000F90827F1C53a10cb7A02335B175320002935EIP-2935 block hash history
VALIDATOR_V5 deploy script0x721C008fdff27BF06E7E123956E2Fe03B63342e3the transfer validator the collection is deployed with
MAX_PER_CHUNK1,228MintGuard: addresses one deny list data contract can hold
VALIDATOR_OPTIONS6 = (1 << 1) | (1 << 2)ERC721-C policy: holders with EIP-7702 or smart wallets may move their own tokens
TOKEN_TYPE_ERC721 internal721token type registered at the validator
margin before the referral codeREF_GAS + 40,000or LowGas
margin before a history read codeHISTORY_GAS + 10,000or LowGas
gas a settlement keeps code5,000the history read gets the rest
the roll codekeccak256(…) % 10,000against ODDS_BP