#moonquic

// A protected Initial packet, from the connection ID up (RFC 9001 §5.2–§5.4).
let dcid : Bytes = b"\x83\x94\xc8\xf0\x3e\x51\x57\x08"
let (client, server) = @crypto.initial(dcid[:])
let wire = @conn.seal_long(
  @packet.Kind::Initial, 1U, dcid, b"\xaa\xbb\xcc\xdd", 1L, 4,
  @packet.payload([@frame.Ping]), server,
)

// And back, with the packet number recovered against what this space has seen.
let opened = @conn.recv_long(wire, client, largest=-1L) catch {
  _ => abort("the packet did not open")
}
guard opened is Some((frames, n)) else { abort("the packet did not open") }
assert_eq(n, 1L)
assert_eq(frames, [@frame.Ping])

moon run src/examples/02-frames     moon run src/examples/05-ack        moon run src/examples/08-streams
moon run src/examples/03-params     moon run src/examples/06-flow       moon run src/examples/09-sender
moon run src/examples/04-crypto     moon run src/examples/07-recovery

#Packages

#Serving

let server : @conn.Endpoint[Addr] = @conn.Endpoint::server(
  @conn.Config::default(),
  @tls.Server::new(chain, key, alpn=["h3"]),
  rand=entropy,
)
server.recv(datagram, from, now)
for conn in server.take_busy() {
  for event in conn.take_events() {
    match event {
      Readable(id) => {
        let bytes = conn.read(id)
        conn.write(id, reply(bytes), fin=conn.finished(id))
      }
      _ => ()
    }
  }
}
while server.poll_out(now) is Some((datagram, to)) {
  send(datagram, to)
}

#Connecting

let client = @conn.Client::new(
  @tls.Client::new(roots, alpn=["h3"]),
  "a.example",
  @conn.encode(params),
  rand=entropy,
  dcid=Bytes::make(8, 1),
  scid=Bytes::make(8, 2),
  now,
)
for datagram in client.poll_out(now) { send(datagram, to) }
for datagram in receive() {
  client.recv(datagram, now)
  for answer in client.poll_out(now) { send(answer, to) }
}

client.tick(now)
for datagram in client.poll_out(now) { send(datagram, to) }

#Resuming a connection

client.write(0UL, request, fin=true)
for datagram in client.poll_out(now) { send(datagram, to) }

let kept = client.remembered().unwrap()   // a ticket and the parameters it was issued under
let next = @conn.Client::new(
  @tls.Client::new(roots, alpn=["h3"], sessions=store, early=true),
  "a.example",
  @conn.encode(params),
  rand=entropy,
  dcid=Bytes::make(8, 3),
  scid=Bytes::make(8, 4),
  now,
  resumption=kept,
)

let cfg = @conn.Config::default()
assert_eq(cfg.zero_rtt_data, 0UL)
assert_eq(cfg.zero_rtt_stream_data, 0UL)
// A caller that knows better than the last connection says so; §7.4.1 makes the
// remembered value the ceiling, so a larger override earns a flow-control error.
let small = { ..cfg, zero_rtt_data: 4096UL, zero_rtt_stream_data: 4096UL }
assert_eq(small.zero_rtt_data, 4096UL)

#Several connections on one socket

let endpoint = @conn.ClientEndpoint::new(@conn.Config::default(), rand=entropy)
let id = endpoint.connect(
  @tls.Client::new(roots, alpn=["h3"]),
  "a.example",
  params,
  now,
)
endpoint.recv(datagram, now)
for answer in endpoint.poll_out(now) { send(answer, to) }
endpoint.tick(now)
let client = endpoint.client(id).unwrap()

#Paths

let paths = @conn.Paths::new(local_max=2UL)   // what this end will maintain
paths.on_max_path_id(1UL)                     // what the peer said it would
assert_true(paths.openable(1UL))
assert_false(paths.openable(2UL))             // the peer offered one path, not two
let spare : Bytes = b"\xaa\xbb\xcc\xdd"
paths.bind(1UL, spare)                        // the peer's id for the path
ignore(paths.bind_local(1UL, b"\x01\x02"))    // this end's
assert_eq(paths.path_of(b"\x01\x02"), 1UL)
assert_false(paths.validated(1UL))
ignore(paths.start(1UL, b"\x10\x20\x30\x40\x50\x60\x70\x80"))
assert_true(paths.prove(1UL, b"\x10\x20\x30\x40\x50\x60\x70\x80"))
assert_true(paths.validated(1UL))

let (_, keys) = @crypto.initial(b"\x83\x94\xc8\xf0\x3e\x51\x57\x08")
assert_eq(keys.nonce_at(0UL, 54321L), keys.nonce(54321L))
assert_true(keys.nonce_at(1UL, 54321L) != keys.nonce(54321L))

let status = @frame.PathStatus(path_id=1UL, seq=1UL, available=true)
let wire = @frame.encode(status)
let (back, used) = @frame.decode(wire[:]) catch {
  _ => abort("the frame did not decode")
}
assert_eq(used, wire.length())
assert_eq(back, status)
// PATH_ACK names the path whose packet numbers it settles.
let ack = @frame.PathAck(path_id=1, largest=9UL, delay=0UL, first_range=1UL, ranges=[])
assert_eq(@frame.encode(ack).length(), 4)

#Datagrams

let cfg = { ..@conn.Config::default(), max_datagram_frame_size: 1200UL }
assert_eq(cfg.max_datagram_frame_size, 1200UL)

#Everything the protocol leaves open is a parameter

let dcid : Bytes = b"\x83\x94\xc8\xf0\x3e\x51\x57\x08"
let (initial, _) = @crypto.initial(dcid[:])            // AEAD_AES_128_GCM, RFC 9001 §5.2
let strong = @crypto.Keys::of(initial.key, suite=@crypto.aes256)
let others = @crypto.Keys::of(initial.key, suite=@crypto.chacha20)
assert_eq(strong.iv.length(), 12)
assert_eq(others.iv.length(), 12)

let reno = @recovery.State::new()
let cubic = @recovery.State::new(control=@recovery.Cubic::new())
let bbr = @recovery.State::new(control=@recovery.Bbr::new())
assert_true(reno.window() > 0L)
assert_true(cubic.window() > 0L)
assert_true(bbr.window() > 0L)

#What is not here

#Verification

#Conformance

#License