Documentation

Unova Nodes is the self-service deployment interface for the Unova network. It lets you spin up a node — validator, data node, or Open Innovation Node — in a few clicks, with no DevOps required. You connect your wallet, pick a node type and a deployment target, and the launchpad handles the install and registration. You always retain custody of both your wallet and your hosting account.

1. Connect your wallet from any page using the Connect Wallet button. We support MetaMask, WalletConnect, Coinbase Wallet, social login, and most other EIP-1193 wallets via Reown AppKit. You'll be prompted to switch to Unova Testnet — accept it, then sign once to complete Sign-in with Ethereum.
2. Type-2 only: create your company at /data/companyfirst. Companies own Type-2 nodes; you can't deploy one without one.
3. Go to Deploy a node and pick a type (see Node types below).
4. Pick a deployment target:DigitalOcean — paste a personal API token and we auto-provision a droplet (cost varies by node type, billed by DO directly). We also generate a per-droplet SSH key so you can manage runtime config from the launchpad later.On-premise — bring your own Ubuntu 22.04+ server and we hand you a one-line install command. Runtime config edits via the launchpad require an SSH key, so on-prem nodes are install-once for now.
5. For Type-1 / Type-2 you'll provide an operator private key — the key that signs blocks (Type-1) or data bundles (Type-2). Use a fresh wallet for this, never your main one (see The 3-key model below).
6. Type-2/4 data nodes are whitelisted automatically at deploy time — no approval wait. Only Type-1 validators wait for owner approval (48h SLA). Watch status on My nodes.

The operator key pays gas when your node publishes data bundles to the chain. After deploying a data node, send some UON to the operator address (shown on the node detail page) — the faucet drips 1 UON per day per wallet, which covers normal bundle traffic. A node whose operator balance hits zero keeps accepting API writes but stops anchoring them on-chain until refunded.

Three different wallets are involved in running a node. Keeping them separate is what stops a single compromise from emptying your treasury.

Only Type-1 (validator) deploys wait for a manual owner approval. Type-2/Type-4 data nodes are whitelisted automatically at deploy time (the launchpad signs the on-chain whitelist transaction itself), and Type-3 (OIN) needs no approval at all — both run as soon as the install finishes.

Type-1 (validator)

1. You submit the deploy form. KYC fields are optional but speed up review.
2. Your node installs and starts running but doesn't mint blocks until it's registered to the validator set on chain.
3. Registration is a single on-chain transaction by the network admin. Typical SLA: 48 hours.
4. Once registered, your node enters the validator set within a few blocks and starts producing. You can watch the transition on My nodes.

Type-2 / Type-4 (data node)

1. Create your company at /data/company.
2. Deploy the node. The launchpad whitelists the node's operator address on-chain automatically — no waiting.
3. As soon as the install finishes, the node accepts facility writes and participates as a data node. (In rare cases — the launchpad's signing key not being configured — the node falls back to the manual whitelist queue, 48h SLA.)

Both flows are enforced by smart contracts on Unova Testnet — no off-chain trust. We'll move to a Safe multisig with a security co-signer in Phase 2 of the network.

Type-2 nodes are built around a company. One company can own multiple Type-2 nodes and multiple physical facilities (warehouses, factories, stores).

1. Create a company at /data/company — name, VAT, address, type. The wallet that creates it is the primary admin.
2. Invite teammates by wallet address with roles: admin (full control), operator (deploy + manage nodes), viewer (read-only). They claim the invite when they sign in.
3. Add facilities. Each facility gets its own auto-generated wallet (operator key, encrypted at rest). This is the data-attribution identity for that site — separate from any user wallet.
4. Generate an API tokenfor a facility. The launchpad picks up the Hermes URL from your Type-2 node automatically, exchanges the facility's private key for a bearer token at /auth/getApiToken, and shows it once.
5. Paste the bearer into your warehouse / IoT / ERP system as the Authorization header. Tokens are derived on demand — never persisted by us — so re-generate any time.

Atlas — the worker that batches your assets and events into on-chain bundles — has two knobs you can tune per-node from the node detail page:

• Bundling interval (default 300s) — how often the worker checks for unbundled data. Lower = fresher data, more gas. Range: 30s – 86,400s.
• Minimum items per bundle (default 3) — wait until this many assets+events accumulate before bundling. Higher = cheaper, slower indexing. Range: 1 – 10,000.

Three presets are wired in for typical use cases: Realtime (60s / 1 item), Balanced (300s / 3 items, default), and Cost-saving (1800s / 25 items).

Changes are saved to the launchpad DB and applied to the running node via SSH (we generate a per-droplet ed25519 keypair during provisioning, store the privkey AES-encrypted, and use it to sed-patch the running docker-compose.yml + restart the worker container). Older nodes deployed before this feature shipped need a redeploy to enable live apply.

Use the deploy wizard (Nodes → Deploy → On-premise): it registers your node and gives you a personalised one-line install command that carries your node ID and a one-time INSTALL_SECRET. That secret is how the installer securely fetches your registry credentials and staged operator key — a bare, unparameterised command would install an unregistered node that never appears in the launchpad.

Server requirements:

• Ubuntu 22.04 or 24.04 — the installer uses Ubuntu's Docker repositories; other distros are not supported
• x86-64 (amd64) CPU — ARM (Raspberry Pi, Apple Silicon VMs) will not work
• 4 vCPU / 8 GB RAM / 80 GB disk minimum; root access
• Inbound TCP/UDP 30303 (all types); Type-2/4 also need inbound TCP 80 and 9876 (the launchpad and your integrations call your node's API on these); Type-4 also 3000, or 443 with an HTTPS hostname
• Outbound access to download.docker.com, Docker Hub, ghcr.io, ollama.com (Type-4) and nodes.unova.io

For Type-1/2/4 you must stage your operator key on the server BEFORE running the command (the wizard shows three staging options — key file, environment variable with sudo -E, or interactive). The installer aborts with a clear error if no key is staged; it never generates one for you, because the key must match the address registered in the launchpad. Script source: /install/setup.sh.

Approval pending longer than the 48-hour SLA, an install that won't complete, or an error you can't place — email tech@unova.io with your node ID (visible on the node's detail page). Failed installs can be re-run from the node detail page ("Re-run install"), and its "View install logs" button shows the server-side log without SSH.

Network

Unova Testnet

Chain ID

3001

Native token

UON (18 decimals)

Block time

~5 seconds

RPC

https://rpctest.unova.io

Explorer

https://explorertest.unova.io

Mainnet is on the roadmap but RPC and contracts are not deployed yet. Switching your wallet to Unova Mainnet inside the app will trigger a "coming soon" toast and switch you back to testnet.

Unova is EVM-compatible — anything that runs on Ethereum runs here. Standard tooling (Foundry, Hardhat, viem, ethers.js, MetaMask) works out of the box against the RPC above: chain ID 3001, native token UON (18 decimals). Get testnet UON from the faucet.

1. Add the network to your wallet

Or add it manually: RPC https://rpctest.unova.io, chain ID 3001 (0xbb9), symbol UON, explorer https://explorertest.unova.io.

2. Fund your deployer

Deploys cost gas — grab testnet UON from /faucetfor the address you'll deploy with before continuing.

3. Deploy a contract with Foundry

forge init hello-unova && cd hello-unova

Create src/HelloUnova.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloUnova {
    string public greeting = "Hello, Unova!";

    function setGreeting(string calldata g) external {
        greeting = g;
    }
}

Deploy it (with $PKset to your funded deployer's private key):

forge create --rpc-url https://rpctest.unova.io \
  --private-key $PK \
  src/HelloUnova.sol:HelloUnova

The transaction shows up on the explorer within a few blocks. Contract source verification is coming with the new explorer.

• API reference — endpoints exposed by your Type-2 node (assets, events, bundles, auth)
• Block explorer
• Monitor (live network stats)
• unova.io — main site, whitepaper, contact