pot-o-extensions 0.4.0

DeFi, staking, and external-chain extensions for the PoT-O validator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Peer network: local-only and optional VPN mesh for multi-node discovery.

use async_trait::async_trait;
use pot_o_core::TribeResult;
use pot_o_mining::{Challenge, ProofPayload};
use serde::{Deserialize, Serialize};

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

pub type NodeId = String;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PeerInfo {
    pub node_id: NodeId,
    pub address: String,
    pub port: u16,
    pub last_seen: chrono::DateTime<chrono::Utc>,
    pub version: String,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct NetworkState {
    pub peers: Vec<PeerInfo>,
    pub total_nodes: usize,
    pub synced: bool,
}

// ---------------------------------------------------------------------------
// Trait
// ---------------------------------------------------------------------------

/// How validator nodes discover and communicate with each other.
#[async_trait]
pub trait PeerNetwork: Send + Sync {
    fn node_id(&self) -> &NodeId;
    async fn discover_peers(&self) -> TribeResult<Vec<PeerInfo>>;
    async fn broadcast_challenge(&self, challenge: &Challenge) -> TribeResult<()>;
    async fn relay_proof(&self, proof: &ProofPayload) -> TribeResult<()>;
    async fn sync_state(&self) -> TribeResult<NetworkState>;
}

// ---------------------------------------------------------------------------
// LocalOnlyNetwork (implemented now)
// ---------------------------------------------------------------------------

pub struct LocalOnlyNetwork {
    node_id: NodeId,
}

impl LocalOnlyNetwork {
    pub fn new() -> Self {
        Self {
            node_id: uuid::Uuid::new_v4().to_string(),
        }
    }
}

impl Default for LocalOnlyNetwork {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait]
impl PeerNetwork for LocalOnlyNetwork {
    fn node_id(&self) -> &NodeId {
        &self.node_id
    }

    async fn discover_peers(&self) -> TribeResult<Vec<PeerInfo>> {
        Ok(vec![]) // No peers in local-only mode
    }

    async fn broadcast_challenge(&self, _challenge: &Challenge) -> TribeResult<()> {
        Ok(()) // No-op
    }

    async fn relay_proof(&self, _proof: &ProofPayload) -> TribeResult<()> {
        Ok(()) // No-op
    }

    async fn sync_state(&self) -> TribeResult<NetworkState> {
        Ok(NetworkState {
            peers: vec![],
            total_nodes: 1,
            synced: true,
        })
    }
}

// ---------------------------------------------------------------------------
// VpnMeshNetwork (stubbed for future WireGuard + mDNS)
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VpnMeshConfig {
    pub wireguard_interface: String,
    pub peer_addresses: Vec<String>,
    pub mdns_enabled: bool,
    pub gossip_port: u16,
}

pub struct VpnMeshNetwork {
    pub node_id: NodeId,
    pub config: VpnMeshConfig,
}

#[async_trait]
impl PeerNetwork for VpnMeshNetwork {
    fn node_id(&self) -> &NodeId {
        &self.node_id
    }

    async fn discover_peers(&self) -> TribeResult<Vec<PeerInfo>> {
        todo!("VPN mesh peer discovery via WireGuard + mDNS not yet implemented")
    }

    async fn broadcast_challenge(&self, _challenge: &Challenge) -> TribeResult<()> {
        todo!("VPN mesh challenge broadcast not yet implemented")
    }

    async fn relay_proof(&self, _proof: &ProofPayload) -> TribeResult<()> {
        todo!("VPN mesh proof relay not yet implemented")
    }

    async fn sync_state(&self) -> TribeResult<NetworkState> {
        todo!("VPN mesh state sync not yet implemented")
    }
}