DOCUMENTATION

Protocol specification and developer reference for the VTT blockchain. Covers architecture, consensus, tokenomics, smart contracts, compliance, governance, cross-chain messaging, and the full JSON-RPC API.

PROTOCOL OVERVIEW

CRYPTOGRAPHIC PRIMITIVES

ARCHITECTURE DIAGRAM

STORAGE (ROCKSDB)

CONSENSUS (DPOS)

CONSENSUS PARAMETERS

VALIDATOR ELECTION

SLASHING

BFT FINALITY

TOKEN ECONOMICS

SUPPLY & ALLOCATION

INFLATION & STAKING REWARDS

REWARD DISTRIBUTION

GAS & FEES

GAS COST TABLE

FEE CALCULATION EXAMPLE

// Simple transfer
gas_used  = 21,000 (base_transfer)
gas_price = 1 gwei = 1,000,000,000 raw units

total_fee = 21,000 * 1,000,000,000 = 21,000,000,000,000 raw units
          = 0.000021 VTT

// Of that fee:
//   70% burned    = 0.0000147 VTT (removed from supply)
//   30% producer  = 0.0000063 VTT (paid to block producer)

SMART CONTRACTS

CONTRACT REQUIREMENTS

ARGUMENT PASSING

HOST FUNCTIONS

DEPLOYMENT & EXECUTION

CONTRACT STORAGE

MINIMAL CONTRACT EXAMPLE (RUST)

#![no_std]
#![no_main]

extern "C" {
    fn host_storage_read(key_ptr: *const u8, key_len: i32, val_ptr: *mut u8, val_max: i32) -> i32;
    fn host_storage_write(key_ptr: *const u8, key_len: i32, val_ptr: *const u8, val_len: i32);
    fn host_emit_log(data_ptr: *const u8, data_len: i32);
}

#[no_mangle]
pub extern "C" fn increment() -> i32 {
    let key = b"counter";
    let mut buf = [0u8; 8];

    unsafe {
        // Read current value
        let len = host_storage_read(key.as_ptr(), key.len() as i32, buf.as_mut_ptr(), 8);
        let current = if len > 0 {
            u64::from_le_bytes(buf)
        } else {
            0
        };

        // Increment and write back
        let next = (current + 1).to_le_bytes();
        host_storage_write(key.as_ptr(), key.len() as i32, next.as_ptr(), 8);

        // Log the event
        let msg = b"incremented";
        host_emit_log(msg.as_ptr(), msg.len() as i32);
    }

    0 // success
}

ASSET TOKENIZATION (RWA)

THREE-LAYER ARCHITECTURE

VEHICLE OPTIONS

REGISTRAR PARTNERSHIP MODEL

ONBOARDING FLOW

ASSET CLASSIFICATIONS

ASSET LIFECYCLE

ASSET METADATA

DOCUMENT TYPES

COMPLIANCE & IDENTITY

CLAIM TYPES

CLAIM STRUCTURE

interface IdentityClaim {
  claim_type: ClaimType;    // KYC | AMLCleared | AccreditedInvestor | ...
  issuer: Address;          // Address of the claim issuer
  subject: Address;         // Address the claim is about
  issued_at: u64;           // Unix timestamp of issuance
  expires_at: u64;          // Unix timestamp of expiration (0 = no expiry)
  revoked: boolean;         // Whether the claim has been revoked
  data: Vec<u8>;            // Optional additional data (e.g. jurisdiction code)
}

TRANSFER VALIDATION

GOVERNANCE

GOVERNANCE PARAMETERS

PROPOSAL TYPES

PARAMETERCHANGE WHITELIST

PROPOSAL LIFECYCLE

ASSET GOVERNANCE

ASSET GOVERNANCE PARAMETERS

PROPOSAL ACTION TYPES

TRANSACTION ACTIONS

REVENUE DISTRIBUTION

BLOCK REWARDS

INFLATION MODEL

EPOCH REWARD CALCULATION

// Epoch reward formula (from vtt-consensus/src/rewards.rs)
//
// base_rate = 50 per mille (5% annual)
//
// If staking_ratio == 0%:
//   adjusted = base_rate × 2 (max incentive)
// Else:
//   adjusted = clamp(60 × base_rate / staking_ratio, base_rate/2, base_rate×2)
//
// epoch_reward = total_supply × adjusted / (1000 × 8760)

// Example at 60% staking (target):
//   adjusted = 60 × 50 / 60 = 50
//   epoch_reward = 1,000,000,000 × 50 / (1000 × 8760) ≈ 5,708 VTT per epoch

BLOCK REWARD SPLIT

GAS FEE SPLIT

BRIDGE SYSTEM

ARCHITECTURE

BRIDGE WITHDRAW (VTT → ETHEREUM)

RELAYER FLOW

BRIDGE DEPOSIT (ETHEREUM → VTT)

CROSS-CHAIN MESSAGING

PAYLOAD TYPES

MESSAGE LIFECYCLE

MECHANICS

ORACLE SYSTEM

FEED TYPES

AGGREGATION MECHANICS

DEX / AMM

CONSTANT PRODUCT FORMULA

FEE STRUCTURE

LP TOKENS

LIQUIDITY MINING

REVENUE SHARE (VTT-REV)

vUSDT — NATIVE STABLECOIN

POOL CREATION

NETWORK

NETWORK STACK

BLOCK SYNC PROTOCOL

PROMETHEUS METRICS

API REFERENCE

Complete JSON-RPC 2.0 developer reference. Query chain state, submit transactions, manage tokenized assets, interact with governance, staking, DEX, and more.

API OVERVIEW

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "vtt_methodName",
  "params": [...]
}

RATE LIMITING

CONNECTION

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_chainStatus","params":[]}'

CHAIN METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_chainStatus","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "chain_id": 1,
    "height": 128456,
    "head_hash": "0x9f3a...b2c1",
    "validator_count": 21,
    "total_stake": "0x56bc75e2d63100000"
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_chainHeight","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": 128456
}

BLOCK METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getBlock","params":["0x9f3a...b2c1"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x9f3a...b2c1",
    "number": 128456,
    "parent_hash": "0x8e2b...a1d0",
    "state_root": "0x1234...5678",
    "transactions_root": "0xabcd...ef01",
    "validator": "0x0101010101010101010101010101010101010101",
    "epoch": 642,
    "slot": 3,
    "timestamp": 1711900800,
    "gas_limit": 30000000,
    "gas_used": 1250000,
    "tx_count": 15
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getBlockByNumber","params":[128456]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x9f3a...b2c1",
    "number": 128456,
    "parent_hash": "0x8e2b...a1d0",
    "state_root": "0x1234...5678",
    "transactions_root": "0xabcd...ef01",
    "validator": "0x0101010101010101010101010101010101010101",
    "epoch": 642,
    "slot": 3,
    "timestamp": 1711900800,
    "gas_limit": 30000000,
    "gas_used": 1250000,
    "tx_count": 15
  }
}

ACCOUNT METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getBalance","params":["0x0101010101010101010101010101010101010101"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x56bc75e2d63100000"
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getAccount","params":["0x0101010101010101010101010101010101010101"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "address": "0x0101010101010101010101010101010101010101",
    "balance": "0x56bc75e2d63100000",
    "nonce": 42,
    "is_contract": false
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getStakingInfo","params":["0x0101010101010101010101010101010101010101"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "address": "0x0101010101010101010101010101010101010101",
    "self_stake": "0x56bc75e2d63100000",
    "total_stake": "0x1b1ae4d6e2ef500000",
    "commission_bps": 500,
    "active": true,
    "delegations": [
      { "delegator": "0xabcd...1234", "amount": "0xDE0B6B3A7640000" },
      { "delegator": "0x5678...ef01", "amount": "0x1BC16D674EC80000" }
    ]
  }
}

TRANSACTION METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_sendTransaction","params":["0a0b0c...signed_tx_hex"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x7f8a3c...transaction_hash"
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getTransaction","params":["0x7f8a3c..."]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "hash": "0x7f8a3c...abcd",
    "block_number": 128456,
    "from": "0x0101010101010101010101010101010101010101",
    "to": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
    "action_type": "Transfer",
    "amount": "0xDE0B6B3A7640000",
    "gas_used": 21000,
    "status": "success",
    "timestamp": 1711900800,
    "payload_hex": "01000000..."
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_listTransactions","params":[1, 20]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "items": [
      {
        "hash": "0x7f8a...",
        "block_number": 128456,
        "from": "0x0101...0101",
        "to": "0xabcd...abcd",
        "action_type": "Transfer",
        "amount": "0xDE0B6B3A7640000",
        "gas_used": 21000,
        "status": "success",
        "timestamp": 1711900800,
        "payload_hex": "01000000..."
      }
    ],
    "total": 543210,
    "page": 1,
    "page_size": 20
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getTransactionsByAddress","params":["0x0101010101010101010101010101010101010101", 1, 20]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "items": [ ... ],
    "total": 87,
    "page": 1,
    "page_size": 20
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_txPoolSize","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": 42
}

VALIDATOR METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getValidators","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "address": "0x0101010101010101010101010101010101010101",
      "total_stake": "0x1b1ae4d6e2ef500000",
      "self_stake": "0x56bc75e2d63100000",
      "commission_bps": 500
    },
    {
      "address": "0x0202020202020202020202020202020202020202",
      "total_stake": "0xad78ebc5ac6200000",
      "self_stake": "0x56bc75e2d63100000",
      "commission_bps": 300
    }
  ]
}

ASSET METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getAsset","params":["0xabc123..."]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "0xabc123...",
    "name": "Milan Office Tower A",
    "symbol": "MOTA",
    "issuer": "0x0101010101010101010101010101010101010101",
    "total_supply": "0x52b7d2dcc80cd2e4000000",
    "status": "active",
    "decimals": 18
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getAssetBalance","params":["0xabc123...", "0x0101...0101"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "asset_id": "0xabc123...",
    "owner": "0x0101010101010101010101010101010101010101",
    "available": "0xDE0B6B3A7640000",
    "locked": "0x0"
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_listAssets","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "id": "0xabc123...",
      "name": "Milan Office Tower A",
      "symbol": "MOTA",
      "issuer": "0x0101...0101",
      "total_supply": "0x52b7d2dcc80cd2e4000000",
      "status": "active",
      "decimals": 18
    }
  ]
}

GOVERNANCE METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_listProposals","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "id": "0xdeadbeef...",
      "proposer": "0x0101...0101",
      "description": "Increase max validators to 50",
      "action_type": "ParameterChange",
      "status": "active",
      "votes_yes": "0x56bc75e2d63100000",
      "votes_no": "0x0",
      "votes_abstain": "0xDE0B6B3A7640000",
      "created_at": 1711800000,
      "voting_end": 1712404800
    }
  ]
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getProposal","params":["0xdeadbeef..."]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "0xdeadbeef...",
    "proposer": "0x0101...0101",
    "description": "Increase max validators to 50",
    "action_type": "ParameterChange",
    "status": "active",
    "votes_yes": "0x56bc75e2d63100000",
    "votes_no": "0x0",
    "votes_abstain": "0xDE0B6B3A7640000",
    "created_at": 1711800000,
    "voting_end": 1712404800
  }
}

ASSET GOVERNANCE METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getAssetProposals","params":["0xabc123..."]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "id": "0xdeadbeef...",
      "asset_id": "0xabc123...",
      "proposer": "0x0101...0101",
      "action_type": "DistributeRevenue",
      "description": "Distribute Q1 2026 rental income",
      "status": "Active",
      "votes_yes": "0x56bc75e2d63100000",
      "votes_no": "0x0",
      "votes_abstain": "0xDE0B6B3A7640000",
      "voting_end": 302400,
      "created_at": 100800
    }
  ]
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getAssetProposal","params":["0xdeadbeef..."]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "0xdeadbeef...",
    "asset_id": "0xabc123...",
    "proposer": "0x0101...0101",
    "action_type": "DistributeRevenue",
    "description": "Distribute Q1 2026 rental income",
    "status": "Active",
    "votes_yes": "0x56bc75e2d63100000",
    "votes_no": "0x0",
    "votes_abstain": "0xDE0B6B3A7640000",
    "voting_end": 302400,
    "created_at": 100800
  }
}

BRIDGE METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getBridgeWithdrawals","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "tx_hash": "0x7f8a3c...abcd",
      "block_number": 128456,
      "sender": "0x0101010101010101010101010101010101010101",
      "token": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "amount": "0xDE0B6B3A7640000",
      "destination_chain": 1,
      "destination_address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
      "timestamp": 1711900800
    }
  ]
}

CONFIG METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getConsensusParams","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "epoch_length": 1200,
    "block_time_ms": 3000,
    "active_validators": 21,
    "min_self_stake": "0x152D02C7E14AF6800000",
    "unbonding_period_secs": 1814400,
    "slash_double_sign_bps": 500,
    "slash_downtime_bps": 10,
    "downtime_threshold_pct": 50
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getGasConfig","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "min_gas_price": "0x3B9ACA00",
    "base_transfer_cost": 21000,
    "cost_per_byte": 16
  }
}

DEX / SWAP METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_listPools","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": [
    {
      "pool_id": "0x3a5b8c2f1e9d4a7b6c0f2e1d3a8b9c4d5e6f7a0b1c2d3e4f5a6b7c8d9e0f1a2b",
      "token_a": "0x0000000000000000000000000000000000000000000000000000000000000000",
      "token_b": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
      "reserve_a": "0x56bc75e2d63100000",
      "reserve_b": "0x1b1ae4d6e2ef500000",
      "lp_supply": "0x8ac7230489e80000",
      "fee_bps": 30
    }
  ]
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getPool","params":["0x3a5b8c2f1e9d4a7b6c0f2e1d3a8b9c4d5e6f7a0b1c2d3e4f5a6b7c8d9e0f1a2b"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "pool_id": "0x3a5b8c2f1e9d4a7b6c0f2e1d3a8b9c4d5e6f7a0b1c2d3e4f5a6b7c8d9e0f1a2b",
    "token_a": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "token_b": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
    "reserve_a": "0x56bc75e2d63100000",
    "reserve_b": "0x1b1ae4d6e2ef500000",
    "lp_supply": "0x8ac7230489e80000",
    "fee_bps": 30
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getSwapQuote","params":["0x3a5b8c2f1e9d4a7b6c0f2e1d3a8b9c4d5e6f7a0b1c2d3e4f5a6b7c8d9e0f1a2b","0x0000000000000000000000000000000000000000000000000000000000000000","1000000000000000000"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "amount_in": "0xDE0B6B3A7640000",
    "amount_out": "0x2B5E3AF16B1880000",
    "price_impact_bps": 12,
    "fee": "0x2386F26FC10000"
  }
}

LAUNCHPAD METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getLaunchpadInfo","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "active": true,
    "price_per_vtt": "0x2386F26FC10000",
    "total_supply": "0x52b7d2dcc80cd2e4000000",
    "sold": "0x1b1ae4d6e2ef500000",
    "cap": "0x295be96e64066972000000",
    "start_time": 1711800000,
    "end_time": 1714392000
  }
}

NETWORK METHODS

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getNetworkStats","params":["24h"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tps": [
      { "timestamp": 1711900000, "value": 45 },
      { "timestamp": 1711900060, "value": 52 }
    ],
    "gas_usage": [
      { "timestamp": 1711900000, "value": 12500000 }
    ],
    "total_stake": [
      { "timestamp": 1711900000, "value": "0x56bc75e2d63100000" }
    ],
    "block_times": [
      { "timestamp": 1711900000, "value": 2000 }
    ]
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getOracle","params":["VTT/USD"]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "feed_id": "VTT/USD",
    "name": "VTT / US Dollar",
    "latest_value": "0.85",
    "updated_at": 1711900800,
    "quorum": 3,
    "sources": 5
  }
}

curl -X POST http://127.0.0.1:9944 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"vtt_getNodeMetrics","params":[]}'

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "block_height": 84210,
    "connected_peers": 12,
    "txpool_size": 3,
    "blocks_imported": 84210,
    "transactions_executed": 152847,
    "current_epoch": 70,
    "active_validators": 21
  }
}

TYPES REFERENCE

Complete TypeScript type definitions for all JSON-RPC response objects. These mirror the Rust types defined in vtt-rpc/src/types.rs.

BlockInfo

interface BlockInfo {
  hash: string;           // Block hash (0x + 64 hex)
  number: number;         // Block height
  parent_hash: string;    // Parent block hash
  state_root: string;     // State trie Merkle root
  transactions_root: string; // Tx trie Merkle root
  validator: string;      // Block producer address (0x + 40 hex)
  epoch: number;          // Epoch number
  slot: number;           // Slot within the epoch
  timestamp: number;      // Unix timestamp (seconds)
  gas_limit: number;      // Max gas for block
  gas_used: number;       // Gas consumed
  tx_count: number;       // Transaction count
}

ChainStatus

interface ChainStatus {
  chain_id: number;       // Chain identifier
  height: number;         // Current block height
  head_hash: string;      // Latest block hash
  validator_count: number; // Active validator count
  total_stake: string;    // Total staked VTT (hex u128, 18 decimals)
  total_burned: string;   // Cumulative VTT burned from gas fees (hex u128)
  total_minted: string;   // Cumulative VTT minted as block rewards (hex u128)
}

AccountInfo

interface AccountInfo {
  address: string;        // Account address (0x + 40 hex)
  balance: string;        // VTT balance (hex u128, 18 decimals)
  nonce: number;          // Transaction sequence number
  is_contract: boolean;   // True if WASM contract
}

ValidatorInfo

interface ValidatorInfo {
  address: string;        // Validator address
  total_stake: string;    // Total stake (self + delegations)
  self_stake: string;     // Validator's own stake
  commission_bps: number; // Commission in basis points (500 = 5%)
}

StakingInfo

interface StakingInfo {
  address: string;        // Validator address
  self_stake: string;     // Own stake (hex u128)
  total_stake: string;    // Total stake including delegations
  commission_bps: number; // Commission (basis points)
  active: boolean;        // In active validator set
  delegations: DelegationInfo[];
}

interface DelegationInfo {
  delegator: string;      // Delegator address
  amount: string;         // Delegated amount (hex u128)
}

AssetInfo

interface AssetInfo {
  id: string;             // Asset ID (0x + 64 hex / 32 bytes)
  name: string;           // Human-readable name
  symbol: string;         // Token ticker
  issuer: string;         // Issuer address
  total_supply: string;   // Total supply (hex u128)
  status: string;         // "active" | "frozen" | "retired"
  decimals: number;       // Decimal places
}

AssetBalanceInfo

interface AssetBalanceInfo {
  asset_id: string;       // Asset ID
  owner: string;          // Owner address
  available: string;      // Available balance (hex u128)
  locked: string;         // Locked balance (hex u128)
}

TransactionInfo

interface TransactionInfo {
  hash: string;           // Transaction hash
  block_number: number;   // Containing block height
  from: string;           // Sender address
  to: string | null;      // Recipient (null for deploys)
  action_type: string;    // "Transfer" | "Stake" | "Swap" | "BridgeWithdraw" | ...
  amount: string;         // VTT amount (hex u128, 18 decimals)
  nonce: number;          // Sender's sequence number
  gas_price: string;      // Gas price per unit (hex u128, 18 decimals)
  gas_limit: number;      // Maximum gas for this tx
  timestamp: number;      // Unix timestamp (seconds)

  // Swap-specific fields (present only for Swap transactions)
  swap_pool_id?: string;  // Pool ID (hex, 0x + 64 chars)
  swap_token_in?: string; // Token being sold (hex, 0x + 64 chars)
  swap_min_out?: string;  // Minimum output amount (hex u128)
}

PaginatedResult<T>

interface PaginatedResult<T> {
  items: T[];             // Items for current page
  total: number;          // Total item count
  page: number;           // Current page number
  page_size: number;      // Items per page
}

ProposalInfo

interface ProposalInfo {
  id: string;             // Proposal ID (0x + 64 hex)
  proposer: string;       // Creator address
  description: string;    // Proposal description
  action_type: string;    // Governance action type
  status: string;         // "pending" | "active" | "passed" | "rejected" | "executed"
  votes_yes: string;      // Yes vote weight (hex u128)
  votes_no: string;       // No vote weight (hex u128)
  votes_abstain: string;  // Abstain vote weight (hex u128)
  created_at: number;     // Creation timestamp (unix seconds)
  voting_end: number;     // Voting deadline (unix seconds)
}

SwapPool

interface SwapPool {
  id: string;             // Pool ID
  token_a: string;        // First token (asset ID or "VTT")
  token_b: string;        // Second token
  reserve_a: string;      // Reserve of token A (hex u128)
  reserve_b: string;      // Reserve of token B (hex u128)
  total_liquidity: string; // Total LP tokens (hex u128)
  fee_bps: number;        // Swap fee (basis points, 30 = 0.3%)
}

SwapQuote

interface SwapQuote {
  amount_in: string;      // Input amount (hex u128)
  amount_out: string;     // Expected output (hex u128)
  price_impact_bps: number; // Price impact (basis points)
  fee: string;            // Swap fee (hex u128)
}

LaunchpadInfo

interface LaunchpadInfo {
  active: boolean;        // Sale currently active
  price_per_vtt: string;  // Price per VTT (hex u128)
  total_supply: string;   // Tokens allocated for sale (hex u128)
  sold: string;           // Tokens sold so far (hex u128)
  cap: string;            // Hard cap (hex u128)
  start_time: number;     // Sale start (unix seconds)
  end_time: number;       // Sale end (unix seconds)
}

NetworkStats

interface NetworkStats {
  tps: { timestamp: number; value: number }[];
  gas_usage: { timestamp: number; value: number }[];
  total_stake: { timestamp: number; value: string }[];
  block_times: { timestamp: number; value: number }[];
}

OracleFeedInfo

interface OracleFeedInfo {
  feed_id: string;        // Feed identifier
  name: string;           // Human-readable name
  latest_value: string | null; // Latest value (null if no data)
  updated_at: number;     // Last update (unix seconds)
  quorum: number;         // Min required sources
  sources: number;        // Current reporting sources
}

AssetProposalInfo

interface AssetProposalInfo {
  id: string;             // Proposal ID (0x + 64 hex)
  asset_id: string;       // Target asset ID
  proposer: string;       // Creator address
  action_type: string;    // "DistributeRevenue" | "ChangeIssuer" | "Signal"
  description: string;    // Human-readable description
  status: string;         // "Active" | "Passed" | "Rejected" | "Executed"
  votes_yes: string;      // Yes vote weight (hex u128, token-weighted)
  votes_no: string;       // No vote weight (hex u128)
  votes_abstain: string;  // Abstain vote weight (hex u128)
  voting_end: number;     // Block number when voting ends
  created_at: number;     // Block number when created
}

BridgeWithdrawalInfo

interface BridgeWithdrawalInfo {
  tx_hash: string;        // Transaction hash on VTT chain
  block_number: number;   // Block that included the withdrawal
  sender: string;         // Sender address on VTT
  token: string;          // Token ID (0x000...0 = VTT, or asset ID)
  amount: string;         // Amount burned (hex u128)
  destination_chain: number; // EVM chain ID (1, 8453, etc.)
  destination_address: string; // Recipient on external chain
  timestamp: number;      // Unix timestamp (seconds)
}

ConsensusParamsRpc

interface ConsensusParamsRpc {
  epoch_length: number;       // Blocks per epoch
  block_time_ms: number;      // Target block time (ms)
  active_validators: number;  // Max active validators
  min_self_stake: string;     // Min self-stake (hex u128, 18 decimals)
  unbonding_period_secs: number; // Unbonding period (seconds)
  slash_double_sign_bps: number; // Double-sign slash (bps)
  slash_downtime_bps: number; // Downtime slash per epoch (bps)
  downtime_threshold_pct: number; // Missed slot % to trigger slash
}

GasConfigRpc

interface GasConfigRpc {
  min_gas_price: string;      // Minimum gas price (hex u128)
  base_transfer_cost: number; // Gas for simple transfer
  cost_per_byte: number;      // Gas per calldata byte
}

TRANSACTION GUIDE

PAYLOAD STRUCTURE

interface TransactionPayload {
  chainId: number;      // u32 — prevents replay across chains
  nonce: bigint;        // u64 — sender's sequence number
  gasPrice: Amount;     // u128 — price per unit of gas (18 decimals)
  gasLimit: bigint;     // u64 — maximum gas units
  action: TransactionAction; // enum — what the tx does
}

// Amount is a u128 with 18 decimal places
interface Amount {
  raw: bigint;          // e.g. 1000000000000000000n = 1.0 VTT
}

BORSH ENCODING RULES

ACTION TYPES

CROSS-CHAIN PAYLOAD VARIANTS

SIGNING & SUBMITTING

import { serializeTransactionPayload } from "@/lib/crypto/borsh";
import { signTransaction } from "@/lib/wallet/transaction";
import { generateKeypair } from "@/lib/wallet/keypair";

// 1. Generate or import a keypair
const wallet = await generateKeypair();
console.log("Address:", wallet.addressHex);
// e.g. "0x7a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b"

// 2. Get account nonce
const account = await rpc.getAccount(wallet.addressHex);
const nonce = BigInt(account.nonce);

// 3. Build the payload
const payload = {
  chainId: 1,
  nonce: nonce,
  gasPrice: { raw: 1000000000n },        // 1 gwei
  gasLimit: 21000n,
  action: {
    type: "Transfer" as const,
    to: hexToBytes("abcdefabcdefabcdefabcdefabcdefabcdefabcd"),
    amount: { raw: 1000000000000000000n }, // 1.0 VTT
  },
};

// 4. Sign and encode
const signed = await signTransaction(payload, wallet.seed, wallet.publicKey);

// 5. Submit
const txHash = await rpc.sendTransaction(signed.encodedHex);
console.log("Tx hash:", txHash);

ACTION EXAMPLES

const payload = {
  chainId: 1,
  nonce: 5n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 50000n,
  action: {
    type: "Stake" as const,
    validator: hexToBytes("0101010101010101010101010101010101010101"),
    amount: { raw: 100000000000000000000n }, // 100 VTT
  },
};

const payload = {
  chainId: 1,
  nonce: 6n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 50000n,
  action: {
    type: "GovernanceVote" as const,
    proposalId: hexToBytes("deadbeefdeadbeefdeadbeefdeadbeef" +
                           "deadbeefdeadbeefdeadbeefdeadbeef"),
    vote: 0, // 0 = Yes, 1 = No, 2 = Abstain
  },
};

const payload = {
  chainId: 1,
  nonce: 7n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 200000n,
  action: {
    type: "CreateAssetClass" as const,
    name: "Milan Office Tower A",
    symbol: "MOTA",
    metadataUri: "ipfs://QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG",
    totalSupply: { raw: 100000000000000000000000n }, // 100,000 tokens
  },
};

const payload = {
  chainId: 1,
  nonce: 8n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 50000n,
  action: {
    type: "AssetTransfer" as const,
    assetId: hexToBytes("abc123..." + "0".repeat(38)), // 32 bytes
    to: hexToBytes("abcdefabcdefabcdefabcdefabcdefabcdefabcd"),
    amount: { raw: 500000000000000000000n }, // 500 tokens
  },
};

const wasmBytes = new Uint8Array(fs.readFileSync("contract.wasm"));
const initArgs = new TextEncoder().encode('{"owner":"0x0101..."}');

const payload = {
  chainId: 1,
  nonce: 9n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 5000000n,
  action: {
    type: "DeployContract" as const,
    code: wasmBytes,
    initData: initArgs,
  },
};

const args = new TextEncoder().encode('{"recipient":"0xabcd...","amount":"1000"}');

const payload = {
  chainId: 1,
  nonce: 10n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 500000n,
  action: {
    type: "CallContract" as const,
    contract: hexToBytes("abcdefabcdefabcdefabcdefabcdefabcdefabcd"),
    method: "transfer",
    args: args,
    value: { raw: 0n }, // no VTT sent with call
  },
};

const payload = {
  chainId: 1,
  nonce: 11n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 100000n,
  action: {
    type: "CrossChainTransfer" as const,
    destinationChain: 2,
    to: hexToBytes("abcdefabcdefabcdefabcdefabcdefabcdefabcd"),
    payload: {
      type: "VttTransfer" as const,
      amount: { raw: 10000000000000000000n }, // 10 VTT
    },
  },
};

const payload = {
  chainId: 1,
  nonce: 12n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 500000n,
  action: {
    type: "DistributeRevenue" as const,
    assetId: hexToBytes("abc123..." + "0".repeat(38)), // 32 bytes
    totalAmount: { raw: 10000000000000000000000n }, // 10,000 VTT
  },
};

const payload = {
  chainId: 1,
  nonce: 13n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 200000n,
  action: {
    type: "ProposeAssetAction" as const,
    assetId: hexToBytes("abc123..." + "0".repeat(38)),
    action: {
      type: "DistributeRevenue" as const,
      totalAmount: { raw: 5000000000000000000000n }, // 5,000 VTT
    },
    description: "Distribute Q1 2026 rental income to all holders",
  },
};

const payload = {
  chainId: 1,
  nonce: 14n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 50000n,
  action: {
    type: "VoteAssetProposal" as const,
    proposalId: hexToBytes("deadbeef..." + "0".repeat(48)), // 32 bytes
    vote: 0, // 0 = Yes, 1 = No, 2 = Abstain
  },
};

const payload = {
  chainId: 1,
  nonce: 15n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 100000n,
  action: {
    type: "BridgeWithdraw" as const,
    token: new Uint8Array(32), // H256::ZERO = native VTT
    amount: { raw: 5000000000000000000n }, // 5 VTT
    destinationChain: 1, // Ethereum mainnet
    destinationAddress: hexToBytes("abcdefabcdefabcdefabcdefabcdefabcdefabcd"),
  },
};

const payload = {
  chainId: 1,
  nonce: 16n,
  gasPrice: { raw: 1000000000n },
  gasLimit: 200000n,
  action: {
    type: "Swap" as const,
    poolId: hexToBytes("3a5b8c2f..." + "0".repeat(48)), // 32 bytes
    tokenIn: new Uint8Array(32), // H256::ZERO = native VTT
    amountIn: { raw: 1000000000000000000n }, // 1 VTT
    minAmountOut: { raw: 2800000000000000000n }, // min 2.8 tokens out
  },
};

WALLET GUIDE

KEYPAIR STRUCTURE

interface WalletKeypair {
  seed: Uint8Array;       // 32-byte Ed25519 seed (KEEP SECRET)
  publicKey: Uint8Array;  // 32-byte Ed25519 public key
  address: Uint8Array;    // 20-byte VTT address
  publicKeyHex: string;   // "0x" + 64 hex chars
  addressHex: string;     // "0x" + 40 hex chars
}

ADDRESS DERIVATION

// Address derivation (from blake3.ts)
import { blake3 } from "@noble/hashes/blake3";

function addressFromPublicKey(publicKey: Uint8Array): Uint8Array {
  const hash = blake3(publicKey);  // 32-byte BLAKE3 hash
  return hash.slice(12, 32);       // last 20 bytes
}

// Result: 0x + 40 hex chars = 20-byte address

GENERATE A NEW KEYPAIR

import { generateKeypair } from "@/lib/wallet/keypair";

const wallet = await generateKeypair();

console.log("Seed (KEEP SECRET):", bytesToHex(wallet.seed));
console.log("Public Key:", wallet.publicKeyHex);
console.log("Address:", wallet.addressHex);

// Example output:
// Seed: "a1b2c3d4...64 hex chars"
// Public Key: "0x9f8e7d6c5b4a3...64 hex chars"
// Address: "0x7a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b"

IMPORT FROM SEED

import { importFromHexSeed } from "@/lib/wallet/keypair";

// Import from a 64-character hex seed (32 bytes)
const wallet = await importFromHexSeed(
  "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6"
);

console.log("Address:", wallet.addressHex);
// Deterministic: same seed always produces the same address

SIGNING MESSAGES

import { sign, verify, getPublicKey } from "@/lib/crypto/ed25519";

// Sign arbitrary data
const message = new TextEncoder().encode("Hello VTT");
const signature = await sign(message, seed);

// Verify
const publicKey = await getPublicKey(seed);
const valid = await verify(signature, message, publicKey);
console.log("Valid:", valid); // true

CRYPTOGRAPHIC LIBRARIES

ERROR CODES

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32001,
    "message": "Nonce too low: expected 43, got 42"
  }
}

import { VttRpcClient, RpcError } from "@/lib/rpc/client";

const client = new VttRpcClient("http://127.0.0.1:9944");

try {
  const result = await client.call("vtt_getBalance", ["0x0101...0101"]);
  console.log("Balance:", result);
} catch (err) {
  if (err instanceof RpcError) {
    console.error(`RPC error ${err.code}: ${err.message}`);
    // Handle specific error codes
    if (err.code === -32001) {
      console.error("Nonce mismatch — re-fetch account nonce");
    }
  }
}

SDK EXAMPLES

JAVASCRIPT / TYPESCRIPT

// === VTT JSON-RPC Client — JavaScript ===

const RPC_URL = "http://127.0.0.1:9944";

async function rpcCall(method, params = []) {
  const res = await fetch(RPC_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
  });
  const json = await res.json();
  if (json.error) throw new Error(`RPC ${json.error.code}: ${json.error.message}`);
  return json.result;
}

// Chain status
const status = await rpcCall("vtt_chainStatus");
console.log("Height:", status.height);
console.log("Validators:", status.validator_count);

// Account balance
const balance = await rpcCall("vtt_getBalance", [
  "0x0101010101010101010101010101010101010101",
]);
const vttBalance = Number(BigInt(balance)) / 1e18;
console.log("Balance:", vttBalance, "VTT");

// Full account info
const account = await rpcCall("vtt_getAccount", [
  "0x0101010101010101010101010101010101010101",
]);
console.log("Nonce:", account.nonce);
console.log("Is contract:", account.is_contract);

// Get block by number
const block = await rpcCall("vtt_getBlockByNumber", [100]);
if (block) {
  console.log("Block hash:", block.hash);
  console.log("Tx count:", block.tx_count);
  console.log("Validator:", block.validator);
}

// List validators
const validators = await rpcCall("vtt_getValidators");
for (const v of validators) {
  const stake = Number(BigInt(v.total_stake)) / 1e18;
  console.log(`${v.address}: ${stake} VTT staked, ${v.commission_bps / 100}% commission`);
}

// Paginated transactions
const txPage = await rpcCall("vtt_listTransactions", [1, 10]);
console.log(`Showing ${txPage.items.length} of ${txPage.total} transactions`);
for (const tx of txPage.items) {
  console.log(`${tx.hash} — ${tx.action_type} — ${tx.status}`);
}

// List assets (RWA tokens)
const assets = await rpcCall("vtt_listAssets");
for (const a of assets) {
  console.log(`${a.symbol} (${a.name}) — status: ${a.status}`);
}

// Governance proposals
const proposals = await rpcCall("vtt_listProposals");
for (const p of proposals) {
  console.log(`[#${p.id.slice(0, 10)}] ${p.description} — ${p.status}`);
}

// Swap quote
const quote = await rpcCall("vtt_getSwapQuote", [
  "VTT",
  "0xabc123...",
  "0xDE0B6B3A7640000",
]);
console.log("Expected output:", quote.amount_out);
console.log("Price impact:", quote.price_impact_bps, "bps");

PYTHON

# === VTT JSON-RPC Client — Python ===

import requests
import json

RPC_URL = "http://127.0.0.1:9944"

def rpc_call(method: str, params: list = None) -> dict:
    """Send a JSON-RPC 2.0 request to the VTT node."""
    payload = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": method,
        "params": params or [],
    }
    resp = requests.post(RPC_URL, json=payload)
    resp.raise_for_status()
    data = resp.json()
    if "error" in data:
        raise Exception(f"RPC error {data['error']['code']}: {data['error']['message']}")
    return data["result"]


# Chain status
status = rpc_call("vtt_chainStatus")
print(f"Height: {status['height']}")
print(f"Validators: {status['validator_count']}")
print(f"Chain ID: {status['chain_id']}")

# Account balance (amounts are hex-encoded u128 with 18 decimals)
balance_hex = rpc_call("vtt_getBalance", [
    "0x0101010101010101010101010101010101010101"
])
balance_vtt = int(balance_hex, 16) / 1e18
print(f"Balance: {balance_vtt:.4f} VTT")

# Full account info
account = rpc_call("vtt_getAccount", [
    "0x0101010101010101010101010101010101010101"
])
print(f"Nonce: {account['nonce']}")
print(f"Is contract: {account['is_contract']}")

# Get block by number
block = rpc_call("vtt_getBlockByNumber", [100])
if block:
    print(f"Block #{block['number']}: {block['hash']}")
    print(f"  Validator: {block['validator']}")
    print(f"  Transactions: {block['tx_count']}")
    print(f"  Gas: {block['gas_used']}/{block['gas_limit']}")

# List validators
validators = rpc_call("vtt_getValidators")
for v in validators:
    stake = int(v["total_stake"], 16) / 1e18
    commission = v["commission_bps"] / 100
    print(f"{v['address']}: {stake:.2f} VTT staked, {commission}% commission")

# Paginated transaction list
tx_page = rpc_call("vtt_listTransactions", [1, 10])
print(f"\nShowing {len(tx_page['items'])} of {tx_page['total']} transactions")
for tx in tx_page["items"]:
    amount = int(tx["amount"], 16) / 1e18
    print(f"  {tx['hash'][:16]}... {tx['action_type']} {amount:.4f} VTT [{tx['status']}]")

# Staking info for a validator
staking = rpc_call("vtt_getStakingInfo", [
    "0x0101010101010101010101010101010101010101"
])
if staking:
    print(f"\nValidator {staking['address']}")
    print(f"  Active: {staking['active']}")
    print(f"  Self stake: {int(staking['self_stake'], 16) / 1e18:.2f} VTT")
    print(f"  Total stake: {int(staking['total_stake'], 16) / 1e18:.2f} VTT")
    print(f"  Delegations: {len(staking['delegations'])}")

# List assets (tokenized RWAs)
assets = rpc_call("vtt_listAssets")
for a in assets:
    supply = int(a["total_supply"], 16) / (10 ** a["decimals"])
    print(f"{a['symbol']} ({a['name']}): {supply:.2f} total supply — {a['status']}")

# Governance proposals
proposals = rpc_call("vtt_listProposals")
for p in proposals:
    print(f"Proposal {p['id'][:16]}... — {p['status']}")
    print(f"  {p['description']}")
    yes = int(p["votes_yes"], 16) / 1e18
    no = int(p["votes_no"], 16) / 1e18
    print(f"  Votes: {yes:.2f} yes / {no:.2f} no")

# DEX swap pools
pools = rpc_call("vtt_listPools")
for pool in pools:
    ra = int(pool["reserve_a"], 16) / 1e18
    rb = int(pool["reserve_b"], 16) / 1e18
    print(f"Pool {pool['id'][:16]}... {pool['token_a']}/{pool['token_b']}")
    print(f"  Reserves: {ra:.2f} / {rb:.2f}, Fee: {pool['fee_bps']}bps")

# Swap quote
quote = rpc_call("vtt_getSwapQuote", [
    "VTT", "0xabc123...", "0xDE0B6B3A7640000"
])
out_amount = int(quote["amount_out"], 16) / 1e18
print(f"Swap quote: {out_amount:.4f} out, impact: {quote['price_impact_bps']}bps")

# Launchpad info
launchpad = rpc_call("vtt_getLaunchpadInfo")
print(f"\nLaunchpad active: {launchpad['active']}")
sold = int(launchpad["sold"], 16) / 1e18
total = int(launchpad["total_supply"], 16) / 1e18
print(f"  Sold: {sold:.2f} / {total:.2f} VTT")

# Network stats
stats = rpc_call("vtt_getNetworkStats", ["24h"])
if stats["tps"]:
    latest_tps = stats["tps"][-1]["value"]
    print(f"\nLatest TPS: {latest_tps}")
if stats["block_times"]:
    latest_bt = stats["block_times"][-1]["value"]
    print(f"Latest block time: {latest_bt}ms")

# Oracle feed
oracle = rpc_call("vtt_getOracle", ["VTT/USD"])
if oracle:
    print(f"\n{oracle['name']}: {oracle['latest_value']}")
    print(f"  Sources: {oracle['sources']}/{oracle['quorum']} quorum")

CLI TOOLS

VTT-VALIDATOR

vtt-validator [FLAGS]
  --rpc-port <port>       RPC server port (default: 9944)
  --port <port>           P2P network port (default: 30333)
  --seed <hex>            Validator private key (64 hex chars)
  --genesis <path>        Path to genesis JSON file
  --data-dir <path>       Path to RocksDB data directory
  --bootnodes <addrs>     Comma-separated bootnode multiaddresses
  --metrics-port <port>   Prometheus metrics port (default: 9615)
  --testnet               Use built-in testnet genesis config
  --dev                   Use built-in dev genesis config

Environment: VALIDATOR_SEED (fallback if --seed not provided)

VTT-NODE

vtt-node [FLAGS]
  --rpc-port <port>       RPC server port (default: 9944)
  --port <port>           P2P network port (default: 30333)
  --genesis <path>        Path to genesis JSON file
  --data-dir <path>       Path to RocksDB data directory
  --bootnodes <addrs>     Comma-separated bootnode multiaddresses
  --metrics-port <port>   Prometheus metrics port (default: 9615)
  --testnet               Use built-in testnet genesis config
  --dev                   Use built-in dev genesis config

VTT-CLI

vtt-cli <command> [OPTIONS]
  keygen [--seed <hex>]           Generate or derive a keypair
  balance <address>               Query account balance
  account <address>               Query full account info
  block <hash|number>             Query block by hash or number
  status                          Query chain status
  validators                      List active validators
  genesis [--testnet]             Export genesis JSON
  stake --validator <addr> --amount <vtt> --seed <hex>    Stake VTT
  unstake --validator <addr> --amount <vtt> --seed <hex>  Unstake VTT

Global: --rpc <url>  (default: http://127.0.0.1:9944)