Minehand, explained end to end.

Minehand lets every holder mine with an agent. You deploy an agent, send it on a 12-hour shift, and every hour it holds your place it earns a share of the pool you picked: ETH, TOKEN, or a tokenized stock.

There is no hardware. Your agent runs on a machine, which is a setting you choose in the app. Bigger machines mine faster and need more held TOKEN to switch on.

1. Hold TOKEN. At least 100,000 for the smallest machine.
2. Connect your wallet from the header. The site never sends anything without your confirmation.
3. Create your agent in the dashboard: pick a character, a name, a machine and a reward. Sign once.
4. Start a shift from Overview or Machine. Sign once more. Your agent mines for 12 hours.
5. Claim from Portfolio once a payout root has passed its 30-minute window.

Each wallet owns exactly one agent. Saving it again updates it; the change applies from your next shift.

A shift starts the moment your signature is accepted and ends exactly 12 hours later. The machine and reward are frozen for that shift.

• A new shift can start only when none is running.
• Starting needs at least 100,000 TOKEN in the wallet at that moment.
• Seconds count: a shift that covers 20 minutes of an epoch earns for 20 minutes of it.
• An idle agent earns nothing. That is the point: abandoned agents stop drawing from the pool.

The machine your agent actually runs at in an epoch is the largest machine your lowest balance in that epoch covers, and never larger than the one you picked.

picked      H100  (needs 10,000,000)
lowest bal  2,300,000 during the hour
runs as     RTX 4090 · 10 H/s for that hour

Every epoch the network reads every TOKEN Transfer that touched your wallet and walks your balance back through the hour. The lowest point it finds sets your machine for that epoch.

• Buying just before the hour ends does not help: the balance at the start of the hour counts too.
• Selling and buying back inside the hour counts as the dip.
• Below the smallest machine, that epoch earns nothing, but the shift keeps running.

There is one pool per reward asset. Your agent mines only the pool you picked, and is paid in that asset. No swap is involved.

released(pool, epoch) = remaining(pool) × 0.1%
remaining(pool)        = balance − (allocated − claimed)

weight(agent)          = hashrate(machine) × seconds on shift in the epoch
share(agent)           = released × weight / Σ weight of agents on this pool

Every share is rounded down, so a pool never releases more than its 0.1%. A pool with nobody mining it releases nothing that hour.

ETH pool holds 10 ETH            → releases 0.01 ETH this hour
agent A: H100 (120 H/s) × 3600 s  → weight 432,000
agent B: A100 ( 55 H/s) × 1800 s  → weight  99,000
A earns 0.01 × 432,000 / 531,000 = 0.008135 ETH
B earns 0.01 ×  99,000 / 531,000 = 0.001864 ETH

Because the release is a share of what is left, a pool never runs dry on its own; refills make the next hours pay more.

An hourly job measures each finished epoch, adds the results to every wallet's running total, and publishes a Merkle root of those totals to MiningPool.

If the job is down, up to 24 missed epochs are processed on its next run, oldest first.

Portfolio shows, per asset, what you earned, what you already claimed and what is claimable now. Claiming sends one transaction that proves your total and pays the difference since your last claim.

• Claimable trails earned by up to one settlement plus its 30-minute window.
• Only your own wallet can claim for itself.
• A stock issuer can block a wallet or pause its market. That claim reverts, nothing moves, and the reward stays claimable.

The owner can list reward assets, rotate the publisher and guardian, and propose a withdraw. A withdraw is an on-chain event that cannot execute for 48 hours and can never touch what is owed to miners.

function fund(address asset, uint256 amount) payable
function claim(address asset, uint256 cumulative, bytes32[] proof)
function publish(bytes32 root, address[] assets, uint256[] newCommitted)   // publisher
function veto()                                                            // guardian
function promote()                                                         // anyone
function proposeWithdraw(address asset, uint256 amount, address to)        // owner
function executeWithdraw(uint256 id) / cancelWithdraw(uint256 id)          // owner
function setAsset(address asset, bool allowed) / setRoles(owner, publisher, guardian)

view root() · pendingRoot() · committed(asset) · claimed(asset)
     claimedBy(account, asset) · unallocated(asset) · allowed(asset)

event Funded(from, asset, amount)       event Claimed(account, asset, amount)
event Published(root, assets, totals)  event Promoted(root)   event Vetoed(root)
event WithdrawProposed(id, asset, amount, to, readyAt)  WithdrawCancelled  WithdrawExecuted

error OverCap(asset)  BadProof  NothingToClaim  OverCommitted  PendingExists
      NotAllowed  BadInput  NothingToVeto  NotReady  OverUnallocated  Unauthorized

ETH is address(0). Asset arrays in publish must be strictly ascending.

{
  "cumulative": "8135000000000000",
  "claimable":  "8135000000000000",
  "proof": ["0x5f2a…", "0x91c0…"]
}

Amounts are decimal strings in the asset's smallest unit (18 decimals for every listed asset). Addresses are lowercase.

Both actions are plain personal-sign messages. Every field is inside the text, so none can be swapped after signing.

minehand agent
address: 0xyouraddress
name: nightshift
tier: h100
asset: 0x0000000000000000000000000000000000000000
avatar: sentinel
ts: 1791395618

minehand session
address: 0xyouraddress
ts: 1791395619

Agent

Your miner; one per wallet.

Shift

A 12-hour mining session.

Machine

The hashrate tier your agent runs at.

Epoch

A 60-minute window; rewards are measured per epoch.

Weight

Hashrate × seconds on shift within an epoch.

Root

Merkle root of every wallet's cumulative rewards.

Committed

What the active root says miners are owed, per asset.

Unallocated

Pool balance not owed to anyone.

Publisher

The key that posts roots.

Guardian

The key that can veto a root during its window.