qualia_core_db/net/peer/fabric/
lease_protocol.rs1use super::kernel::FabricError;
4use super::lease::{CustodyLease, RelayLease};
5use super::wire::{decode_custody, decode_relay_lease, encode_relay_lease};
6use crate::net::peer::connectivity::policy::Disclosure;
7
8pub fn apply_relay_lease(bytes: &[u8], disclosure: Disclosure) -> Result<RelayLease, FabricError> {
10 let mut lease = decode_relay_lease(bytes)?;
11 if !matches!(disclosure, Disclosure::DirectPermitted) {
12 lease.export_observations = false;
13 }
14 Ok(lease)
15}
16
17pub fn custody_cannot_forward(bytes: &[u8]) -> Result<CustodyLease, FabricError> {
19 decode_custody(bytes).map_err(FabricError::from)
20}
21
22pub fn charge_lease(lease: &mut RelayLease, n: u64, now_ms: u64) -> Result<(), FabricError> {
24 lease.charge(n, now_ms).map_err(|_| FabricError::LeaseDead)
25}
26
27pub fn encode_forced_relay_only(lease: &RelayLease, out: &mut [u8]) -> Result<usize, FabricError> {
29 let mut copy = *lease;
30 copy.export_observations = false;
31 encode_relay_lease(©, out).map_err(FabricError::from)
32}
33
34#[cfg(test)]
35mod tests {
36 use super::*;
37 use crate::net::peer::fabric::wire::encode_relay_lease;
38
39 #[test]
40 fn relay_only_clears_export_bit() {
41 let l = RelayLease::grant(1, 9, [1u8; 32], [2u8; 32], 20, 100, 1, true);
42 let mut buf = [0u8; 256];
43 let n = encode_relay_lease(&l, &mut buf).unwrap();
44 let got = apply_relay_lease(&buf[..n], Disclosure::ApprovedRelaysOnly).unwrap();
45 assert!(!got.export_observations);
46 let open = apply_relay_lease(&buf[..n], Disclosure::DirectPermitted).unwrap();
47 assert!(open.export_observations);
48 let mut live = got;
49 charge_lease(&mut live, 8, 10).unwrap();
50 assert!(charge_lease(&mut live, 20, 10).is_err());
51 live.expiry_ms = 0;
52 assert!(charge_lease(&mut live, 1, 10).is_err());
53 }
54
55 #[test]
56 fn custody_is_not_a_forwarding_lease() {
57 let c = CustodyLease::grant(4, 1, 50, 2);
58 let mut buf = [0u8; 256];
59 let n = super::super::wire::encode_custody(&c, &mut buf).unwrap();
60 let back = custody_cannot_forward(&buf[..n]).unwrap();
61 assert_eq!(back.max_objects, 2);
62 assert!(encode_forced_relay_only(
63 &RelayLease::grant(1, 1, [1u8; 32], [2u8; 32], 8, 9, 1, true),
64 &mut buf
65 )
66 .is_ok());
67 }
68
69 #[cfg(not(target_arch = "wasm32"))]
70 #[test]
71 fn two_local_peers_exchange_under_cscp_lease() {
72 use std::net::UdpSocket;
73
74 use crate::net::peer::fabric::relay::{decode_payload, encode, BoundUdpRelay};
75
76 let a = [1u8; 32];
77 let b = [2u8; 32];
78 let mut wire = [0u8; 256];
79 let n = encode_forced_relay_only(
80 &RelayLease::grant(11, 1, a, b, 64, 10_000, 1, true),
81 &mut wire,
82 )
83 .unwrap();
84 let lease = apply_relay_lease(&wire[..n], Disclosure::ApprovedRelaysOnly).unwrap();
85 assert!(!lease.export_observations);
86 let mut relay = BoundUdpRelay::bind(lease).unwrap();
87 let addr = relay.addr().unwrap();
88 let sa = UdpSocket::bind("127.0.0.1:0").unwrap();
89 let sb = UdpSocket::bind("127.0.0.1:0").unwrap();
90 sa.set_read_timeout(Some(std::time::Duration::from_millis(250)))
91 .unwrap();
92 sb.set_read_timeout(Some(std::time::Duration::from_millis(250)))
93 .unwrap();
94 let mut pkt = [0u8; 64];
95 let na = encode(&relay.lease, &a, b"ping", &mut pkt).unwrap();
96 sa.send_to(&pkt[..na], addr).unwrap();
97 assert_eq!(relay.forward_once(10).unwrap(), 0);
98 let nb = encode(&relay.lease, &b, b"pong", &mut pkt).unwrap();
99 sb.send_to(&pkt[..nb], addr).unwrap();
100 assert_eq!(relay.forward_once(10).unwrap(), 4);
101 let mut got = [0u8; 64];
102 let (n, _) = sa.recv_from(&mut got).unwrap();
103 assert_eq!(decode_payload(&got[..n]).unwrap(), b"pong");
104 assert_eq!(relay.forwarded, 4);
105 }
106}