@decentnetwork/peer 0.1.141 → 0.1.143

package/dist/peer.d.ts

@@ -335,11 +335,13 @@ export declare class Peer {
     setUserInfo(info: {
         name?: string;
         description?: string;
+        punkId?: number | null;
     }): void;
     /** Our current display name + status-message description. */
     userInfo(): {
         name: string;
         description: string;
+        punkId?: number;
     };
     /**
      * Tell a friend our public UDP endpoint over the (already-working,

package/dist/peer.js

@@ -286,6 +286,19 @@ const RECV_REORDER_WINDOW = 8192;
 // Minimum gap between PACKET_ID_REQUEST packets we send for our own receive gaps
 // (toxcore paces requests ~ once per RTT; this floor avoids flooding on a burst).
 const RECV_REQUEST_MIN_INTERVAL_MS = 200;
+/** Read a CryptoPunks id out of the userinfo `gender` field.
+ *
+ *  Beagle writes the bare nft id there. Anything else — an empty string, or a
+ *  real gender from a non-Beagle Carrier client — is not a punk and must not
+ *  be rendered as one. */
+function parsePunkField(value) {
+    if (!value)
+        return undefined;
+    const n = Number(value.trim());
+    if (!Number.isInteger(n) || n < 0 || n > 9999)
+        return undefined;
+    return n;
+}
 export class Peer {
     #opts;
     #events = new EventEmitter();
@@ -885,6 +898,41 @@ export class Peer {
         if (!this.#bootstrap) {
             throw new Error("Peer is not started");
         }
+        // A browser has no UDP and never will. The DHT bootstrap is a getnodes
+        // datagram waiting for a sendnodes reply, so there it can only ever time
+        // out — 30 seconds, then an error that reads like a network fault.
+        //
+        // That cost far more than a slow start. Everything after the await lives
+        // downstream of it: the self-announce (without which nobody can FIND this
+        // peer), the announce loop, and the express pull loop (without which
+        // offline messages are never collected). start() launches only the
+        // friend-connection loop, so a browser could talk to a friend who was
+        // already online and whose endpoint it had cached — and nothing else.
+        // That is exactly the half-working shape this looked like from outside.
+        //
+        // With tcpOnlyBootstrap we skip the datagram round trip and seed the node
+        // list from the configured bootstrap nodes, which is what the TCP relay
+        // path uses anyway. Announce and both loops then run normally.
+        if (this.#opts.tcpOnlyBootstrap) {
+            const seed = this.#opts.bootstrapNodes ?? [];
+            if (seed.length === 0) {
+                throw new Error("tcpOnlyBootstrap needs at least one bootstrap node to seed from");
+            }
+            this.#knownNodes = dedupeNodes([...seed]);
+            await this.#runSelfAnnounce(false, Date.now() + JOIN_ANNOUNCE_TIMEOUT_MS);
+            this.#ensureSelfAnnounceLoop();
+            this.#ensureDhtMaintenanceLoop();
+            this.#ensureFriendConnectionLoop();
+            this.#ensureExpressPullLoop();
+            void this.#doFriendConnections().catch((error) => {
+                this.#debugLog(`initial friend connection cycle failed: ${error.message}`);
+            });
+            const first = seed[0];
+            return {
+                respondingNode: first,
+                discoveredNodes: []
+            };
+        }
         const result = await this.#bootstrap.join();
         this.#recordNodeSuccess(`${result.respondingNode.host}:${result.respondingNode.port}`);
         const discovered = result.discoveredNodes.map((node) => ({
@@ -4250,12 +4298,17 @@ export class Peer {
             // back to plain UTF-8 for compatibility.
             let userInfoName;
             let userInfoDescr;
+            let userInfoPunk;
             let clientMeta;
             try {
                 const decoded = decodeCarrierPacket(inner);
                 if (decoded.type === PACKET_TYPE_USERINFO) {
                     userInfoName = decoded.name;
                     userInfoDescr = decoded.descr;
+                    // The friend's avatar. `gender` is where Beagle puts the punk id —
+                    // it was decoded here and thrown away, which is the whole reason a
+                    // friend's picture could only ever come from beagles.eth.
+                    userInfoPunk = parsePunkField(decoded.gender);
                     // AgentNet appended fields — present only for updated peers.
                     if (decoded.protoVersion || decoded.platform || decoded.appVersion) {
                         clientMeta = {
@@ -4274,19 +4327,23 @@ export class Peer {
                 const friend = this.#friends.get(friendId);
                 const newName = userInfoName && userInfoName.length > 0 ? userInfoName : friend?.name;
                 const newDescr = userInfoDescr ?? friend?.description;
+                // Keep what we had when this packet carried no punk: a peer that
+                // stops sending one has not taken their avatar off.
+                const newPunk = userInfoPunk ?? friend?.punkId;
                 const metaChanged = friend != null && clientMeta != null &&
                     (friend.protoVersion !== clientMeta.protoVersion ||
                         friend.platform !== clientMeta.platform ||
                         friend.osVersion !== clientMeta.osVersion ||
                         friend.appVersion !== clientMeta.appVersion);
-                if (friend && (friend.name !== newName || friend.description !== newDescr || metaChanged)) {
-                    this.#friends.set(friendId, { ...friend, name: newName, description: newDescr, ...(clientMeta ?? {}) });
+                if (friend && (friend.name !== newName || friend.description !== newDescr || friend.punkId !== newPunk || metaChanged)) {
+                    this.#friends.set(friendId, { ...friend, name: newName, description: newDescr, punkId: newPunk, ...(clientMeta ?? {}) });
                     this.#persistFriends();
                     this.#events.emit("friendInfo", {
                         pubkey: friendId,
                         userid: friend.userid ?? friendId,
                         name: newName,
                         description: newDescr,
+                        punkId: newPunk,
                         ...(clientMeta ?? {})
                     });
                 }
@@ -4958,6 +5015,11 @@ export class Peer {
             opts.nickname = info.name;
         if (info.description !== undefined)
             opts.statusMessage = info.description;
+        // null clears it explicitly; undefined means "not changing it". Everything
+        // below re-sends the profile to every established friend, which is what
+        // makes an avatar change visible without a reconnect.
+        if (info.punkId !== undefined)
+            opts.punkId = info.punkId ?? undefined;
         this.#profileSentTo.clear();
         for (const timer of this.#profileRetryTimers.values())
             clearTimeout(timer);
@@ -4974,6 +5036,9 @@ export class Peer {
         return {
             name: opts.nickname ?? PEER_NICKNAME,
             description: opts.statusMessage ?? PEER_STATUS_MESSAGE,
+            // Reported so "what am I actually advertising" is answerable without
+            // reading a packet capture — the UI surfaces this as `me.advertised`.
+            punkId: opts.punkId,
         };
     }
     #scheduleProfileRetry(friendId) {
@@ -5030,7 +5095,12 @@ export class Peer {
                         protoVersion: AGENTNET_PROTO_VERSION,
                         platform: this.#opts.platform ?? process.platform,
                         osVersion: this.#opts.osVersion ?? `node-${process.versions?.node ?? ""}`,
-                        appVersion: this.#opts.appVersion ?? `peer-${PEER_PKG_VERSION}`
+                        appVersion: this.#opts.appVersion ?? `peer-${PEER_PKG_VERSION}`,
+                        // The avatar, in the field Beagle uses for it (see punkId on
+                        // FriendInfoEvent). OMITTED when we have none, never sent as "":
+                        // an empty string would clear an avatar the friend already
+                        // resolved. Without this, iOS shows us no picture at all.
+                        ...(this.#opts.punkId != null ? { gender: String(this.#opts.punkId) } : {})
                     });
                     await this.#sendMessengerPacket(friendId, PACKET_ID_STATUSMESSAGE, userInfo);
                     this.#debugLog(`userinfo sent to ${friendId} (name="${nick}", descr="${descr}", proto=${AGENTNET_PROTO_VERSION}, platform=${this.#opts.platform ?? process.platform})`);

package/dist/store/friends.d.ts

@@ -5,6 +5,10 @@ export type FriendRecord = {
     nospam?: number;
     name?: string;
     description?: string;
+    /** The friend's CryptoPunks id, from the userinfo `gender` field. Persisted
+     *  so their avatar survives a restart instead of waiting for the next
+     *  profile packet. See FriendInfoEvent.punkId. */
+    punkId?: number;
     status: "requested" | "offline" | "online";
     remoteHost?: string;
     remotePort?: number;

package/dist/types/peer.d.ts

@@ -88,6 +88,18 @@ export type PeerOptions = {
      * version.
      */
     appVersion?: string;
+    /** Our own CryptoPunks id, advertised to friends in the userinfo `gender`
+     *  field — the only way an avatar travels over Carrier itself. Leave unset
+     *  and the field is omitted entirely (never sent as ""), so a friend keeps
+     *  whatever picture they already have for us. */
+    punkId?: number;
+    /** Skip the UDP DHT bootstrap and seed the node list from bootstrapNodes.
+     *
+     *  For hosts with no UDP — a browser above all. Without it joinNetwork()
+     *  waits 30s for a datagram that cannot arrive, and everything downstream
+     *  of it never runs: self-announce (so nobody can find this peer) and the
+     *  express pull loop (so offline messages are never collected). */
+    tcpOnlyBootstrap?: boolean;
     compatibilityMode?: CompatibilityMode;
     debugLabel?: string;
 };
@@ -110,6 +122,18 @@ export type FriendInfoEvent = {
     userid?: string;
     name?: string;
     description?: string;
+    /** The friend's CryptoPunks id — their avatar.
+     *
+     *  Carried in the userinfo packet's `gender` field, which is not a mistake
+     *  and not ours to rename. The protocol has no avatar field: `has_avatar`
+     *  is a bool in all four implementations and the image exchange was never
+     *  built. Beagle borrowed `gender` because a punk carries a gender anyway.
+     *  Defined in WalletForBeagleV2/docs/profile.md — set with
+     *  userinfo.setGender(nftid), read back off friendInfo.gender.
+     *
+     *  Undefined when the friend sent no punk, or sent something that is not a
+     *  punk id (a real gender from a non-Beagle Carrier client). */
+    punkId?: number;
     /** Peer's advertised client metadata (from the userinfo profile). Present
      *  only once the friend has sent a profile with these fields — a legacy
      *  peer (native C SDK before the extension, or an old JS build) leaves them

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.141",
+  "version": "0.1.143",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",