Class RFedNode

constructor

• new RFedNode(opts: RFedNodeOptions): RFedNode

  Parameters

  • opts: RFedNodeOptions

  Returns RFedNode

_announceListener

_nodeDest

_notifyDest

_notifyRegisterDest

_notifyUnregisterDest

_publishDest

_pullDest

_rfedNodeNameHash

_started

_subscribeDest

_unsubscribeDest

blobStore

blobTtlSecs

deferred

deferredQueueLimit

deferredTtlSecs

fedSync

identity

name

notifyRegistry

ownerOfflineSecs

policyFor

presenceTtlSec

primaryNode

pullPageSize

rns

secondaryNodes

stampCost

stampFlexibility

subscriptions

transferLimitBytes

trustedBackupPeers

nodeHash

• get nodeHash(): Uint8Array<ArrayBufferLike> | null

  The rfed.node destination hash (the canonical node identifier).

  Returns Uint8Array<ArrayBufferLike> | null

_dispatchNotify

• _dispatchNotify(
      reg: { relayHash: string },
      parts: {
          channel?: Uint8Array<ArrayBufferLike> | null;
          receiver: Uint8Array;
          sender?: Uint8Array<ArrayBufferLike> | null;
      },
  ): Promise<void>

  Sends a §9.3 notify wake packet to a registered relay's rfed.notify destination. Fire-and-forget: failures are logged and swallowed (the subscriber still gets the blob via deferred pull / live fanout later). The relay identity must be recallable (it was remembered at registration).

  Parameters

  • reg: { relayHash: string }
  • parts: {
        channel?: Uint8Array<ArrayBufferLike> | null;
        receiver: Uint8Array;
        sender?: Uint8Array<ArrayBufferLike> | null;
    }

  Returns Promise<void>

_drainDeferredFor

• _drainDeferredFor(
      sub: { identity: Identity | null; subscriberHash: Uint8Array },
  ): Promise<void>

  Live-delivers everything queued for a subscriber (FIFO), then the bucket is empty for future /rfed/pull / fanout. Backup entries have no identity and are pull-served, so a null identity here is a no-op.

  Parameters

  • sub: { identity: Identity | null; subscriberHash: Uint8Array }

  Returns Promise<void>

_fanout

• _fanout(
      channelHash: Uint8Array<ArrayBufferLike>,
      innerBlob: Uint8Array<ArrayBufferLike>,
  ): Promise<void>

  Fans a blob out to every subscriber of channelHash. Present subscribers (their rfed.delivery announced within the TTL) receive it immediately; absent subscribers get it enqueued in the deferred queue.

  Parameters

  • channelHash: Uint8Array<ArrayBufferLike>
  • innerBlob: Uint8Array<ArrayBufferLike>

  Returns Promise<void>

_handleBackupPush

• _handleBackupPush(data: any): Promise<boolean>

  /rfed/backup/push (SPEC §11) — an owner node replicates its (subscriber_hash, channel_hash) pairs to this backup. The payload is the shared signed [value, pubkey, sig] form where value is the msgpack of [[sub_hash, ch_hash], …]; the owner identity is derived from pubkey and its rfed.node hash tags the resulting backup subscriptions. Replies true on success, false on any verification/trust failure. Mirrors Rust backup_push_cb.

  Parameters

  • data: any

  Returns Promise<boolean>

_handleGet

• _handleGet(data: any): Uint8Array<ArrayBufferLike>

  /rfed/get (SPEC §3/§4) — encodes the requested blobs into the §3 stream ch(16)‖id(16)‖len(4 BE)‖blob, stopping once transferLimitBytes would be exceeded (per-session cap). Returns the raw stream bytes; the Link wraps them in a msgpack Binary for transit (Rust handle_message_get).

  Blobs transit stamp-stripped; no stamp validation here.

  Parameters

  • data: any

    Decoded msgpack [id, …].

  Returns Uint8Array<ArrayBufferLike>

_handleNotifyClear

• _handleNotifyClear(data: any): Promise<boolean>

  /rfed/notify/clear — removes ALL relay registrations for the caller (every channel + LXMF). Served on legacy rfed.notify only.

  Parameters

  • data: any

  Returns Promise<boolean>

_handleNotifyRegister

• _handleNotifyRegister(data: any): Promise<boolean>

  /rfed/notify/register (SPEC §9.1) — verifies the signed command, validates the relay hash, remembers the relay identity (so we can later route a wake to it), issues a path request, and records the registration.

  Parameters

  • data: any

  Returns Promise<boolean>

_handleNotifyUnregister

• _handleNotifyUnregister(data: any): Promise<boolean>

  /rfed/notify/unregister — removes one (subscriber, channel, relay) registration.

  Parameters

  • data: any

  Returns Promise<boolean>

_handleOffer

• _handleOffer(): [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>][]

  /rfed/offer (SPEC §4) — returns the node's full store manifest as [[channelHash, messageId], …] so the caller can compute its gap. (Rust handle_offer; the caller's offered IDs are accepted but unused.)

  Returns [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>][]

_handlePull

• _handlePull(
      data: any,
      caller: Identity | null,
  ): Promise<
      [[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>][], boolean],
  >

  /rfed/pull — drains one page of the caller's deferred queue for the requested channel. Caller is authenticated by the identified link.

  Parameters

  • data: any

    bin(16) channel hash.

  • caller: Identity | null

  Returns Promise<[[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>][], boolean]>

_handleSend

• _handleSend(data: Uint8Array<ArrayBufferLike>): Promise<void>

  SEND ingest (the publish destination's DATA callback): validate the stamp (when configured), store the blob, and fan out / defer to subscribers.

  Parameters

  • data: Uint8Array<ArrayBufferLike>

    Decrypted SEND payload.

  Returns Promise<void>

_handleSubscribe

• _handleSubscribe(data: any): Promise<[boolean, number | null]>

  /rfed/subscribe — verifies the signed [channel_hash, pubkey, sig] payload, records the subscription, replies [true, stamp_cost|nil].

  Parameters

  • data: any

  Returns Promise<[boolean, number | null]>

_handleUnsubscribe

• _handleUnsubscribe(data: any): Promise<boolean>

  /rfed/unsubscribe — verifies the signed payload, drops the subscription.

  Parameters

  • data: any

  Returns Promise<boolean>

_ingest

• _ingest(
      channelHash: Uint8Array<ArrayBufferLike>,
      innerBlob: Uint8Array<ArrayBufferLike>,
  ): Promise<void>

  Stores the blob (sync-side) and dispatches it to subscribers: live fanout for present subscribers, deferred queue for the rest.

  Parameters

  • channelHash: Uint8Array<ArrayBufferLike>
  • innerBlob: Uint8Array<ArrayBufferLike>

  Returns Promise<void>

_onAnnounce

• _onAnnounce(event: any): Promise<void>

  Transport "announce" handler: records the destination as present and, if it is a subscriber's rfed.delivery, drains that subscriber's deferred queue and live-delivers (SPEC §7 trigger 1).

  Parameters

  • event: any

  Returns Promise<void>

_sendDelivery

• _sendDelivery(
      subscriberIdentity: Identity,
      payload: Uint8Array<ArrayBufferLike>,
  ): Promise<void>

  Builds and sends an outbound DATA packet to a subscriber's rfed.delivery.

  Parameters

  • subscriberIdentity: Identity
  • payload: Uint8Array<ArrayBufferLike>

    [ channel_hash ‖ inner_blob ].

  Returns Promise<void>

_syncWithPeerInternal

• _syncWithPeerInternal(
      peerNodeHash: Uint8Array<ArrayBufferLike>,
  ): Promise<number>

  Internal sync implementation without peer tracking side-effects.

  Parameters

  • peerNodeHash: Uint8Array<ArrayBufferLike>

  Returns Promise<number>

announce

• announce(): Promise<void>

  Announces rfed.node (with stamp-cost app_data) and the four service destinations so clients can discover and path-request them.

  Returns Promise<void>

isOnline

• isOnline(deliveryHash: Uint8Array<ArrayBufferLike>): boolean

  Whether a subscriber's rfed.delivery has been heard from within the TTL. Exposed so callers (and tests) can inspect reachability before acting.

  Parameters

  • deliveryHash: Uint8Array<ArrayBufferLike>

  Returns boolean

start

• start(): Promise<void>

  Brings up the five inbound destinations, registers the request/Send handlers, binds the announce listener, and announces rfed.node + the service destinations so clients can path-request them.

  Returns Promise<void>

stop

• stop(): void

  Detaches the announce listener.

  Returns void

syncPeers

• syncPeers(): Promise<number>

  Syncs with all federation peers that are due for sync. Matches LXMF router's syncPeers() API pattern.

  Called periodically by the runner (e.g., every 10-60 seconds).

  Returns Promise<number>

  Total number of blobs ingested from all peers

syncWithPeer

• syncWithPeer(peerNodeHash: Uint8Array<ArrayBufferLike>): Promise<number>

  Synchronises with a peer rfed.node: OFFER (our held IDs) → receive the peer's manifest → compute the gap (channels we subscribe to, don't hold) → MESSAGE_GET the missing blobs → ingest each (store under the upstream id, then fan out to local subscribers). Mirrors Rust run_sync_session.

  Returns the number of newly-ingested blobs. Throws if the peer identity cannot be recalled or the link fails.

  Parameters

  • peerNodeHash: Uint8Array<ArrayBufferLike>

    The peer's rfed.node destination hash.

  Returns Promise<number>

tickBackupDelivery

• tickBackupDelivery(): Promise<
      { adopted: number; pruned: number; pushed: number; repushed: number },
  >

  Backup-failover tick (SPEC §11) — a runner calls this every BACKUP_TICK_SECS seconds (30s). Three tasks:

  1. Push own subscriptions: drain {@link _pendingBackupPushes} and forward to ONE resolved backup node.
  2. Prune stale backup entries (chain unravel; TTL = max(ownerOfflineSecs × 2, 90)).
  3. Failover: for each held backup whose owner has gone silent, dump the channel backlog into the deferred queue + fire notify wakes, and re-push adopted entries to our own backup (chain of custody).

  Mirrors Rust tick_backup_delivery. Auto-selection from federation peers (Rust priority 5) is not implemented — only configured primaryNode / secondaryNodes are used.

  Returns Promise<{ adopted: number; pruned: number; pushed: number; repushed: number }>

tickMaintenance

• tickMaintenance(): { blobsEvicted: number; deferredEvicted: number }

  Periodic maintenance — a runner calls this hourly (SPEC §5/§7). Prunes expired blobs (30-day TTL) and deferred-queue entries (7-day TTL) and evicts blob-store overflow to the capacity limit.

  Returns { blobsEvicted: number; deferredEvicted: number }