NIP-53: 直播活動

概述

NIP-53 定義了一套用於直播活動、會議室和即時互動的事件類型。它支援視訊直播、語音房間、 線上會議等場景，包含參與者管理、聊天訊息、狀態追蹤等完整功能。

事件類型

直播活動結構（Kind 30311）

直播活動事件包含豐富的元資料和參與者資訊：

活動狀態

參與者角色

參與者標籤格式：["p", "pubkey", "relay", "role", "proof"]

使用範例

創建直播活動

{
  "kind": 30311,
  "tags": [
    ["d", "abc123-live-event"],
    ["title", "Nostr 開發者聚會"],
    ["summary", "討論 Nostr 協議的最新發展"],
    ["image", "https://example.com/cover.jpg"],
    ["streaming", "https://stream.example.com/live/abc123"],
    ["starts", "1704067200"],
    ["status", "planned"],
    ["p", "<host-pubkey>", "wss://relay.example.com", "Host"],
    ["p", "<speaker-pubkey>", "wss://relay.example.com", "Speaker"]
  ],
  "content": ""
}

正在直播的活動

{
  "kind": 30311,
  "tags": [
    ["d", "abc123-live-event"],
    ["title", "Nostr 開發者聚會"],
    ["summary", "討論 Nostr 協議的最新發展"],
    ["streaming", "https://stream.example.com/live/abc123"],
    ["starts", "1704067200"],
    ["status", "live"],
    ["current_participants", "256"],
    ["p", "<host-pubkey>", "wss://relay.example.com", "Host"],
    ["p", "<speaker1>", "", "Speaker"],
    ["p", "<speaker2>", "", "Speaker", "<proof-signature>"]
  ],
  "content": ""
}

直播聊天訊息

{
  "kind": 1311,
  "tags": [
    ["a", "30311:<host-pubkey>:abc123-live-event", "wss://relay.example.com"]
  ],
  "content": "這個功能太棒了！🎉"
}

已結束（含錄影）

{
  "kind": 30311,
  "tags": [
    ["d", "abc123-live-event"],
    ["title", "Nostr 開發者聚會"],
    ["status", "ended"],
    ["starts", "1704067200"],
    ["ends", "1704074400"],
    ["recording", "https://video.example.com/recordings/abc123.mp4"],
    ["total_participants", "1024"]
  ],
  "content": ""
}

TypeScript 實作

import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools'
import { schnorr } from '@noble/curves/secp256k1'
import { sha256 } from '@noble/hashes/sha256'
import { bytesToHex } from '@noble/hashes/utils'

type LiveStatus = 'planned' | 'live' | 'ended'
type ParticipantRole = 'Host' | 'Speaker' | 'Participant' | 'Moderator' | 'Owner'

interface Participant {
  pubkey: string
  relay?: string
  role: ParticipantRole
  proof?: string
}

interface LiveEventOptions {
  id: string
  title: string
  summary?: string
  image?: string
  streamingUrl?: string
  recordingUrl?: string
  starts?: number
  ends?: number
  status: LiveStatus
  participants?: Participant[]
  currentParticipants?: number
  totalParticipants?: number
}

// 創建直播活動事件
function createLiveEvent(
  options: LiveEventOptions,
  secretKey: Uint8Array
): object {
  const tags: string[][] = [
    ['d', options.id],
    ['title', options.title],
    ['status', options.status],
  ]

  if (options.summary) {
    tags.push(['summary', options.summary])
  }

  if (options.image) {
    tags.push(['image', options.image])
  }

  if (options.streamingUrl) {
    tags.push(['streaming', options.streamingUrl])
  }

  if (options.recordingUrl) {
    tags.push(['recording', options.recordingUrl])
  }

  if (options.starts) {
    tags.push(['starts', options.starts.toString()])
  }

  if (options.ends) {
    tags.push(['ends', options.ends.toString()])
  }

  if (options.currentParticipants !== undefined) {
    tags.push(['current_participants', options.currentParticipants.toString()])
  }

  if (options.totalParticipants !== undefined) {
    tags.push(['total_participants', options.totalParticipants.toString()])
  }

  // 添加參與者
  if (options.participants) {
    for (const p of options.participants) {
      const pTag = ['p', p.pubkey, p.relay || '', p.role]
      if (p.proof) {
        pTag.push(p.proof)
      }
      tags.push(pTag)
    }
  }

  const event = {
    kind: 30311,
    created_at: Math.floor(Date.now() / 1000),
    tags,
    content: '',
  }

  return finalizeEvent(event, secretKey)
}

// 生成參與者證明簽名
function generateParticipantProof(
  hostPubkey: string,
  eventId: string,
  participantSecretKey: Uint8Array
): string {
  const aTag = `30311:${hostPubkey}:${eventId}`
  const hash = sha256(new TextEncoder().encode(aTag))
  const signature = schnorr.sign(hash, participantSecretKey)
  return bytesToHex(signature)
}

// 發送直播聊天訊息
function createLiveChatMessage(
  hostPubkey: string,
  eventId: string,
  message: string,
  relay: string,
  secretKey: Uint8Array
): object {
  const aTag = `30311:${hostPubkey}:${eventId}`

  const event = {
    kind: 1311,
    created_at: Math.floor(Date.now() / 1000),
    tags: [
      ['a', aTag, relay],
    ],
    content: message,
  }

  return finalizeEvent(event, secretKey)
}

// 更新活動狀態為直播中
function startLiveEvent(
  eventId: string,
  currentOptions: LiveEventOptions,
  secretKey: Uint8Array
): object {
  return createLiveEvent({
    ...currentOptions,
    id: eventId,
    status: 'live',
    starts: Math.floor(Date.now() / 1000),
  }, secretKey)
}

// 結束直播活動
function endLiveEvent(
  eventId: string,
  currentOptions: LiveEventOptions,
  recordingUrl: string,
  totalParticipants: number,
  secretKey: Uint8Array
): object {
  return createLiveEvent({
    ...currentOptions,
    id: eventId,
    status: 'ended',
    ends: Math.floor(Date.now() / 1000),
    recordingUrl,
    totalParticipants,
  }, secretKey)
}

// 使用範例
const hostSk = generateSecretKey()
const hostPk = getPublicKey(hostSk)

const speakerSk = generateSecretKey()
const speakerPk = getPublicKey(speakerSk)

const eventId = 'nostr-dev-meetup-2024'

// 創建排程活動
const plannedEvent = createLiveEvent({
  id: eventId,
  title: 'Nostr 開發者聚會',
  summary: '討論 Nostr 協議的最新發展和未來計畫',
  image: 'https://example.com/cover.jpg',
  streamingUrl: 'https://stream.example.com/live/abc123',
  starts: Math.floor(Date.now() / 1000) + 86400, // 明天
  status: 'planned',
  participants: [
    { pubkey: hostPk, role: 'Host' },
    { pubkey: speakerPk, relay: 'wss://relay.example.com', role: 'Speaker' },
  ],
}, hostSk)

// 講者生成參與證明
const proof = generateParticipantProof(hostPk, eventId, speakerSk)
console.log('Speaker proof:', proof)

// 發送聊天訊息
const chatMessage = createLiveChatMessage(
  hostPk,
  eventId,
  '大家好！期待今天的分享！🎉',
  'wss://relay.example.com',
  speakerSk
)

console.log('Planned event:', plannedEvent)
console.log('Chat message:', chatMessage)

查詢直播活動

import { SimplePool } from 'nostr-tools'

const pool = new SimplePool()
const relays = ['wss://relay.example.com']

// 查詢正在直播的活動
async function getLiveEvents() {
  const events = await pool.querySync(relays, {
    kinds: [30311],
    '#status': ['live'],
  })
  return events
}

// 查詢即將開始的活動
async function getUpcomingEvents() {
  const now = Math.floor(Date.now() / 1000)
  const events = await pool.querySync(relays, {
    kinds: [30311],
    '#status': ['planned'],
  })

  // 過濾出未來的活動
  return events.filter(event => {
    const startsTag = event.tags.find(t => t[0] === 'starts')
    if (!startsTag) return true
    return parseInt(startsTag[1]) > now
  })
}

// 查詢特定活動的聊天訊息
async function getLiveChatMessages(hostPubkey: string, eventId: string) {
  const aTag = `30311:${hostPubkey}:${eventId}`
  const messages = await pool.querySync(relays, {
    kinds: [1311],
    '#a': [aTag],
  })
  return messages.sort((a, b) => a.created_at - b.created_at)
}

// 訂閱直播聊天
function subscribeLiveChat(
  hostPubkey: string,
  eventId: string,
  onMessage: (message: any) => void
) {
  const aTag = `30311:${hostPubkey}:${eventId}`

  return pool.subscribeMany(
    relays,
    [{
      kinds: [1311],
      '#a': [aTag],
      since: Math.floor(Date.now() / 1000),
    }],
    {
      onevent(event) {
        onMessage(event)
      },
    }
  )
}

// 解析直播活動
function parseLiveEvent(event: any) {
  const getTag = (name: string) =>
    event.tags.find((t: string[]) => t[0] === name)?.[1]

  const participants = event.tags
    .filter((t: string[]) => t[0] === 'p')
    .map((t: string[]) => ({
      pubkey: t[1],
      relay: t[2] || undefined,
      role: t[3] || 'Participant',
      proof: t[4] || undefined,
    }))

  return {
    id: getTag('d'),
    title: getTag('title'),
    summary: getTag('summary'),
    image: getTag('image'),
    streamingUrl: getTag('streaming'),
    recordingUrl: getTag('recording'),
    starts: getTag('starts') ? parseInt(getTag('starts')!) : undefined,
    ends: getTag('ends') ? parseInt(getTag('ends')!) : undefined,
    status: getTag('status') as LiveStatus,
    currentParticipants: getTag('current_participants')
      ? parseInt(getTag('current_participants')!)
      : undefined,
    participants,
    host: event.pubkey,
    createdAt: event.created_at,
  }
}

// 使用範例
const liveEvents = await getLiveEvents()
console.log('正在直播:', liveEvents.map(e => parseLiveEvent(e)))

const upcoming = await getUpcomingEvents()
console.log('即將開始:', upcoming.map(e => parseLiveEvent(e)))

應用場景

最佳實踐

相關 NIP

總結