@openclaw/buzz 2026.8.1-beta.2 → 2026.9.1-beta.1

package/node_modules/nostr-tools/lib/cjs/nip29.js

@@ -23,23 +23,45 @@ __export(nip29_exports, {
   GroupAdminPermission: () => GroupAdminPermission,
   encodeGroupReference: () => encodeGroupReference,
   fetchGroupAdminsEvent: () => fetchGroupAdminsEvent,
+  fetchGroupLivekitParticipantsEvent: () => fetchGroupLivekitParticipantsEvent,
   fetchGroupMembersEvent: () => fetchGroupMembersEvent,
   fetchGroupMetadataEvent: () => fetchGroupMetadataEvent,
+  fetchGroupPinnedEventsEvent: () => fetchGroupPinnedEventsEvent,
+  fetchGroupRolesEvent: () => fetchGroupRolesEvent,
   fetchRelayInformationByGroupReference: () => fetchRelayInformationByGroupReference,
+  generateCreateGroupEventTemplate: () => generateCreateGroupEventTemplate,
+  generateCreateInviteEventTemplate: () => generateCreateInviteEventTemplate,
+  generateDeleteEventEventTemplate: () => generateDeleteEventEventTemplate,
+  generateDeleteGroupEventTemplate: () => generateDeleteGroupEventTemplate,
+  generateEditGroupMetadataEventTemplate: () => generateEditGroupMetadataEventTemplate,
   generateGroupAdminsEventTemplate: () => generateGroupAdminsEventTemplate,
+  generateGroupJoinRequestEventTemplate: () => generateGroupJoinRequestEventTemplate,
+  generateGroupLeaveRequestEventTemplate: () => generateGroupLeaveRequestEventTemplate,
+  generateGroupLivekitParticipantsEventTemplate: () => generateGroupLivekitParticipantsEventTemplate,
   generateGroupMembersEventTemplate: () => generateGroupMembersEventTemplate,
   generateGroupMetadataEventTemplate: () => generateGroupMetadataEventTemplate,
+  generateGroupPinnedEventsEventTemplate: () => generateGroupPinnedEventsEventTemplate,
+  generateGroupRolesEventTemplate: () => generateGroupRolesEventTemplate,
+  generatePutUserEventTemplate: () => generatePutUserEventTemplate,
+  generateRemoveUserEventTemplate: () => generateRemoveUserEventTemplate,
+  generateUpdatePinListEventTemplate: () => generateUpdatePinListEventTemplate,
   getNormalizedRelayURLByGroupReference: () => getNormalizedRelayURLByGroupReference,
   loadGroup: () => loadGroup,
   loadGroupFromCode: () => loadGroupFromCode,
   parseGroupAdminsEvent: () => parseGroupAdminsEvent,
   parseGroupCode: () => parseGroupCode,
+  parseGroupLivekitParticipantsEvent: () => parseGroupLivekitParticipantsEvent,
   parseGroupMembersEvent: () => parseGroupMembersEvent,
   parseGroupMetadataEvent: () => parseGroupMetadataEvent,
+  parseGroupPinnedEventsEvent: () => parseGroupPinnedEventsEvent,
+  parseGroupRolesEvent: () => parseGroupRolesEvent,
   subscribeRelayGroupsMetadataEvents: () => subscribeRelayGroupsMetadataEvents,
   validateGroupAdminsEvent: () => validateGroupAdminsEvent,
+  validateGroupLivekitParticipantsEvent: () => validateGroupLivekitParticipantsEvent,
   validateGroupMembersEvent: () => validateGroupMembersEvent,
-  validateGroupMetadataEvent: () => validateGroupMetadataEvent
+  validateGroupMetadataEvent: () => validateGroupMetadataEvent,
+  validateGroupPinnedEventsEvent: () => validateGroupPinnedEventsEvent,
+  validateGroupRolesEvent: () => validateGroupRolesEvent
 });
 module.exports = __toCommonJS(nip29_exports);
 
@@ -196,20 +218,33 @@ var GroupAdminPermission = /* @__PURE__ */ ((GroupAdminPermission2) => {
   GroupAdminPermission2["CreateGroup"] = "create-group";
   GroupAdminPermission2["DeleteGroup"] = "delete-group";
   GroupAdminPermission2["CreateInvite"] = "create-invite";
+  GroupAdminPermission2["UpdatePinList"] = "update-pin-list";
   return GroupAdminPermission2;
 })(GroupAdminPermission || {});
+function buildGroupMetadataTags(metadata) {
+  const tags = [];
+  metadata.name && tags.push(["name", metadata.name]);
+  metadata.picture && tags.push(["picture", metadata.picture]);
+  metadata.banner && tags.push(["banner", metadata.banner]);
+  metadata.about && tags.push(["about", metadata.about]);
+  metadata.isPrivate && tags.push(["private"]);
+  metadata.isRestricted && tags.push(["restricted"]);
+  metadata.isHidden && tags.push(["hidden"]);
+  metadata.isClosed && tags.push(["closed"]);
+  metadata.hasLiveKit && tags.push(["livekit"]);
+  metadata.supportedKinds && metadata.supportedKinds.length > 0 && tags.push(["supported_kinds", ...metadata.supportedKinds]);
+  metadata.parent && tags.push(["parent", metadata.parent]);
+  metadata.children && metadata.children.forEach((child) => {
+    tags.push(["child", child]);
+  });
+  return tags;
+}
 function generateGroupMetadataEventTemplate(group) {
-  const tags = [["d", group.metadata.id]];
-  group.metadata.name && tags.push(["name", group.metadata.name]);
-  group.metadata.picture && tags.push(["picture", group.metadata.picture]);
-  group.metadata.about && tags.push(["about", group.metadata.about]);
-  group.metadata.isPublic && tags.push(["public"]);
-  group.metadata.isOpen && tags.push(["open"]);
   return {
     content: "",
     created_at: Math.floor(Date.now() / 1e3),
     kind: 39e3,
-    tags
+    tags: [["d", group.metadata.id], ...buildGroupMetadataTags(group.metadata)]
   };
 }
 function validateGroupMetadataEvent(event) {
@@ -324,17 +359,38 @@ function parseGroupMetadataEvent(event) {
       case "picture":
         metadata.picture = value;
         break;
+      case "banner":
+        metadata.banner = value;
+        break;
       case "about":
         metadata.about = value;
         break;
-      case "public":
-        metadata.isPublic = true;
+      case "private":
+        metadata.isPrivate = true;
+        break;
+      case "restricted":
+        metadata.isRestricted = true;
+        break;
+      case "hidden":
+        metadata.isHidden = true;
+        break;
+      case "closed":
+        metadata.isClosed = true;
+        break;
+      case "livekit":
+        metadata.hasLiveKit = true;
         break;
-      case "open":
-        metadata.isOpen = true;
+      case "parent":
+        metadata.parent = value;
         break;
     }
   }
+  const supportedKinds = event.tags.filter(([tag]) => tag === "supported_kinds").flatMap(([, ...values]) => values);
+  if (supportedKinds.length > 0)
+    metadata.supportedKinds = supportedKinds;
+  const children = event.tags.filter(([tag]) => tag === "child").map(([, value]) => value);
+  if (children.length > 0)
+    metadata.children = children;
   return metadata;
 }
 async function fetchGroupAdminsEvent({
@@ -394,6 +450,69 @@ async function fetchGroupMembersEvent({
     throw new Error(`members for group '${groupReference.id}' not found on ${normalizedRelayURL}`);
   return groupMembersEvent;
 }
+async function fetchGroupRolesEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL
+}) {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference);
+  }
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL);
+  }
+  const groupRolesEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39003],
+    authors: [relayInformation.pubkey],
+    "#d": [groupReference.id]
+  });
+  if (!groupRolesEvent)
+    throw new Error(`roles for group '${groupReference.id}' not found on ${normalizedRelayURL}`);
+  return groupRolesEvent;
+}
+async function fetchGroupLivekitParticipantsEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL
+}) {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference);
+  }
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL);
+  }
+  const groupLivekitParticipantsEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39004],
+    authors: [relayInformation.pubkey],
+    "#d": [groupReference.id]
+  });
+  if (!groupLivekitParticipantsEvent)
+    throw new Error(`livekit participants for group '${groupReference.id}' not found on ${normalizedRelayURL}`);
+  return groupLivekitParticipantsEvent;
+}
+async function fetchGroupPinnedEventsEvent({
+  pool,
+  groupReference,
+  relayInformation,
+  normalizedRelayURL
+}) {
+  if (!normalizedRelayURL) {
+    normalizedRelayURL = getNormalizedRelayURLByGroupReference(groupReference);
+  }
+  if (!relayInformation) {
+    relayInformation = await fetchRelayInformation(normalizedRelayURL);
+  }
+  const groupPinnedEventsEvent = await pool.get([normalizedRelayURL], {
+    kinds: [39005],
+    authors: [relayInformation.pubkey],
+    "#d": [groupReference.id]
+  });
+  if (!groupPinnedEventsEvent)
+    throw new Error(`pinned events for group '${groupReference.id}' not found on ${normalizedRelayURL}`);
+  return groupPinnedEventsEvent;
+}
 function parseGroupMembersEvent(event) {
   if (!validateGroupMembersEvent(event))
     throw new Error("invalid group members event");
@@ -408,6 +527,163 @@ function parseGroupMembersEvent(event) {
   }
   return members;
 }
+function generateGroupRolesEventTemplate(group, roles) {
+  const tags = [["d", group.metadata.id]];
+  for (const role of roles) {
+    const tag = ["role", role.name];
+    role.description && tag.push(role.description);
+    tags.push(tag);
+  }
+  return {
+    content: "",
+    created_at: Math.floor(Date.now() / 1e3),
+    kind: 39003,
+    tags
+  };
+}
+function validateGroupRolesEvent(event) {
+  if (event.kind !== 39003)
+    return false;
+  const requiredTags = ["d"];
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag))
+      return false;
+  }
+  return true;
+}
+function parseGroupRolesEvent(event) {
+  if (!validateGroupRolesEvent(event))
+    throw new Error("invalid group roles event");
+  const roles = [];
+  for (const [tag, name, description] of event.tags) {
+    if (tag !== "role")
+      continue;
+    roles.push({ name, description });
+  }
+  return roles;
+}
+function generateGroupLivekitParticipantsEventTemplate(group, participants) {
+  const tags = [["d", group.metadata.id]];
+  participants.forEach((pubkey) => {
+    tags.push(["participant", pubkey]);
+  });
+  return {
+    content: "",
+    created_at: Math.floor(Date.now() / 1e3),
+    kind: 39004,
+    tags
+  };
+}
+function validateGroupLivekitParticipantsEvent(event) {
+  if (event.kind !== 39004)
+    return false;
+  const requiredTags = ["d"];
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag))
+      return false;
+  }
+  return true;
+}
+function parseGroupLivekitParticipantsEvent(event) {
+  if (!validateGroupLivekitParticipantsEvent(event))
+    throw new Error("invalid group livekit participants event");
+  return event.tags.filter(([tag]) => tag === "participant").map(([, pubkey]) => pubkey);
+}
+function generateGroupPinnedEventsEventTemplate(group, pinnedEvents) {
+  const tags = [["d", group.metadata.id]];
+  pinnedEvents.forEach((pinnedEvent) => {
+    tags.push([pinnedEvent.type, pinnedEvent.value]);
+  });
+  return {
+    content: "",
+    created_at: Math.floor(Date.now() / 1e3),
+    kind: 39005,
+    tags
+  };
+}
+function validateGroupPinnedEventsEvent(event) {
+  if (event.kind !== 39005)
+    return false;
+  const requiredTags = ["d"];
+  for (const tag of requiredTags) {
+    if (!event.tags.find(([t]) => t == tag))
+      return false;
+  }
+  return true;
+}
+function parseGroupPinnedEventsEvent(event) {
+  if (!validateGroupPinnedEventsEvent(event))
+    throw new Error("invalid group pinned events event");
+  const pinnedEvents = [];
+  for (const [tag, value] of event.tags) {
+    if (tag !== "e" && tag !== "a")
+      continue;
+    pinnedEvents.push({ type: tag, value });
+  }
+  return pinnedEvents;
+}
+function generateGroupModerationEventTemplate(kind, groupId, content, tags, previous) {
+  const allTags = [["h", groupId], ...tags];
+  previous && previous.length > 0 && allTags.push(["previous", ...previous]);
+  return {
+    content,
+    created_at: Math.floor(Date.now() / 1e3),
+    kind,
+    tags: allTags
+  };
+}
+function generatePutUserEventTemplate(groupId, pubkey, roles, reason, previous) {
+  return generateGroupModerationEventTemplate(9e3, groupId, reason || "", [["p", pubkey, ...roles || []]], previous);
+}
+function generateRemoveUserEventTemplate(groupId, pubkey, reason, previous) {
+  return generateGroupModerationEventTemplate(9001, groupId, reason || "", [["p", pubkey]], previous);
+}
+function generateEditGroupMetadataEventTemplate(group, reason, previous) {
+  return generateGroupModerationEventTemplate(
+    9002,
+    group.metadata.id,
+    reason || "",
+    buildGroupMetadataTags(group.metadata),
+    previous
+  );
+}
+function generateDeleteEventEventTemplate(groupId, eventId, reason, previous) {
+  return generateGroupModerationEventTemplate(9005, groupId, reason || "", [["e", eventId]], previous);
+}
+function generateCreateGroupEventTemplate(groupId, reason, previous) {
+  return generateGroupModerationEventTemplate(9007, groupId, reason || "", [], previous);
+}
+function generateDeleteGroupEventTemplate(groupId, reason, previous) {
+  return generateGroupModerationEventTemplate(9008, groupId, reason || "", [], previous);
+}
+function generateCreateInviteEventTemplate(groupId, code, reason, previous) {
+  return generateGroupModerationEventTemplate(9009, groupId, reason || "", [["code", code]], previous);
+}
+function generateUpdatePinListEventTemplate(groupId, pinnedEvents, reason, previous) {
+  const tags = pinnedEvents.map((pinnedEvent) => [pinnedEvent.type, pinnedEvent.value]);
+  return generateGroupModerationEventTemplate(9010, groupId, reason || "", tags, previous);
+}
+function generateGroupJoinRequestEventTemplate(groupId, inviteCode, reason, previous) {
+  const tags = [["h", groupId]];
+  inviteCode && tags.push(["code", inviteCode]);
+  previous && previous.length > 0 && tags.push(["previous", ...previous]);
+  return {
+    content: reason || "",
+    created_at: Math.floor(Date.now() / 1e3),
+    kind: 9021,
+    tags
+  };
+}
+function generateGroupLeaveRequestEventTemplate(groupId, reason, previous) {
+  const tags = [["h", groupId]];
+  previous && previous.length > 0 && tags.push(["previous", ...previous]);
+  return {
+    content: reason || "",
+    created_at: Math.floor(Date.now() / 1e3),
+    kind: 9022,
+    tags
+  };
+}
 async function loadGroup({
   pool,
   groupReference,