1-Second Transaction Finality

User clicks "Place Bet" → Waits for confirmation → Sees result

Ethereum (12s + multi-block): 30+ seconds wait, poor UX
BSC (3s + multi-block):       15+ seconds wait, acceptable
TOS (1s single-block):        1 second wait, excellent UX

User invests → Uplines receive reward notification

TOS 1-second finality: Instant feedback, no perceived wait

Traditional Blockchain:
Block 1 → Block 2 → Block 3 → Block 4
          (orphan) ↗

TOS BlockDAG:
       ↗ Block 2a ↘
Block 1             Block 3 → Block 4
       ↘ Block 2b ↗
(All blocks included, no orphans)

1-Second Block (1000ms):

T+0ms:     Leader collects transactions
T+400ms:   Leader packages block
T+500ms:   Broadcast to validators
T+800ms:   Collect 2/3 signatures
T+950ms:   Block confirmed
T+1000ms:  Next block begins

pub mod ConsensusParams {
    /// Block time: 1 second
    pub const BLOCK_TIME_MS: u64 = 1000;
 
    /// Finality: 1 block (immediate)
    pub const FINALITY_BLOCKS: u64 = 1;
 
    /// Target TPS: 10,000+
    pub const TARGET_TPS: u64 = 10000;
 
    /// Block size limit: 10MB
    pub const MAX_BLOCK_SIZE: u64 = 10 * 1024 * 1024;
 
    /// Block gas limit
    pub const MAX_BLOCK_GAS: u64 = 100_000_000;
 
    /// Validator count
    pub const VALIDATOR_COUNT: u64 = 21;
 
    /// Confirmation threshold (2/3 + 1)
    pub const CONFIRMATION_THRESHOLD: u64 = 15;
}

pub enum TransactionStatus {
    /// In mempool, waiting to be included
    Pending,
 
    /// In a block - this IS final on TOS
    Included {
        block_number: u64,
        block_hash: Hash,
    },
 
    /// Alias for Included on TOS (1-block finality)
    Confirmed {
        block_number: u64,
        block_hash: Hash,
    },
}
 
// On TOS: Included == Confirmed (single-block finality)

/// Transactions with no dependencies execute in parallel
fn parallel_execute(txs: Vec<Transaction>) -> Vec<Receipt> {
    // Analyze transaction dependencies
    let dependency_graph = analyze_dependencies(&txs);
 
    // Sort into independent layers
    let layers = topological_sort(dependency_graph);
 
    // Execute each layer in parallel
    for layer in layers {
        layer.par_iter()
            .map(|tx| execute(tx))
            .collect();
    }
}

// Send transaction
const txHash = await wallet.sendTransaction(tx);
 
// Wait for confirmation (typically ≤1 second)
const receipt = await provider.waitForTransaction(txHash);
 
// Transaction is now FINAL
if (receipt.status === 'confirmed') {
    updateUI(); // Safe to update immediately
}

// Subscribe to transaction confirmation
ws.subscribe('tx_confirmed', txHash, (receipt) => {
    console.log('Transaction confirmed:', receipt);
    // Typically received within 1 second of submission
});

// For applications that need explicit confirmation
async function waitForConfirmation(txHash: string): Promise<Receipt> {
    while (true) {
        const receipt = await provider.getTransactionReceipt(txHash);
        if (receipt) {
            return receipt; // On TOS, receipt means finality
        }
        await sleep(100); // Check every 100ms
    }
}

/// Handle leader failure
fn handle_leader_timeout() {
    // 2-second timeout (2 block times)
    if time_since_last_block() > BLOCK_TIME_MS * 2 {
        // Skip current leader
        current_leader = next_leader();
 
        // Resume block production
        start_new_block();
    }
}

Partition Scenario:

Partition A (12 validators): Continues producing blocks
Partition B (9 validators):  Cannot reach consensus, pauses

After Recovery:
- Partition B syncs to Partition A's chain
- Automatic catch-up, no manual intervention
- Network resumes normal operation

pub struct ChainMetrics {
    /// Current transactions per second
    pub current_tps: u64,
 
    /// Average block time (ms)
    pub avg_block_time_ms: u64,
 
    /// Average finality time (ms)
    pub avg_finality_time_ms: u64,
 
    /// Pending transaction count
    pub pending_tx_count: u64,
 
    /// Active validator count
    pub active_validators: u64,
}