weave-sdk · replication

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ReplicationMessage {
    /// Anonymous resource preflight. Private repositories attach a one-time
    /// proof derived from the current repository epoch and Noise channel.
    /// No DID or authentication public key is disclosed at this stage.
    #[serde(rename = "hello")]
    Hello {
        version: u8,
        discovery_key: Vec<u8>,
        live: bool,
        #[serde(default)]
        access_proof: Vec<u8>,
    },

    /// Initial handshake: exchange public keys and discovery key.
    #[serde(rename = "handshake")]
    Handshake {
        version: u8,
        public_key: Vec<u8>,
        discovery_key: Vec<u8>,
        live: bool,
        #[serde(default)]
        peer_did: Option<String>,
        #[serde(default)]
        auth_public_key: Option<Vec<u8>>,
        #[serde(default)]
        auth_signature: Option<Vec<u8>>,
    },

    /// Announce available block range.
    #[serde(rename = "have")]
    Have { start: u64, length: u64 },

    /// Request the remote to announce its availability from `start`.
    #[serde(rename = "want")]
    Want { start: u64 },

    /// Request a range of blocks.
    #[serde(rename = "request")]
    Request { start: u64, end: u64 },

    /// Deliver a block.
    #[serde(rename = "data")]
    Data {
        seq: u64,
        #[serde(with = "base64_bytes")]
        data: Vec<u8>,
        header: WireHeader,
    },

    /// Cancel a previous request.
    #[serde(rename = "cancel")]
    Cancel { start: u64, end: u64 },

    /// Indicate we do not have a block.
    #[serde(rename = "unhave")]
    Unhave { seq: u64 },

    /// Synchronization complete (non-live sessions).
    #[serde(rename = "sync")]
    Sync,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WireHeader {
pub version: u8,
pub seq: u64,
pub length: u64,
pub byte_offset: u64,
#[serde(default, with = "base64_bytes")]
pub prev_hash: Vec<u8>,
pub writer_public_key: Vec<u8>,
pub timestamp: u64,
#[serde(with = "base64_bytes")]
pub signature: Vec<u8>
}

pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: Serializer,;

pub fn deserialize<'de, D>(deserializer: D) -> std::result::Result<Vec<u8>, D::Error>
    where
        D: Deserializer<'de>,;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionState {
    /// Handshake in progress.
    Connecting,
    /// Actively replicating.
    Active,
    /// Paused (e.g., waiting for data).
    Idle,
    /// Session closed.
    Closed,
}

#[derive(Debug, Clone, Default)]
pub struct ReplicationStats {
pub blocks_uploaded: u64,
pub blocks_downloaded: u64,
pub bytes_uploaded: u64,
pub bytes_downloaded: u64
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AuthenticatedPeer {
/// Claimed and verified DID.

pub did: String,
/// Ed25519 authentication public key used to verify the handshake.

pub auth_public_key: [u8; 32]
}

pub type ReplicationAdmissionPolicy =
    Arc<dyn Fn(&AuthenticatedPeer, &[u8; 32]) -> bool + Send + Sync>;

#[derive(Clone)]
pub struct ReplicationAccessProof {

}

pub fn new(
        generator: impl Fn(&[u8; 32], &[u8; 32], bool) -> Result<[u8; 32]> + Send + Sync + 'static,
        verifier: impl Fn(&[u8; 32], &[u8; 32], bool, &[u8; 32]) -> bool + Send + Sync + 'static,
    ) -> Self;

pub fn dogfood_shared_secret(secret: &[u8]) -> Self;

pub fn dogfood_allow_authenticated_peers() -> ReplicationAdmissionPolicy;

pub type IncomingStrandResolver =
    Arc<dyn Fn([u8; 32]) -> Option<(String, Arc<tokio::sync::RwLock<Strand>>)> + Send + Sync>;

#[derive(Clone)]
pub struct LocusReplicationTargets {
/// Metadata B-tree strand.

pub meta_strand: Arc<RwLock<Strand>>,
/// Blob metadata strand.

pub blob_meta_strand: Arc<RwLock<Strand>>,
/// Blob payload strand.

pub blob_data_strand: Arc<RwLock<Strand>>,
/// Keep the sessions open for live updates.

pub live: bool
}

pub fn new(
        meta_strand: Arc<RwLock<Strand>>,
        blob_meta_strand: Arc<RwLock<Strand>>,
        blob_data_strand: Arc<RwLock<Strand>>,
        live: bool,
    ) -> Self;

#[derive(Debug)]
pub struct ReplicationSession {
/// The remote peer's DID.

pub peer_did: String,
/// Remote peer's public key.

pub peer_public_key: [u8; 32],
/// Names of strands being replicated.

pub strands: Vec<String>,
/// Session state.

pub state: SessionState,
/// Accumulated stats.

pub stats: ReplicationStats
}

pub struct ReplicationManager {

}

pub fn new() -> Self;

pub fn with_identity(identity: WeaveIdentity) -> Self;

pub async fn set_private_controls(
        &self,
        proof: Option<ReplicationAccessProof>,
        policy: Option<ReplicationAdmissionPolicy>,
    ) -> Result<()>;

pub async fn private_controls_enabled(&self) -> Result<bool>;

pub async fn private_discovery_authenticator(
        &self,
        discovery_key: &[u8; 32],
        payload_digest: &[u8; 32],
    ) -> Result<Option<[u8; 32]>>;

pub async fn verify_private_discovery_authenticator(
        &self,
        discovery_key: &[u8; 32],
        payload_digest: &[u8; 32],
        authenticator: &[u8; 32],
    ) -> Result<bool>;

pub async fn connect_and_replicate(
        &self,
        _peer_did: &str,
        _addr: SocketAddr,
        _strand_name: &str,
        _strand: Arc<tokio::sync::RwLock<Strand>>,
        _live: bool,
    ) -> Result<()>;

pub async fn connect_and_replicate_pinned(
        &self,
        peer_did: &str,
        expected_peer_auth_key: [u8; 32],
        addr: SocketAddr,
        strand_name: &str,
        strand: Arc<tokio::sync::RwLock<Strand>>,
        live: bool,
    ) -> Result<()>;

pub async fn handle_incoming_replication(
        &self,
        peer_did: &str,
        stream: TcpStream,
        strand_name: &str,
        strand: Arc<tokio::sync::RwLock<Strand>>,
        live: bool,
    ) -> Result<()>;

pub async fn handle_incoming_replication_dynamic(
        &self,
        peer_did: &str,
        stream: TcpStream,
        live: bool,
        resolver: IncomingStrandResolver,
    ) -> Result<()>;

pub async fn listen_for_replication(
        &self,
        bind_addr: SocketAddr,
        strand: Arc<tokio::sync::RwLock<Strand>>,
        live: bool,
    ) -> Result<(SocketAddr, JoinHandle<()>)>;

pub async fn stop_replication(&self, peer_did: &str) -> Result<()>;

pub async fn sessions(&self) -> Vec<(String, SessionState)>;

pub async fn is_session_live(&self, peer_did: &str) -> bool;

pub async fn stats(&self, peer_did: &str) -> ReplicationStats;

pub async fn replicate_lens(
        &self,
        peer_did: &str,
        peer_auth_public_key: [u8; 32],
        addr: SocketAddr,
        lens_name: &str,
        lens_strand: Arc<tokio::sync::RwLock<Strand>>,
        live: bool,
    ) -> Result<()>;

pub async fn replicate_locus(
        &self,
        peer_did: &str,
        peer_auth_public_key: [u8; 32],
        addr: SocketAddr,
        locus_name: &str,
        targets: LocusReplicationTargets,
    ) -> Result<u32>;

pub async fn replicate_nexus(
        &self,
        peer_did: &str,
        peer_auth_public_key: [u8; 32],
        addr: SocketAddr,
        nexus_name: &str,
        input_strands: Vec<(String, Arc<tokio::sync::RwLock<Strand>>)>,
        live: bool,
    ) -> Result<u32>;