Inside Ultravein, from rig to payout.

Ultravein lets every holder put a VGA on the vein. Unlock one with the UVN you hold, or buy one from the shop for good, then switch it on from a terminal. Every hour it stays on it draws a share of the pool you chose: ETH, UVN, or a tokenized stock.

No hardware involved: every VGA is virtual. Bigger VGAs mine faster; a held one needs more UVN to power on, a bought one needs none.

1. Hold UVN. At least 100,000 for the smallest machine.
2. Connect your wallet in the dashboard. The site never sends anything without your confirmation.
3. Deploy a VGA in the dashboard: pick a VGA (or buy one), a name and a reward. Sign once.
4. Run the terminal: node rig.mjs init, paste the code on Deploy VGA, then node rig.mjs start. It mines while it runs.
5. Withdraw from Portfolio once a payout root has passed its 30-minute window.

Each wallet runs one rig with one VGA. Every VGA is virtual: there is no hardware to plug in. There are two ways to get one.

• Upgrading a bought VGA costs only the difference over what this wallet already paid.
• The whole price lands in the UVN reward pool and is paid back out to miners like any refill.
• Your rig runs the best VGA you can power, owned or held, and never one above the VGA you picked.

Your VGA is switched on from a terminal, like a mining rig. The terminal holds a small node key (Ed25519) that signs a heartbeat. That key holds no funds and can withdraw nothing; withdrawals always go through your wallet.

curl -fsSLo rig.mjs https://<this site>/rig.mjs   # or download it from the Deploy page
node rig.mjs init https://<this site>             # prints a code: UV-XXXX-XXXX-XXXX
                                                  # paste it on Deploy VGA, sign with your wallet
node rig.mjs start                                # mines while this stays open

• Needs Node.js 18 or newer and nothing else. The key is saved in ~/.ultravein/rig.json.
• A code lasts 30 minutes and works once. Running init again keeps the same key and prints a fresh code.
• The terminal sends a heartbeat every 5 minutes. Each one keeps the rig mining for 10 minutes, so closing the terminal stops it within 10 minutes.
• Linking a new node retires the old one. One wallet runs one rig: extra terminals add nothing.
• Seconds count: a rig online for 20 minutes of an epoch earns for 20 minutes of it.

The VGA your rig actually runs in an epoch is the largest one you bought or 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 UVN 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 VGA 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(rig)            = hashrate(VGA) × seconds on session in the epoch
share(rig)             = released × weight / Σ weight of rigs 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
rig A: H100   (120 H/s) × 3600 s  → weight 432,000
rig 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 withdrew and what is ready now. Withdrawing sends one transaction (the contract's claim function) that proves your total and pays the difference since your last withdrawal.

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

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 buyCard(uint8 tier)                                               // VGA shop, pays the difference
function setShop(address token, uint256[] prices)                          // owner, prices[i] = tier i+1
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)
     cardToken() · cardPrice(tier) · cardOf(account) · cardSpent(account)

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
event ShopSet(token, prices)           event CardBought(buyer, tier, paid)

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.

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

ultravein rig
address: 0xyouraddress
name: nightshift
tier: h100
asset: 0x0000000000000000000000000000000000000000
ts: 1791395618

ultravein link
address: 0xyouraddress
code: UV-8K2F-QX7M-41PD
ts: 1791395619

The terminal signs its own messages with the node key (Ed25519, base64url): ultravein node for init and ultravein beat for each heartbeat, each with node: and ts: lines.

Rig

Your miner; one per wallet.

Node

The terminal key that switches a rig on; holds no funds.

VGA

The hashrate tier your rig runs, held or bought.

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.