Cached channel derivations: channel name → derivation entry.
The inbound rfed.delivery destination, once listen is called.
Callback invoked for each decoded fanout message.
Channel names subscribed as raw (non-LXMF). Incoming fanout for these is decoded via unwrapRawChannelMessage instead of the LXMF path.
Cached advertised stamp costs: hex(channelHash) → cost (or null).
Removes ALL notify relay registrations for this subscriber (every channel
rfed.notify destination (SPEC §9.1).Starts listening for live fanout deliveries on the local rfed.delivery
destination and announces it so the node can route to it.
Each incoming fanout payload [ channel_hash ‖ inner_blob ] is matched to
a subscribed channel and EC-decrypted. Channels subscribed via
subscribeRaw yield a "raw" decode (arbitrary payload); all others
yield an "lxmf" decode (a verified Message). The kind field on
the decoded object discriminates the two.
the rfed.delivery destination hash.
Publishes a message to a channel (fire-and-forget SEND).
Wraps the LXMF message with the Phase-0 codec using the cached stamp cost
(from the last subscribe) and sends it as an encrypted DATA packet
to the node's rfed.channel.publish destination. If no stamp cost is
cached, the message is sent without a stamp.
MTU limit: The publish endpoint is fire-and-forget and does not use links. Payloads must fit within the network MTU (typically ~500 bytes after header and encryption overhead). Oversized payloads will be dropped by the node. For larger transfers, use a direct link outside of RFed.
SEND is fire-and-forget — there is no acceptance response. Call subscribe again to refresh the stamp cost if publishes seem to be dropped (the node silently rejects under-stamped blobs).
Publishes a raw (non-LXMF) payload to a channel (fire-and-forget SEND).
Wraps the payload with the RTID prelude (magic + sender public key) and EC-encrypts it to the channel identity — no LXMF serialisation. Use this for self-describing, self-authenticating payloads (e.g. a Dacar delta) that do not need LXMF framing and benefit from the saved MTU. Receivers must decode with unwrapRawChannelMessage, i.e. they subscribed via subscribeRaw.
The cached stamp cost (from the last subscribe) is honoured. See publish for the MTU and fire-and-forget caveats.
Raw application payload.
Pulls one page of pending blobs for a channel from the node's deferred queue (user-initiated paging).
Opens an identified link to rfed.channel.pull and sends /rfed/pull with
the channel hash. The response is [[[channel_hash, blob], …], more_pending]; repeat while morePending is true to drain the queue.
Registers a notify relay for wake-ups (SPEC §9.1). When a blob is deferred
for this subscriber on the given channel (or globally if channelName is
omitted), the node sends a §9.3 wake packet to the relay.
relayHash is the 32-char lowercase hex destination hash of the relay's
rfed.notify destination.
OptionalchannelName: string
Optional channel scope; omit for LXMF/global.
true if the node accepted the registration.
Subscribes to a channel on a node and caches the advertised PoW stamp cost.
Opens a link to the node's rfed.channel.subscribe destination, identifies
as the subscriber, and sends /rfed/subscribe with the signed channel
hash. Re-subscribing refreshes the cached stamp cost — do this at least once
per session and after any publish rejection.
Any rfed.* destination hash of the node
(they all share one identity).
Subscribes to a channel that carries raw (non-LXMF) payloads and marks it locally so incoming fanout is decoded via unwrapRawChannelMessage instead of the LXMF path.
The wire protocol is identical to subscribe — the node never
inspects the inner_blob (SPEC §3: it is treated opaquely); only this
client's local decode behaviour changes. Use this for channels whose
senders publish with publishRaw (or any RFed-compatible raw
wrapper) — e.g. self-describing, self-signed application payloads that
do not need LXMF framing.
Removes a subscription. Same payload shape as subscribe.
A rfed channel client.