weave-dht · route_v1

pub const ROUTE_SET_VERSION: u64;

pub const MAX_ROUTE_SET_BYTES: usize;

pub const MAX_PRIVATE_INNER_ROUTE_SET_BYTES: usize;

pub const MAX_ROUTE_CANDIDATES: usize;

pub const MAX_SUPPORTED_PROTOCOLS: usize;

pub const MAX_TRANSPORT_PEER_ID_BYTES: usize;

pub const MAX_MULTIADDR_BYTES: usize;

pub const MAX_OPERATOR_DOMAIN_BYTES: usize;

pub const MAX_PROTOCOL_ID_BYTES: usize;

pub const MAX_ROUTE_LIFETIME_MS: u64;

pub const ALLOCATED_FEATURES_MASK: u64;

pub const ALLOCATED_SERVICE_ROLES_MASK: u16;

pub const ROUTE_SIGNATURE_DOMAIN: &[u8];

pub const ROUTE_SET_DIGEST_DOMAIN: &[u8];

#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
pub enum Protocol1CodecError {
    #[error("malformed Protocol 1.0 data")]
    Malformed,
    #[error("noncanonical Protocol 1.0 data")]
    NonCanonical,
    #[error("unknown or missing fixed-schema field")]
    UnknownOrMissingField,
    #[error("Protocol 1.0 resource bound exceeded")]
    ResourceLimitExceeded,
    #[error("route signature or transport identity is invalid")]
    TransportAuthenticationFailed,
    #[error("route record is expired, future-issued, or has an invalid lifetime")]
    InvalidLifetime,
    #[error("route sequence is stale, rolled back, or equivocates")]
    Rollback,
    #[error("route contains an unsafe address")]
    AddressPolicyDenied,
    #[error("route requires an unsupported Protocol 1.0 feature")]
    UnsupportedCriticalFeature,
    #[error("private discovery rejected")]
    PrivateDiscoveryRejected,
}

pub fn public_error_family(self) -> &'static str;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum EndpointProfile {
    NativeFull = 0,
    NativeRestricted = 1,
    PortableMacosAlpha = 2,
    OfflineLan = 3,
    BrowserReserved = 4,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum PrivacyProfile {
    Public = 0,
    PrivateStandard = 1,
    PrivateMetadata = 2,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum RouteTransport {
    TcpNoiseYamux = 0,
    QuicV1 = 1,
    CircuitRelayV2 = 2,
    Tcp443Relay = 3,
    ExplicitOverlay = 4,
    WebTransportReserved = 5,
    WebRtcReserved = 6,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum CandidateScope {
    Public = 0,
    AuthenticatedLan = 1,
    ObservedPublic = 2,
    VerifiedMapping = 3,
    ExplicitOverlay = 4,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DirectCandidateV1 {
pub multiaddr: Vec<u8>,
pub transport: RouteTransport,
pub scope: CandidateScope,
pub expires_at_ms: u64,
pub required_features: u64
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RelayCandidateV1 {
pub relay_peer_id: Vec<u8>,
pub destination_multiaddr: Vec<u8>,
pub transport: RouteTransport,
pub reservation_expires_at_ms: u64,
pub operator_domain: Option<String>,
pub relay_ad_digest: [u8; 32]
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SupportedProtocolV1 {
pub protocol_id: String,
pub supported_features: u64,
pub required_features: u64
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PeerRouteSetUnsignedV1 {
pub transport_peer_id: Vec<u8>,
pub route_generation: u64,
pub sequence: u64,
pub issued_at_ms: u64,
pub expires_at_ms: u64,
pub direct_candidates: Vec<DirectCandidateV1>,
pub relay_candidates: Vec<RelayCandidateV1>,
pub supported_protocols: Vec<SupportedProtocolV1>,
pub endpoint_profile: EndpointProfile,
pub service_roles: u16,
pub privacy_profile: PrivacyProfile,
pub critical_features: u64
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PeerRouteSetV1 {
pub unsigned: PeerRouteSetUnsignedV1,
pub signature: [u8; 64]
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct RouteSequence {
pub route_generation: u64,
pub sequence: u64
}

#[derive(Debug, Clone, Default)]
pub struct ProtocolRegistryV1 {

}

pub fn empty() -> Self;

pub fn with_application_major(
        mut self,
        name: &str,
        major: u64,
    ) -> Result<Self, Protocol1CodecError>;

#[derive(Debug, Clone)]
pub struct RouteValidationContext {

}

pub fn alpha(now_ms: u64) -> Self;

pub fn try_new(
        now_ms: u64,
        maximum_future_skew_ms: u64,
        last_accepted: Option<RouteSequence>,
        supported_features: u64,
        protocol_registry: ProtocolRegistryV1,
    ) -> Result<Self, Protocol1CodecError>;

pub fn sign(
        unsigned: PeerRouteSetUnsignedV1,
        identity: &libp2p::identity::Keypair,
        context: &RouteValidationContext,
    ) -> Result<Self, Protocol1CodecError>;

pub fn encode(&self) -> Result<Vec<u8>, Protocol1CodecError>;

pub fn decode_and_validate(
        bytes: &[u8],
        context: &RouteValidationContext,
    ) -> Result<Self, Protocol1CodecError>;

pub fn validate(&self, context: &RouteValidationContext) -> Result<(), Protocol1CodecError>;

pub fn digest(&self) -> Result<[u8; 32], Protocol1CodecError>;

pub fn encode(&self) -> Result<Vec<u8>, Protocol1CodecError>;