Mine stocks.
Onchain.

Point your hashrate at the stock you want.

Set a target reward asset from the eligible allowlist. Every valid proof pays out in that Stock Token, valued in USD by its Chainlink feed and drawn from the reward vault. Switch your target whenever you like — the proof-of-work is the same; only the payout asset changes.

These are Robinhood Stock Tokens on Robinhood Chain. Only assets registered by verified contract address, priced by a live feed, and held by the vault can be mined; availability and eligibility are jurisdiction-dependent.

A challenge-based Proof-of-Work system.

Each epoch has a unique challenge, a difficulty target, and a submission window. Miners vary a nonce until they find a hash below the target. The reward per valid proof is set by the protocol in USD terms; it's paid to you in the eligible Stock Token you selected, from the vault. Difficulty self-adjusts toward a target block time with clamped swings.

// each epoch derives a fresh challenge
challenge = H(previousChallenge || epoch || difficulty || domainSeparator)
// miner iterates the nonce space
hash  = H(challenge || minerAddress || nonce)
// valid when the hash falls under the target
valid = uint256(hash) < target ; target = MAX_TARGET / difficulty
// payout: usdReward / oraclePrice(chosenAsset), paid from the vault

Trust nothing. Verify everything.

A submitted proof is untrusted input. Before paying, the contract verifies the epoch, challenge, miner-address binding, nonce, target, and recomputed digest — confirms the proof is unique, the epoch is live, the chosen asset is eligible with a fresh non-zero price, and the vault holds enough of it. Any failure reverts.

mapping(bytes32 => bool) public usedProofs;
proofId = keccak256(abi.encode(epoch, miner, nonce, digest));
require(!usedProofs[proofId], "proof already used");
require(asset.enabled && vaultBalance[asset] >= payout, "asset unavailable");

Illustrative — exact implementation must be independently audited before deployment.

The reward vault holds real Stock Tokens, custodied by code.

Mining distributes assets the protocol already owns. The reward vault is funded by the 10% transaction tax, treasury allocations, and market purchases of eligible Stock Tokens. It's held by the contract — not a dev wallet — and assets leave it in one direction only: to miners who submit a valid proof. No person, including the deployer, can withdraw or redirect it.

   FUNDING            REWARD VAULT
  10% tax  --->   holds eligible Stock Tokens
  treasury --->   (AAPL, TSLA, SPY, ...)
  buys     --->          |
                  valid proof  --->  MINER
                         |          (chosen asset)
       vault balance for an asset only DECREMENTS
       via proof payout

   x  no admin withdraw / sweep / rescue
   x  no redirect of vault assets

// read-only — verify vault holdings at any block
function vaultBalance(address asset) external view returns (uint256);
function eligibleAssets() external view returns (address[] memory);
// no ownerWithdraw / sweep / rescue path exists on vault assets

A 10% tax keeps the vault stocked.

$HASH is the protocol's native token and the thing that trades. Its 10% transfer tax is the fuel: a slice continuously buys eligible Stock Tokens for the reward vault, so miners always have something to mine. Every allocation is a configurable parameter — not immutable unless the deployed contract makes it so.

TAX_BPS = 1000; // 10%
tax = amount * TAX_BPS / 10_000; net = amount - tax;

The flywheel

Tax funds the vault; miners mine it out; the activity feeds more tax. A separate slice buys back and burns $HASH. Both are mechanics, not a promise of price appreciation.

Buyback & vault purchases are protected by slippage/min-output limits, deadlines, reentrancy guards, a router allowlist, max swap size, and pause. DEX integration is planned architecture in this prototype.

Stake $HASH for a separate reward stream.

Staking is distinct from mining. Stake $HASH to earn from a defined source — protocol emissions, a treasury allocation, or a tax allocation — using a standard reward-per-token model. Mining earns through work; staking through locked capital. Staking does not create yield.

Example lock tiers — not deployed parameters unless confirmed onchain.

Built to read chain data, not fake it.

Every figure is read from RPC, contract reads, an event indexer, and oracle feeds — nothing here is fabricated. Fields show — until live data is available.

# example CLI · Linux / Windows / macOS / Docker
miner --rpc https://YOUR-RPC --wallet YOUR_ADDRESS --asset AAPL --threads 8

Contracts, config & interfaces.

Every HoodHash contract address lives in one config object and is independently verifiable onchain. Always confirm the address before you interact with a contract.

const CONFIG = {
  chain: { name: "Robinhood Chain", id: 4663, gasToken: "ETH", rpc: "[SET RPC]" },
  token: { symbol: "$HASH", maxSupply: "[SET]" },
  taxBps: 1000, upgradeModel: "[IMMUTABLE | UPGRADEABLE-VIA-TIMELOCK]",
  eligibleAssets: [ /* Stock Token addr + Chainlink feed per asset */ ],
  contracts: { token:"0x00..", mining:"0x00..", rewardVault:"0x00..",
    staking:"0x00..", taxRouter:"0x00..", buyback:"0x00..", treasury:"0x00.." }
};

function currentEpoch() external view returns(uint256);
function submitProof(uint256 epoch, uint256 nonce, bytes32 digest, address chosenAsset) external;
function setRewardAsset(address asset) external; // choose what you mine
event StockMined(address indexed miner, address indexed asset, uint256 amount, uint256 usdValue);
event VaultFunded(address indexed asset, uint256 amount);

Questions, answered precisely.