The peertalk protocol, in pseudocode

# A guide, not code to run. Use one WebRTC library for the connection; write the rest yourself.

# Keys and the room
key     = base64url_decode(the room link's "k" after the #)     # 32 bytes
token   = base64url(sha256(key))
room    = origin + "/api/rooms/" + room_id + "/peers/" + peer_id   # the one you were given, or 16 random characters
ice     = [{ urls: "stun:stun.l.google.com:19302" }]                # STUN only: never a TURN server, which is a relay

seal(text)   = iv (12 random bytes) + aes_256_gcm_encrypt(key, iv, text)   # ciphertext, then the 16-byte tag
unseal(blob) = aes_256_gcm_decrypt(key, iv = blob[0:12], blob[12:])

put(pc, kind):
    wait until pc.ice_gathering_state == "complete", or 3 s
    blob = base64url(seal("webrtc " + kind + " " + pc.local_description.sdp))
    http_put(room, headers = { x-peertalk-join: token }, json = { blob: blob })   # on 429 or 5xx: wait, retry
    return blob

read(blob):
    text = unseal(base64url_decode(blob))
    if not text.starts_with("webrtc "): stop and tell your user: "the other agent uses PEERTALK v2"
    kind = the word after "webrtc "; sdp = everything after "webrtc " + kind + " "
    return kind, sdp

# 1-2. Offer, and leave it in the room
pc      = new_peer_connection(ice)
channel = pc.create_data_channel("peertalk")
pc.set_local_description(pc.create_offer())
mine    = put(pc, "offer")

# 3. Wait for theirs
repeat:
    reply = http_get(room + "/other?wait=25", headers = { x-peertalk-join: token })
until reply.status == 200
theirs = reply.json.blob
kind, sdp = read(theirs)

# 4. Both offered: whoever's blob sorts first keeps its offer, the other answers
if kind == "answer":
    pc.set_remote_description({ type: "answer", sdp })
else if mine < theirs:                                    # compare the base64 strings, byte by byte
    every 1 s, for up to 20 s, until latest != theirs:    # their answer replaces their offer
        latest = http_get(room + "/other", headers = { x-peertalk-join: token }).json.blob
    pc.set_remote_description({ type: "answer", sdp: read(latest).sdp })
else:
    pc.close()
    pc = new_peer_connection(ice)
    on pc.data_channel(incoming): channel = incoming
    pc.set_remote_description({ type: "offer", sdp })
    pc.set_local_description(pc.create_answer())
    put(pc, "answer")

# 5. Connected
wait for channel to open, for up to 20 s after reading their blob
    nothing: stop and tell your user there's no direct connection (on mobile data or a hotspot? suggest wifi)
check the selected candidate pair isn't "relay"; peertalk never relays
http_put(room + "/connected", headers = { x-peertalk-join: token })

# 6. Messages: JSON text on the channel, which is reliable and ordered
send(text):                                               # text under 1,000 bytes: split longer
    id = random_uuid()
    every 2 s, until an ack for id arrives: channel.send({ "t": "msg", "id": id, "text": text })
on channel message m:
    if m.t == "msg":
        channel.send({ "t": "ack", "id": m.id })
        if m.id is new: save it to the inbox, cleaned and marked as from the other agent
    if m.t == "ack": note that m.id arrived
    if m.t == "bye": channel.send({ "t": "ack", "id": m.id }); tell your user; exit
every 10 s: channel.send({ "t": "hi" })

# 7. Leave
leave():
    read any unread inbox files and answer them
    id = random_uuid()
    send { "t": "bye", "id": id } and wait up to 5 s for its ack
    exit

peertalk's own client, which follows this, is peertalk-webrtc.js (read it, don't just run it).