Automated scanners raise several findings on $RMHT. This page answers each one, minimising none, with the commands to verify everything yourself.
My identity has been verified by SolidProof, a third-party provider based in Germany, on the $MHT project record on BNB Chain. The same person deployed $RMHT, from address 0x99699278...011bFB.
What that commits me to is not a promise of mine: it is written into their terms.
"You expressly agree that SolidProof.io is entitled to pass on your personal data to government agencies, law enforcement authorities, regulatory authorities and injured third parties if fraud is suspected or damage has been proven."
In other words: were I to misappropriate anyone's funds, an independent third party can hand my identity to the authorities and to the injured parties. I cannot become anonymous again.
Two honest caveats. First, this is a right SolidProof reserves, not an automatic procedure. Second, those same terms provide for two years of data retention after verification: my verification interview took place on 29 April 2026, so retention runs to April 2028 — that is, beyond the unlock date of my founder allocation, set at 4 September 2027. In other words, on the day I can finally touch my tokens, my identity will still be held by that third party.
Finally, on the scope of that verification: $RMHT has not been audited by SolidProof. The contract was run through automated tooling and 322 tests, and the entire source is publicly verified on the explorer — which is what this page documents.
A scanner finding is neither proof of fraud nor a formality to wave away.
Automated analysers read source code and flag anything that could be dangerous. They are right to do so, and their findings on $RMHT are, for the most part, technically accurate.
What they cannot do is cross-check the code against the actual state of the chain, or recognise a mechanism that does not match the patterns they know. This page closes that gap: every finding, what it says exactly, what is true in it, and what you can verify yourself in one command.
No finding is dismissed as a "false positive" without an explanation. Where a risk is real, it is written here as such.
They describe an owner that no longer exists.
Flagged: "Owner can confiscate accrued vault rewards by excluding an account" · "Owner can..." (variants)This is accurate at source level. excludeFromRewards() (line 1382) and rescueTokens() (line 1426) do carry the onlyOwner modifier, and an active owner could use them.
But there is no owner any more. On 4 September 2026, in block 53917113, renounceOwnership() was called on all four contracts. owner() now returns 0x0000...0000 everywhere. Every onlyOwner function is therefore permanently unreachable: nobody can call it, us included.
Scanners analyse code statically, without querying the chain. They will keep listing these points as long as they read the source. Check it yourself, with nothing to install:
owner row (n° 45 in the list).0x0000000000000000000000000000000000000000: there is no owner any more.Do the same on the other three contracts — the owner row number differs from one contract to the next:
From the command line, for those who prefer it:
cast call 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 "owner()(address)" \ --rpc-url https://rpc.mainnet.chain.robinhood.com # -> 0x0000000000000000000000000000000000000000
Moot since finalisation. Verifiable on-chain on all four contracts.
The only power that survives renouncement. It is real, and we own that.
Flagged: "Privileged feedGovernor can replace the price oracle with an arbitrary contract" — rated criticalThis finding is valid. We do not dispute it.
Three functions carry onlyFeedGovernor, and only three. Search the term in the verified source and count them yourself:
| Function | Effect |
|---|---|
| updatePriceFeeds(address, address) | Replaces the two Chainlink feed addresses (ETH/USD and sequencer) |
| transferFeedGovernor(address) | Proposes a successor. Two-step: the recipient must call acceptFeedGovernor() |
| renounceFeedGovernor() | Extinguishes the role permanently |
lockConfig()rescueTokens() or excludeFromRewards() — those are onlyOwner, therefore deadNo path lets the feedGovernor award itself tokens.
updatePriceFeeds() checks that the candidate address is a contract, exposes decimals(), and returns a strictly positive ETH/USD price. Those checks rule out an invalid address, but not a malicious contract that answers the interface correctly while returning a false price.
Concretely: a hostile holder of this role could distort getMarketCap() and therefore bring forward or delay the vault's milestone releases — 500,000,000 RMHT, 50% of supply. They could not take those tokens; they go to holders through the reward mechanism. But they could manipulate the schedule. That is a real power.
A mandatory delay before a feed change would have reintroduced the very risk the role exists to cover: if an oracle breaks today, the protocol must be repairable today, not in forty-eight hours. The safeguards sit elsewhere: sanity checks on the candidate address, an event on every change, two-step transfer, and permanent extinction available.
The role is held by 0xC90e404A9f2ea55cbD2C81cf0054FAe4A721889a, a hardware wallet. renounceFeedGovernor() will remove it forever, bringing the contract to a state with no residual power at all. That call will be made once the feeds are considered durably stable, and it will be announced publicly.
The reason feedGovernor exists is not theoretical. It happened, to this project.
On $MHT V2, our token on BNB Chain, the milestone trigger relied on Chainlink Automation. Two problems compounded: a configuration mistake on our side — the address registered was the Chainlink Registry rather than the upkeep's Forwarder, while the actual caller of performUpkeep() is always the Forwarder — and, discovered in the same period, Chainlink discontinuing that Automation service.
The contract had already renounced ownership, and the corrective function was onlyOwner. There was no way left to repair it. The result: roughly 76% of $MHT V2's supply is frozen permanently. Not stolen — frozen, unreachable, forever.
The initial configuration mistake is ours, and on its own it was enough to break the mechanism: performUpkeep() could never have succeeded, even with a Chainlink service in perfect working order.
Chainlink's migration to CRE, and the discontinuation of the Automation service that came with it, would have stopped milestone triggering anyway — a second cause, independent of the first. But chronologically, it is that migration that made us reopen the file and discover our own mistake, which had gone unnoticed until then.
So we are not putting the blame on a third party: Chainlink evolved its product line, which is its right, and our contract would have been broken even without that.
So the risk feedGovernor covers is not "a malicious governor". It is: an oracle changes, disappears or is deprecated, and nobody can react. Robinhood Chain is a recent chain, and Chainlink has officially stopped extending its Sequencer Uptime Feeds to new networks. The odds that a feed address must change one day are not negligible.
Without this role, the day the ETH/USD feed breaks, the price calculation reverts fail-closed, no milestone can ever trigger again, and the vault's 500,000,000 RMHT are lost to everyone. We chose the risk that can be watched over the one that is irreversible.
$MHT V3 went live on 14 September 2026, written on the same guiding principle as $RMHT: no dependency on Chainlink Automation or any third party for triggering, price computed from an internal TWAP read directly from the pool, and milestones self-triggered by any caller. Ownership was renounced at launch and the configuration is locked, so no privileged address remains. Contract 0x4fb46E8630094F34D96B409EC1713793aD19b734 — the V2 to V3 migration is open until 4 November 2026 at the best rate, on the migration page.
The displayed figure is wrong, and the reality is stronger than what it measures.
Flagged: Percentage of LP locked: 0%Aggregators look for a known locker contract (PinkLock, Unicrypt, Team Finance...) holding LP tokens. They find none, and conclude the liquidity is not locked. This is the most widely read rug signal in the space, so let us be precise.
The $RMHT liquidity position is a Uniswap v3 NFT, tokenId 1004464, held by the RMHTLiquidityCustodian contract (0x50336e2a1396364895702a5222faC47bD0d38407).
That contract has no function capable of moving the NFT out or reducing the liquidity. This is not a promise: decreaseLiquidity(), burn(), any outgoing NFT transfer, any selfdestruct and any proxy mechanism are deliberately absent from the code, and the code is publicly verified. The only function that moves anything is collect(), which gathers swap fees and sends them to an address fixed in contract state — callable by anyone, but with a destination that can no longer be changed now that ownership is renounced.
A time lock expires on a date, after which liquidity can be withdrawn. Here there is no date: no code path exists, at any point in time, to withdraw this liquidity. It is permanent rather than dated.
Open the LiquidityCustodian's "Read contract" tab and read the rows below, clicking Read each time:
| Row | Function | Expected answer | What it proves |
|---|---|---|---|
| 13 | tokenId | 1004464 | The id of the liquidity NFT held |
| 10 | positionReceived | true | The position is indeed deposited here |
| 3 | currentLiquidity | 206429215460407679890536 | Actual liquidity, unchanged since deposit |
| 7 | owner | 0x0000...0000 | Nobody controls this contract any more |
| 5 | feeRecipient | 0xC90e404A...721889a | The fee destination, now frozen |
| 4 | depositor | 0x99699278...011bFB | The only address that could deposit the position |
Then scan the full function list: it is short, and you will find no withdrawal function. No decreaseLiquidity, no burn, no NFT transfer.
From the command line:
cast call 0x50336e2a1396364895702a5222faC47bD0d38407 "tokenId()(uint256)" \ --rpc-url https://rpc.mainnet.chain.robinhood.com cast call 0x50336e2a1396364895702a5222faC47bD0d38407 "owner()(address)" \ --rpc-url https://rpc.mainnet.chain.robinhood.com # -> 1004464 then 0x0000000000000000000000000000000000000000
The aggregators' number and the one that triggers milestones do not measure the same thing.
Aggregators display a market cap computed on the full one-billion supply of RMHT. The contract computes getMarketCap() on the eligible supply: total supply minus burned tokens, minus tokens held by the contract itself (the vault), minus those sitting in the pool.
The gap is large and structural: at launch, aggregators showed roughly $513,000 where the contract computed roughly $34,300.
You can check the aggregators' figure yourself on GeckoTerminal, which reads the pool live: the market cap and FDV shown there are computed on the full one-billion supply, not on the eligible supply the contract uses.
Milestones trigger every $500,000 of eligible supply, on the value computed by the contract — never on a figure displayed by a third-party site. Seeing an aggregator show $513,000 does not mean a milestone has been reached.
The counter on this site's home page reads getMarketCap() directly from the chain. It is the only value the protocol acts on, and you can read it yourself.
In the RMHT contract's "Read contract" tab, find getMarketCap, click it, then Read. The number returned is in whole dollars. Right next to it, nextMilestoneUSD gives you the next milestone to reach.
From the command line:
cast call 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 "getMarketCap()(uint256)" \ --rpc-url https://rpc.mainnet.chain.robinhood.com
A real risk on a young pool, and the three obstacles set against it.
Flagged: "Milestone market-cap price manipulation remains possible with low-liquidity pools"Correct. On a shallow pool, buying enough to move the price costs less than on a mature one. An actor seeking to trigger a milestone artificially could try to push the price up.
Four mechanisms make the operation expensive and unrewarding:
MILESTONE_COOLDOWN enforces a full day before a next milestone can be armed. Chaining several milestones off one manipulation is therefore impossible: each requires repeating the whole operation, a day later.We do not claim manipulation is impossible. It is made slow, visible and economically losing — and its benefit does not accrue to whoever attempts it.
Informational items, covered here so that none is left unanswered.
| Finding | Answer |
|---|---|
| External TWAP and oracle dependency can cause milestone denial of service | Correct, and deliberate. If the oracle does not answer or returns an aberrant value, the calculation reverts rather than returning a false number (fail-closed): no milestone triggers on doubtful data. That behaviour is exactly what makes the feedGovernor role necessary. |
| TWAP price calculation may overflow at extreme Uniswap ticks | The calculation is bounded by the tick range the liquidity position can actually reach, and the formula was verified numerically at those bounds. The "extreme" ticks referenced lie outside the range this pool can reach. |
| Pool configuration is insufficiently validated | Configuration was set once, then permanently locked by lockConfig(). Pool and feed addresses were cross-checked against each other at deployment, and the pool already had to hold enough oracle observations for the TWAP. No further change is possible. |
| Excluded balances remain in the reward denominator | An informational point about reward accounting. It only has an effect if addresses are excluded — and excludeFromRewards() is onlyOwner with ownership renounced: no exclusion can ever be created again. |
No presale, no fundraising. Here is the full bill, to the wei.
There was no presale, no raise, and no allocation sold to anyone. Every fee was paid from the deployer address, funded by a personal transfer. All of it is verifiable in that address's history.
| Step | ETH | Approx. |
|---|---|---|
| Deploying the 4 contracts, creating the pool, minting the position | 0.0037807 | $9.45 |
| Transferring the NFT to the custodian + 9 configuration transactions | 0.0135255 | $33.81 |
| Deploying the WarmUpBuyer | 0.0001585 | $0.40 |
| Warm-up (gas + swap fees) and the feeRecipient change | 0.0001593 | $0.40 |
Finalisation: lockConfig() + 4 × renounceOwnership() | 0.0000510 | $0.13 |
| TOTAL | 0.0176750 | $44.19 |
The liquidity capital is not an expense: it is 433,001,104 RMHT deposited as a single-sided position, with not one ETH facing it. The warm-up committed 0.002 ETH, of which 98.01% came back as WETH.
Most of that line is not an incident: it is the TWAP oracle pre-sizing, which requires reserving 1,801 storage slots in the pool. That single operation accounts for roughly 36 million units of gas — far more than the four deployments combined.
One transaction in our deployment failed, and we would rather explain it than let someone find it. The deployment tool freezes the parameters of all its transactions at simulation time. But the liquidity NFT id is a global Uniswap counter, shared with the whole chain: between our simulation and the mint landing in a block, 17 other positions were created by third parties. The script therefore asked to transfer an NFT we did not own, and the transaction was rejected.
The remaining steps were replayed one by one with the correct id. Cost of the incident: 0.0000116 ETH of burnt gas, about three cents. No funds lost, no address changed, no protocol parameter affected — the five addresses announced before launch are exactly the ones deployed.
Do not take our word for it. All of it is readable on-chain.
All four contracts are verified on robinhoodchain.blockscout.com: the source shown is the source running. No tooling is required — everything reads in the browser.
The rows that answer the most common questions:
owner → 0x0000...0000: no owner leftconfigLocked → true: configuration frozen foreverfeedGovernor → the only residual power, described in section 03getMarketCap and nextMilestoneUSD → the protocol's real market cap and the next milestonetokenId and positionReceived on the LiquidityCustodian → the liquidity position it holdsThe Contract tab on the same screen shows the full source code. Search it for onlyOwner and onlyFeedGovernor and count the functions yourself.
| Contract | Address — click to read its values |
|---|---|
| RMHT | 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 |
| AirdropCustodian | 0xdEc68344a41Cc6104ed5ff2C88F2D16a794688C1 |
| FounderCustodian | 0x4C944c27160A1532b9De3a69d0Ec64164a6f03d8 |
| LiquidityCustodian | 0x50336e2a1396364895702a5222faC47bD0d38407 |
| RMHT/WETH pool | 0xabe3B1fF5Fc6a9638D0c46f2379B20f7e6173bEe |
# No owner left on any of the four contracts
for C in 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 \
0xdEc68344a41Cc6104ed5ff2C88F2D16a794688C1 \
0x4C944c27160A1532b9De3a69d0Ec64164a6f03d8 \
0x50336e2a1396364895702a5222faC47bD0d38407; do
cast call $C "owner()(address)" --rpc-url https://rpc.mainnet.chain.robinhood.com
done
# Configuration locked forever
cast call 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 "configLocked()(bool)" \
--rpc-url https://rpc.mainnet.chain.robinhood.com
# The only residual power
cast call 0xbD4487dad62d23e0677E6a94c99cB0AE45328bA4 "feedGovernor()(address)" \
--rpc-url https://rpc.mainnet.chain.robinhood.com
# The liquidity position held by the custodian
cast call 0x50336e2a1396364895702a5222faC47bD0d38407 "positionReceived()(bool)" \
--rpc-url https://rpc.mainnet.chain.robinhood.com
For the full mechanics, see the protocol page.
What every readable value of the RMHT contract returns, in plain words.
All of these are read in the RMHT contract's "Read contract" tab: click the row, then Read. The numbers are the ones the explorer shows.
Token amounts display with 18 decimals and no separator. 500000000000000000000000000 therefore reads as 500,000,000 RMHT. Dollar amounts, by contrast, show as whole dollars.
| N° | Fonction | What it returns, and what it means |
|---|---|---|
| 10 | configLocked | true — pool and feeds frozen forever |
| 45 | owner | 0x0000...0000 — no owner left |
| 47 | pendingOwner | 0x0000...0000 — no pending ownership claim |
| 16 | feedGovernor | The only residual power, limited to feed addresses (section 03) |
| 46 | pendingFeedGovernor | 0x0000...0000 — no transfer of that role in progress |
| N° | Fonction | What it returns, and what it means |
|---|---|---|
| 62 | TOTAL_SUPPLY | 1,000,000,000 RMHT, fixed at deployment, no minting possible |
| 63 | totalSupply | Current supply: identical, minus any burned tokens |
| 74 | VAULT_SUPPLY | 500,000,000 RMHT, i.e. 50% — the vault's initial endowment |
| 75 | vaultBalance | What remains in the vault, decreasing with each milestone |
| 19 | getEligibleSupply | The basis of the protocol's market cap: total minus burned, minus vault, minus pool |
| 18 | getCirculatingSupply | Total minus burned, minus what the contract holds |
| 8 | BURN_ADDRESS | 0x...dEaD, where burned tokens go |
| 3 | airdropWallet | The custodian holding the airdrop's 16,998,896 RMHT |
| 17 | founderWallet | The founder custodian, 50,000,000 RMHT locked for one year |
| 28 | marketWallet | The address that received the share destined for liquidity |
| N° | Fonction | What it returns, and what it means |
|---|---|---|
| 21 | getMarketCap | The market cap that triggers milestones, in whole dollars |
| 44 | nextMilestoneUSD | The next milestone to clear, in dollars |
| 33 | MILESTONE_STEP_USD | 500,000 — the gap between two milestones |
| 53 | RELEASE_BPS | 150, i.e. 1.5% of the remaining vault released per milestone |
| 40 | milestonesReached | How many milestones have been reached |
| 41 | milestoneStatus | The full state of the milestone machine, in a single read |
| 31 | MILESTONE_CONFIRMATIONS_REQUIRED | 3 confirmations required to validate a milestone |
| 29 | MILESTONE_CONFIRM_INTERVAL | 10 minutes minimum between two confirmations |
| 30 | MILESTONE_CONFIRM_WINDOW | 2 hours to gather the three confirmations |
| 32 | MILESTONE_COOLDOWN | 24 hours between milestones, anti-manipulation |
| 25 | isTwapReady | true if the oracle has enough history to be read |
| 69 | twapHistoryAvailable | Oracle history available, in seconds |
| 68 | TWAP_WINDOW | 1,800 seconds — the price average is computed over 30 minutes |
| 42 | MIN_OBSERVATION_CARDINALITY | 1,801 oracle slots required in the pool |
| 22 | getRMHTPriceInETH | The average price of one RMHT in ETH over the TWAP window |
| 20 | getETHPriceUSD | The ETH price read from Chainlink |
| 14 | ethUsdFeed | The address of the Chainlink ETH/USD feed in use |
| 13 | ETH_USD_HEARTBEAT | 26 hours — beyond that the data is deemed stale and refused |
| 59 | sequencerUptimeFeed | 0x0000...0000: no sequencer feed exists on this chain |
| 58 | SEQUENCER_GRACE_PERIOD | 1 hour after a sequencer restart, were such a feed to exist |
| 71 | uniswapV3Pool | The reference pool, frozen by configLocked |
| 51 | poolIsToken0 | false — RMHT is token1 of the pair |
| N° | Fonction | What it returns, and what it means |
|---|---|---|
| 48 | pendingRewards | Rewards released but not yet claimed, in total |
| 49 | pendingRewardsOf | Pending rewards for a given address — paste your own |
| 70 | unclaimedReleased | Total released by milestones and not yet claimed |
| 24 | isExcludedFromRewards | false everywhere: no exclusion can ever be created |
| 39 | milestoneRewardPerToken | The per-token reward accumulator |
| 7 | BPS_DENOM | 10,000 — the denominator for basis-point percentages |
| 57 | REWARD_PRECISION | 1e36, the internal precision of the reward maths |
Read in its own "Read contract" tab.
| N° | Function | What it returns |
|---|---|---|
| 2 | activeAllocated | Total still allocated and unclaimed |
| 20 | totalAllocated | 16,998,896 RMHT — the sum of the 18 allocations |
| 3 | allocations | An address's allocation: paste yours to see the amount and whether it was claimed |
| 10 | pendingRewardOf | Your pending milestone rewards — paste your address |
| 22 | UNLOCK_MILESTONE | 5 — the milestone that unlocks the airdrop early |
| 23 | unlockTime | 1820019189, i.e. 4 September 2027 at 00:53 UTC |
| 24 | unlockTimeSet | true — the date is set and can no longer change |
| 7 | owner | 0x0000...0000 |
Read in its own "Read contract" tab.
| N° | Function | What it returns |
|---|---|---|
| 9 | FOUNDER_ALLOCATION | 50,000,000 RMHT, the founder principal |
| 2 | beneficiary | 0xC90e404A...721889a, immutable since deployment |
| 21 | unlockedAmount | 0 before the unlock date, 50,000,000 after. No milestone accelerates this lock |
| 4 | claimableNow | What the beneficiary can withdraw right now |
| 6 | claimedAmount | How much of the principal has already been withdrawn |
| 5 | claimableRewardsNow | Milestone rewards claimable, independent of the one-year lock |
| 22 | unlockTime | 1820019189 — identical to the airdrop's |
| 11 | owner | 0x0000...0000 |
The liquidity custodian is detailed in section 05.
The usual ERC-20 functions — name, symbol, decimals, balanceOf, allowance — are present and behave as on any token.
The list is short on both sides, and it is countable in the code. Numbers are those of the "Write contract" tab.
These functions are open to everyone, forever. None requires permission, and the protocol depends on no third-party service to operate.
| N° | Contract | Function | What it does |
|---|---|---|---|
| 50 | RMHT | pokeMilestone() | Anyone can trigger a milestone check. This is what replaces reliance on a third-party service |
| 9 | RMHT | claimRewards() | Each holder claims their own rewards |
| 4 | AirdropCustodian | claim() | Each allocated address claims its allocation, once unlocked |
| 5 | AirdropCustodian | claimReward() | Each allocated address claims its milestone rewards |
| 6 / 10 | Airdrop & Founder | harvestVaultRewards() | Anyone can trigger harvesting rewards into the custodian |
| 3 / 8 | FounderCustodian | claim() / claimReward() | Restricted to the beneficiary, whose address is immutable |
| 2 | LiquidityCustodian | collect() | Anyone can trigger LP fee collection. The destination is frozen and can no longer change |
| 64, 5, 66 | RMHT | transfer() / approve() / transferFrom() | Standard ERC-20 functions, with no tax and no blacklist |
These functions exist in the code, but all carry the onlyOwner lock — and owner() is 0x0000...0000 on all four contracts since finalisation. They are permanently unreachable, including by us.
| Contract | N° and functions now unreachable |
|---|---|
| RMHT | 15 excludeFromRewards · 27 lockConfig · 55 renounceOwnership · 56 rescueTokens · 60 setConfig · 67 transferOwnership |
| AirdropCustodian | 12 renounceOwnership · 13 rescueEth · 17 setAllocations · 18 setRmhtToken · 19 setUnlockTime · 21 transferOwnership |
| FounderCustodian | 14 renounceOwnership · 15 rescueEth · 18 setRmhtToken · 20 transferOwnership |
| LiquidityCustodian | 11 renounceOwnership · 12 setFeeRecipient · 14 transferOwnership |
Four functions do not depend on owner but on the feedGovernor role: 72 updatePriceFeeds, 65 transferFeedGovernor, 54 renounceFeedGovernor and 1 acceptFeedGovernor. They are the only privileged functions still alive across the whole protocol, detailed in section 03.
You will also see 6 onERC721Received on the LiquidityCustodian: it is the entry point through which the liquidity position was deposited. Only Uniswap's PositionManager can call it, and it can no longer do anything — positionReceived is already true, and the contract refuses a second position.
The airdrop unlocks at whichever comes first: either milestonesReached() hits 5 milestones, or the unlockTime date arrives — 4 September 2027 at 00:53 UTC, one year to the day after deployment. A project that performs therefore releases the airdrop sooner; a flat market cannot block it indefinitely.
The founder allocation has no early unlock. unlockedAmount() returns 0 before the date and 50,000,000 after, with no exception. No milestone accelerates it. Holders can therefore be served before the founder, never the other way round.
In both cases, milestone rewards are independent of that lock: they accrue and stay claimable at any time, through claimReward().