VitoCoin Technical Documentation

Protocol Parameters

Supply Schedule

VitoCoin has a hard-capped maximum supply of 21,000,000 VITO. All issuance is through CPU Proof-of-Work block rewards. No premine, no ICO, no developer allocation beyond the 6-block genesis reserve for network bootstrap.

Genesis Reserve

Blocks 0–6 were mined at network launch to establish the initial chain state and provide liquidity for early exchange pairs and node operators. These 350 VITO represent 0.0017% of maximum supply. All addresses are publicly verifiable on the block explorer.

Proof-of-Work Algorithm

VitoCoin uses double SHA-256 (SHA-256d) — the same algorithm used by Bitcoin. This provides battle-tested security, broad hardware compatibility, and no dependence on ASIC-resistance assumptions that have historically proven fragile.

Hash Function

hash = SHA256( SHA256( block_header_bytes ) )

Validity Condition

# The resulting 256-bit hash interpreted as little-endian integer
# must be strictly less than the current compact target:
hash_integer < target

# Where target is derived from the 'bits' field in the block header:
target = mantissa * 256 ** (exponent - 3)

Difficulty Adjustment

Retargets every 144 blocks. The new difficulty is computed as:

actual_time   = timestamp[n] - timestamp[n-144]
expected_time = 144 * 60  # seconds

new_target = old_target * (actual_time / expected_time)
# Clamped: new_target ∈ [old_target/4, old_target*4]

Mining Protocol

External miners connect via the REST API at /mining/template and submit solved headers via /mining/submit. The node also exposes a Server-Sent Events stream for real-time NEW_BLOCK notifications.

Block Header Format

The 80-byte block header is identical in structure to Bitcoin's. All fields are little-endian.

Coinbase Transaction Format

# Coinbase txid (single-transaction block):
txid = sha256d( "coinbase:{height}:{miner_address}:{nonce}" )

# Merkle root for single-tx block:
merkle_root = reverse_bytes( txid )

UTXO Model

VitoCoin uses an Unspent Transaction Output (UTXO) model. Each transaction consumes previous outputs and creates new ones. The sum of inputs must equal the sum of outputs plus the transaction fee.

# Transaction validity rule:
sum(inputs.value) = sum(outputs.value) + fee
fee >= 0.0001 VITO  # minimum relay fee

Double-Spend Protection

The node maintains a UTXO set in memory and on disk. Any attempt to reference an already-spent UTXO is rejected immediately with error double spend. The frontend wallet monitors for this rejection and broadcasts an alert to the admin command center.

Coinbase Maturity Rules

Coinbase (mined) outputs require 114 confirmations before they can be used as inputs in new transactions. This prevents miners from spending rewards from blocks that may be orphaned.

Mempool Policy

• Maximum mempool size: 10,000 transactions
• Minimum relay fee: 0.0001 VITO per transaction
• Transaction expiry: 72 hours from first broadcast
• Duplicate TXID: rejected
• Double-spend: rejected with explicit error code
• Coinbase transactions: only accepted in block context (not relayed standalone)

GET /api/v1/summary

This public, unauthenticated endpoint returns the data required by CoinMarketCap, CoinGecko, and Binance for listing applications. No API key required.

{ "loading": true }

Response Schema

Node REST API

Every VitoCoin node exposes a REST API on port 6334. The official nodes are proxied through Vercel at vitocoin.com/api/node/*.

Server-Sent Events (SSE)

The node exposes a real-time event stream at /events. Connect with EventSource:

const sse = new EventSource('https://vitocoin.com/api/node/events');

sse.addEventListener('NEW_BLOCK', e => {
  const block = JSON.parse(e.data);
  // { height, hash, timestamp, tx_count, reward_vito }
});

sse.addEventListener('NEW_TRANSACTION', e => {
  const tx = JSON.parse(e.data);
  // { txid, fee_vito, inputs, outputs }
});

sse.addEventListener('HASHRATE_UPDATE', e => {
  const stats = JSON.parse(e.data);
  // { hashrate_hps, miners, difficulty }
});

Bootstrap Nodes

New nodes bootstrap by connecting to the following seed peers. Peer discovery is fully automatic after initial connection.

Security

• Double-Spend Protection: UTXO set checked on every transaction; duplicate inputs rejected in both mempool and block validation
• 51% Attack Resistance: SHA-256d; any reorg attempt must outpace the honest chain's cumulative PoW
• Seed Encryption: Client-side BIP-39 mnemonics encrypted with AES-256-GCM + PBKDF2 (100,000 rounds, SHA-256) before storage
• Rate Limiting: API endpoints enforce 429 responses; the client rotates to backup nodes automatically
• No Admin Keys: No privileged API keys that bypass consensus — all rules enforced at the protocol layer

Full security audit log: vitocoin.com/security-audit · Report issues: security@vitocoin.com

CoinMarketCap Listing Data Feed

The /api/v1/summary endpoint is designed to satisfy the CMC and CoinGecko listing data requirements. It returns all mandatory fields in a single, cacheable JSON response.

# Example cURL
curl -s https://vitocoin.com/api/v1/summary | jq .

# Example Node.js
const res = await fetch('https://vitocoin.com/api/v1/summary');
const data = await res.json();
console.log(data.circulating_supply, data.last_price_usd);

Required Listing Links

Spending VITO

VITO is the native utility token of the VitoCoin network. Beyond peer-to-peer transfers and mining rewards, VITO is designed to power a growing ecosystem of real-world applications.