TOS System Architecture

+----------------------------------------------------------+
|                    Smart Contracts                        |
|                    (TAKO Runtime)                         |
+-----------------------------+----------------------------+
                              | syscalls
+-----------------------------v----------------------------+
|                   Native Features                        |
|  +--------+  +--------+  +--------+  +----------------+  |
|  |Referral|  |  VRF   |  |Privacy |  |Scheduled Tasks |  |
|  | System |  | Random |  | (UNO)  |  |                |  |
|  +--------+  +--------+  +--------+  +----------------+  |
+-----------------------------+----------------------------+
                              |
+-----------------------------v----------------------------+
|                 Consensus Layer                          |
|  +--------+  +--------+  +--------+  +----------------+  |
|  |GHOSTDAG|  |  BPS   |  |Finality|  |  Reachability  |  |
|  |Protocol|  | System |  | Depth  |  |    Index       |  |
|  +--------+  +--------+  +--------+  +----------------+  |
+-----------------------------+----------------------------+
                              |
+-----------------------------v----------------------------+
|                  Storage Layer                           |
|  +--------+  +--------+  +--------+  +----------------+  |
|  |RocksDB |  | Cache  |  |Snapshot|  |  DAG Order     |  |
|  |Backend |  | System |  | System |  |  (Topoheight)  |  |
|  +--------+  +--------+  +--------+  +----------------+  |
+----------------------------------------------------------+

Genesis -> Block1 -> Block2 -> Block3
   0         1         2         3

Every block gets sequential topoheight, no gaps.

         Block1 (work=1000)    Block2 (work=1000)
                 \                  /
                  Block3 (merges both)
                  work = max(1000, 1000) + 1000 = 2000

Given:
  D (network delay): 2 seconds
  lambda (block rate): 1 BPS
  delta (security tolerance): 0.001 (0.1%)

Formula:
  x = 2 * D * lambda = 2 * 2 * 1 = 4.0
  K = minimum where P(anticone > K) < delta

Result: K = 10 (rounded from theoretical 9.7)

Block A --+
          +-- Block C (merges both)
Block B --+

If Block C has more than K=10 parallel blocks
that are not ancestors of each other, those
blocks are marked as "red" (orphaned).

pub struct Bps<const BPS: u64>;
 
pub type OneBps = Bps<1>;   // TOS standard
pub type TenBps = Bps<10>;  // Higher throughput
 
impl<const BPS: u64> Bps<BPS> {
    /// Target block time in milliseconds
    pub const fn target_time_per_block() -> u64 {
        1000 / BPS  // 1 BPS = 1000ms
    }
 
    /// GHOSTDAG K parameter
    pub const fn ghostdag_k() -> u64 {
        match BPS {
            1 => 10,    // TOS
            10 => 124,  // Kaspa-style
            _ => panic!("Unsupported BPS"),
        }
    }
 
    /// Finality depth (constant ~100 seconds)
    pub const fn finality_depth() -> u64 {
        BPS * 100
    }
}

Time    Status                  Security
-------------------------------------------
0s      Mempool (unconfirmed)   None
3s      1 confirmation          ~50% attack risk
10s     10 confirmations        ~1% attack risk
30s     30 confirmations        ~0.01% attack risk
60s     60 confirmations        ~0.0001% attack risk
100s    100 confirmations       < 10^-18 attack risk
        FINAL

/// Read-only verification state
#[async_trait]
pub trait BlockchainVerificationState<'a, E> {
    async fn get_sender_balance(...) -> Result<&mut Ciphertext, E>;
    async fn get_receiver_balance(...) -> Result<&mut Ciphertext, E>;
    async fn get_account_nonce(...) -> Result<Nonce, E>;
    async fn update_account_nonce(...) -> Result<(), E>;
}
 
/// Write state for applying transactions
#[async_trait]
pub trait BlockchainApplyState<'a, S, E>:
    BlockchainVerificationState<'a, E>
{
    async fn add_burned_coins(&mut self, amount: u64) -> Result<(), E>;
    async fn add_gas_fee(&mut self, amount: u64) -> Result<(), E>;
    async fn set_contract_outputs(...) -> Result<(), E>;
}

Block arrives:
  |
  v
+------------------+
| Header Validation|  (GHOSTDAG, reachability)
+--------+---------+
         |
         v
+------------------+
| Create ChainState|  (Virtual snapshot)
+--------+---------+
         |
         v
+------------------+
| Verify TX 1...N  |  (Check balances, ZK proofs)
+--------+---------+
         |
         v
+------------------+
| ApplicableState  |  (Prepare commits)
+--------+---------+
         |
         v
+------------------+
| Commit to RocksDB|  (Atomic write)
+------------------+

Tier 1: Exclusive Nodes
        Mandatory connection, highest priority

Tier 2: Priority Nodes (priority=true)
        Seed nodes, manually added, bypass penalties

Tier 3: Whitelist
        Trusted via RPC, no fail count increment

Tier 4: Graylist
        Unknown peers, subject to fail tracking

Tier 5: Blacklist
        Banned, never connect

1. exclusive_nodes (if configured)
       |
2. Whitelist peers from peerlist
       |
3. Graylist peers (backup)
       |
4. Seed nodes (fallback)

if self.allow_priority_blocks && peer.is_priority() {
    // Propagate block immediately before verification
    spawn_task("broadcast-priority-block", async {
        self.broadcast_block(&block_hash).await;
    });
}

Blocks:
  block:<hash>           -> Block data
  block_header:<hash>    -> BlockHeader

DAG:
  ghostdag:<hash>        -> GhostdagData
  reachability:<hash>    -> ReachabilityData
  dag_order:<topo>       -> Hash (topoheight index)

State:
  account:<pubkey>       -> Account data
  balance:<key>          -> Ciphertext
  nonce:<pubkey>         -> u64

Indexes:
  tx_block:<tx_hash>     -> Hash (block containing tx)
  tips:current           -> Vec<Hash>

pub struct StorageCache {
    /// Chain state cache
    pub chain: ChainCache,
 
    /// Object caches (blocks, transactions)
    pub objects: ObjectsCache,
 
    /// Counter caches for fast counts
    pub counters: CounterCache,
}
 
pub struct ChainCache {
    pub tips: Option<Vec<Hash>>,
    pub top_topoheight: Option<u64>,
    pub top_height: Option<u64>,
}

+----------------------+
|   Smart Contract     |
|   (WASM Module)      |
+----------+-----------+
           | syscall
+----------v-----------+
|    TAKO Runtime      |
|  +-------+-------+   |
|  |Syscall|Memory |   |
|  |Handler|Manager|   |
|  +-------+-------+   |
+----------+-----------+
           |
+----------v-----------+
|   Native Features    |
|  (Referral, VRF...)  |
+----------------------+