Transparency

Scanner findings, answered

Automated scanners raise several findings on $RMHT. This page answers each one, minimising none, with the commands to verify everything yourself.

Contracts finalised 4 Sep 2026  ·  ownership renounced  ·  Robinhood Chain (4663)
The founder is not anonymous

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.

01Why this page exists

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.

The rule we hold ourselves to

No finding is dismissed as a "false positive" without an explanation. Where a risk is real, it is written here as such.

02The "Owner can..." findings are dead

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:

No terminal needed — four clicks
  1. Open the RMHT contract's "Read contract" tab.
  2. Scroll down to the owner row (n° 45 in the list).
  3. Click it, then click the yellow Read button.
  4. The answer shown is 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
Status

Moot since finalisation. Verifiable on-chain on all four contracts.

03The feedGovernor role

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 critical

This finding is valid. We do not dispute it.

What the role can do — the list is complete

Three functions carry onlyFeedGovernor, and only three. Search the term in the verified source and count them yourself:

FunctionEffect
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

What the role cannot do

No path lets the feedGovernor award itself tokens.

The real risk, stated without shrinking it

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.

Why there is no timelock

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.

Where it is held, and how it ends

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.

04The $MHT V2 precedent

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.

What we say about it

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.

And $MHT today

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

05"LP locked: 0%"

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.

Difference from a standard lock

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.

No terminal needed

Open the LiquidityCustodian's "Read contract" tab and read the rows below, clicking Read each time:

RowFunctionExpected answerWhat it proves
13tokenId1004464The id of the liquidity NFT held
10positionReceivedtrueThe position is indeed deposited here
3currentLiquidity206429215460407679890536Actual liquidity, unchanged since deposit
7owner0x0000...0000Nobody controls this contract any more
5feeRecipient0xC90e404A...721889aThe fee destination, now frozen
4depositor0x99699278...011bFBThe 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

06The market-cap gap

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.

Do not confuse the two

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.

No terminal needed

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

07Manipulating the price to trigger a milestone

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:

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.

08The remaining findings

Informational items, covered here so that none is left unanswered.

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

09What the launch cost

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.

StepETHApprox.
Deploying the 4 contracts, creating the pool, minting the position0.0037807$9.45
Transferring the NFT to the custodian + 9 configuration transactions0.0135255$33.81
Deploying the WarmUpBuyer0.0001585$0.40
Warm-up (gas + swap fees) and the feeRecipient change0.0001593$0.40
Finalisation: lockConfig() + 4 × renounceOwnership()0.0000510$0.13
TOTAL0.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.

Why is the "transfer + 9 transactions" line so expensive?

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.

The failed transaction you will see in the history

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.

10Verify it yourself

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 method, three clicks per contract
  1. Click the contract address in the table below: the Read contract tab opens directly.
  2. Each numbered row is a value anyone can read. Click the one you care about, then the yellow Read button.
  3. The answer appears just below, read live from the blockchain. Nobody can fake it.

The rows that answer the most common questions:

  • owner → 0x0000...0000: no owner left
  • configLocked → true: configuration frozen forever
  • feedGovernor → the only residual power, described in section 03
  • getMarketCap and nextMilestoneUSD → the protocol's real market cap and the next milestone
  • tokenId and positionReceived on the LiquidityCustodian → the liquidity position it holds

The Contract tab on the same screen shows the full source code. Search it for onlyOwner and onlyFeedGovernor and count the functions yourself.

For users comfortable with a command line

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

11Reading the contract, line by line

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.

One convention to know

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.

Governance

N°FonctionWhat it returns, and what it means
10configLockedtrue — pool and feeds frozen forever
45owner0x0000...0000 — no owner left
47pendingOwner0x0000...0000 — no pending ownership claim
16feedGovernorThe only residual power, limited to feed addresses (section 03)
46pendingFeedGovernor0x0000...0000 — no transfer of that role in progress

Supply breakdown

N°FonctionWhat it returns, and what it means
62TOTAL_SUPPLY1,000,000,000 RMHT, fixed at deployment, no minting possible
63totalSupplyCurrent supply: identical, minus any burned tokens
74VAULT_SUPPLY500,000,000 RMHT, i.e. 50% — the vault's initial endowment
75vaultBalanceWhat remains in the vault, decreasing with each milestone
19getEligibleSupplyThe basis of the protocol's market cap: total minus burned, minus vault, minus pool
18getCirculatingSupplyTotal minus burned, minus what the contract holds
8BURN_ADDRESS0x...dEaD, where burned tokens go
3airdropWalletThe custodian holding the airdrop's 16,998,896 RMHT
17founderWalletThe founder custodian, 50,000,000 RMHT locked for one year
28marketWalletThe address that received the share destined for liquidity

Price, oracle and milestones

N°FonctionWhat it returns, and what it means
21getMarketCapThe market cap that triggers milestones, in whole dollars
44nextMilestoneUSDThe next milestone to clear, in dollars
33MILESTONE_STEP_USD500,000 — the gap between two milestones
53RELEASE_BPS150, i.e. 1.5% of the remaining vault released per milestone
40milestonesReachedHow many milestones have been reached
41milestoneStatusThe full state of the milestone machine, in a single read
31MILESTONE_CONFIRMATIONS_REQUIRED3 confirmations required to validate a milestone
29MILESTONE_CONFIRM_INTERVAL10 minutes minimum between two confirmations
30MILESTONE_CONFIRM_WINDOW2 hours to gather the three confirmations
32MILESTONE_COOLDOWN24 hours between milestones, anti-manipulation
25isTwapReadytrue if the oracle has enough history to be read
69twapHistoryAvailableOracle history available, in seconds
68TWAP_WINDOW1,800 seconds — the price average is computed over 30 minutes
42MIN_OBSERVATION_CARDINALITY1,801 oracle slots required in the pool
22getRMHTPriceInETHThe average price of one RMHT in ETH over the TWAP window
20getETHPriceUSDThe ETH price read from Chainlink
14ethUsdFeedThe address of the Chainlink ETH/USD feed in use
13ETH_USD_HEARTBEAT26 hours — beyond that the data is deemed stale and refused
59sequencerUptimeFeed0x0000...0000: no sequencer feed exists on this chain
58SEQUENCER_GRACE_PERIOD1 hour after a sequencer restart, were such a feed to exist
71uniswapV3PoolThe reference pool, frozen by configLocked
51poolIsToken0false — RMHT is token1 of the pair

Rewards

N°FonctionWhat it returns, and what it means
48pendingRewardsRewards released but not yet claimed, in total
49pendingRewardsOfPending rewards for a given address — paste your own
70unclaimedReleasedTotal released by milestones and not yet claimed
24isExcludedFromRewardsfalse everywhere: no exclusion can ever be created
39milestoneRewardPerTokenThe per-token reward accumulator
7BPS_DENOM10,000 — the denominator for basis-point percentages
57REWARD_PRECISION1e36, the internal precision of the reward maths

The airdrop custodian

Read in its own "Read contract" tab.

N°FunctionWhat it returns
2activeAllocatedTotal still allocated and unclaimed
20totalAllocated16,998,896 RMHT — the sum of the 18 allocations
3allocationsAn address's allocation: paste yours to see the amount and whether it was claimed
10pendingRewardOfYour pending milestone rewards — paste your address
22UNLOCK_MILESTONE5 — the milestone that unlocks the airdrop early
23unlockTime1820019189, i.e. 4 September 2027 at 00:53 UTC
24unlockTimeSettrue — the date is set and can no longer change
7owner0x0000...0000

The founder custodian

Read in its own "Read contract" tab.

N°FunctionWhat it returns
9FOUNDER_ALLOCATION50,000,000 RMHT, the founder principal
2beneficiary0xC90e404A...721889a, immutable since deployment
21unlockedAmount0 before the unlock date, 50,000,000 after. No milestone accelerates this lock
4claimableNowWhat the beneficiary can withdraw right now
6claimedAmountHow much of the principal has already been withdrawn
5claimableRewardsNowMilestone rewards claimable, independent of the one-year lock
22unlockTime1820019189 — identical to the airdrop's
11owner0x0000...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.

12Who can still act on the contracts

The list is short on both sides, and it is countable in the code. Numbers are those of the "Write contract" tab.

What anyone can call

These functions are open to everyone, forever. None requires permission, and the protocol depends on no third-party service to operate.

N°ContractFunctionWhat it does
50RMHTpokeMilestone()Anyone can trigger a milestone check. This is what replaces reliance on a third-party service
9RMHTclaimRewards()Each holder claims their own rewards
4AirdropCustodianclaim()Each allocated address claims its allocation, once unlocked
5AirdropCustodianclaimReward()Each allocated address claims its milestone rewards
6 / 10Airdrop & FounderharvestVaultRewards()Anyone can trigger harvesting rewards into the custodian
3 / 8FounderCustodianclaim() / claimReward()Restricted to the beneficiary, whose address is immutable
2LiquidityCustodiancollect()Anyone can trigger LP fee collection. The destination is frozen and can no longer change
64, 5, 66RMHTtransfer() / approve() / transferFrom()Standard ERC-20 functions, with no tax and no blacklist

What nobody can call any more

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.

ContractN° and functions now unreachable
RMHT15 excludeFromRewards · 27 lockConfig · 55 renounceOwnership · 56 rescueTokens · 60 setConfig · 67 transferOwnership
AirdropCustodian12 renounceOwnership · 13 rescueEth · 17 setAllocations · 18 setRmhtToken · 19 setUnlockTime · 21 transferOwnership
FounderCustodian14 renounceOwnership · 15 rescueEth · 18 setRmhtToken · 20 transferOwnership
LiquidityCustodian11 renounceOwnership · 12 setFeeRecipient · 14 transferOwnership
The exceptions, already documented

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.

Allocation unlocking: two different regimes

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