@elizaos/plugin-nostr 2.0.0-alpha.7 → 2.0.0-beta.1

package/dist/index.js

@@ -1,876 +0,0 @@
-// src/index.ts
-import { logger as logger3 } from "@elizaos/core";
-
-// src/actions/publishProfile.ts
-import {
-  composePromptFromState,
-  ModelType,
-  parseJSONObjectFromText
-} from "@elizaos/core";
-
-// src/types.ts
-import { nip19 } from "nostr-tools";
-var MAX_NOSTR_MESSAGE_LENGTH = 4000;
-var NOSTR_SERVICE_NAME = "nostr";
-var DEFAULT_NOSTR_RELAYS = [
-  "wss://relay.damus.io",
-  "wss://nos.lol",
-  "wss://relay.nostr.band"
-];
-var NostrEventTypes;
-((NostrEventTypes2) => {
-  NostrEventTypes2["MESSAGE_RECEIVED"] = "NOSTR_MESSAGE_RECEIVED";
-  NostrEventTypes2["MESSAGE_SENT"] = "NOSTR_MESSAGE_SENT";
-  NostrEventTypes2["RELAY_CONNECTED"] = "NOSTR_RELAY_CONNECTED";
-  NostrEventTypes2["RELAY_DISCONNECTED"] = "NOSTR_RELAY_DISCONNECTED";
-  NostrEventTypes2["PROFILE_PUBLISHED"] = "NOSTR_PROFILE_PUBLISHED";
-  NostrEventTypes2["CONNECTION_READY"] = "NOSTR_CONNECTION_READY";
-})(NostrEventTypes ||= {});
-
-class NostrPluginError extends Error {
-  code;
-  cause;
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "NostrPluginError";
-  }
-}
-
-class NostrConfigurationError extends NostrPluginError {
-  setting;
-  constructor(message, setting, cause) {
-    super(message, "CONFIGURATION_ERROR", cause);
-    this.name = "NostrConfigurationError";
-    this.setting = setting;
-  }
-}
-
-class NostrRelayError extends NostrPluginError {
-  relay;
-  constructor(message, relay, cause) {
-    super(message, "RELAY_ERROR", cause);
-    this.name = "NostrRelayError";
-    this.relay = relay;
-  }
-}
-
-class NostrCryptoError extends NostrPluginError {
-  constructor(message, cause) {
-    super(message, "CRYPTO_ERROR", cause);
-    this.name = "NostrCryptoError";
-  }
-}
-function isValidPubkey(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  const trimmed = input.trim();
-  if (trimmed.startsWith("npub1")) {
-    try {
-      const decoded = nip19.decode(trimmed);
-      return decoded.type === "npub";
-    } catch {
-      return false;
-    }
-  }
-  return /^[0-9a-fA-F]{64}$/.test(trimmed);
-}
-function normalizePubkey(input) {
-  const trimmed = input.trim();
-  if (trimmed.startsWith("npub1")) {
-    const decoded = nip19.decode(trimmed);
-    if (decoded.type !== "npub") {
-      throw new NostrCryptoError("Invalid npub key");
-    }
-    const data = decoded.data;
-    return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  if (!/^[0-9a-fA-F]{64}$/.test(trimmed)) {
-    throw new NostrCryptoError("Pubkey must be 64 hex characters or npub format");
-  }
-  return trimmed.toLowerCase();
-}
-function pubkeyToNpub(hexPubkey) {
-  const normalized = normalizePubkey(hexPubkey);
-  return nip19.npubEncode(normalized);
-}
-function validatePrivateKey(key) {
-  const trimmed = key.trim();
-  if (trimmed.startsWith("nsec1")) {
-    const decoded = nip19.decode(trimmed);
-    if (decoded.type !== "nsec") {
-      throw new NostrCryptoError("Invalid nsec key: wrong type");
-    }
-    return decoded.data;
-  }
-  if (!/^[0-9a-fA-F]{64}$/.test(trimmed)) {
-    throw new NostrCryptoError("Private key must be 64 hex characters or nsec bech32 format");
-  }
-  const bytes = new Uint8Array(32);
-  for (let i = 0;i < 32; i++) {
-    bytes[i] = parseInt(trimmed.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function getPubkeyDisplayName(pubkey) {
-  const normalized = normalizePubkey(pubkey);
-  return `${normalized.slice(0, 8)}...${normalized.slice(-8)}`;
-}
-function splitMessageForNostr(text, maxLength = MAX_NOSTR_MESSAGE_LENGTH) {
-  if (text.length <= maxLength) {
-    return [text];
-  }
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= maxLength) {
-      chunks.push(remaining);
-      break;
-    }
-    let breakPoint = maxLength;
-    const newlineIndex = remaining.lastIndexOf(`
-`, maxLength);
-    if (newlineIndex > maxLength * 0.5) {
-      breakPoint = newlineIndex + 1;
-    } else {
-      const spaceIndex = remaining.lastIndexOf(" ", maxLength);
-      if (spaceIndex > maxLength * 0.5) {
-        breakPoint = spaceIndex + 1;
-      }
-    }
-    chunks.push(remaining.slice(0, breakPoint).trimEnd());
-    remaining = remaining.slice(breakPoint).trimStart();
-  }
-  return chunks;
-}
-
-// src/actions/publishProfile.ts
-var PUBLISH_PROFILE_TEMPLATE = `# Task: Extract Nostr profile data
-Based on the conversation, determine what profile information to update.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract any of the following profile fields that should be updated:
-- name: Display name
-- about: Bio/description
-- picture: Profile picture URL
-- banner: Banner image URL
-- nip05: Nostr verification (user@domain.com)
-- lud16: Lightning address (user@domain.com)
-- website: Website URL
-
-Respond with a JSON object containing only the fields to update:
-\`\`\`json
-{
-  "name": "optional name",
-  "about": "optional bio"
-}
-\`\`\``;
-var publishProfile = {
-  name: "NOSTR_PUBLISH_PROFILE",
-  similes: ["UPDATE_NOSTR_PROFILE", "SET_NOSTR_PROFILE", "NOSTR_PROFILE"],
-  description: "Publish or update the bot's Nostr profile (kind:0 metadata)",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "nostr";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const nostrService = runtime.getService(NOSTR_SERVICE_NAME);
-    if (!nostrService || !nostrService.isConnected()) {
-      if (callback) {
-        callback({ text: "Nostr service is not available.", source: "nostr" });
-      }
-      return { success: false, error: "Nostr service not available" };
-    }
-    const currentState = state ?? await runtime.composeState(message);
-    const prompt = await composePromptFromState({
-      template: PUBLISH_PROFILE_TEMPLATE,
-      state: currentState
-    });
-    let profileInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText(String(response));
-      if (parsed) {
-        profileInfo = {
-          name: parsed.name ? String(parsed.name) : undefined,
-          displayName: parsed.displayName ? String(parsed.displayName) : undefined,
-          about: parsed.about ? String(parsed.about) : undefined,
-          picture: parsed.picture ? String(parsed.picture) : undefined,
-          banner: parsed.banner ? String(parsed.banner) : undefined,
-          nip05: parsed.nip05 ? String(parsed.nip05) : undefined,
-          lud16: parsed.lud16 ? String(parsed.lud16) : undefined,
-          website: parsed.website ? String(parsed.website) : undefined
-        };
-        break;
-      }
-    }
-    if (!profileInfo) {
-      if (callback) {
-        callback({
-          text: "I couldn't understand the profile information. Please try again.",
-          source: "nostr"
-        });
-      }
-      return { success: false, error: "Could not extract profile parameters" };
-    }
-    const result = await nostrService.publishProfile(profileInfo);
-    if (!result.success) {
-      if (callback) {
-        callback({
-          text: `Failed to publish profile: ${result.error}`,
-          source: "nostr"
-        });
-      }
-      return { success: false, error: result.error };
-    }
-    if (callback) {
-      callback({
-        text: "Profile published successfully.",
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        eventId: result.eventId,
-        relays: result.relays,
-        profile: profileInfo
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Update your profile name to 'Bot Assistant'" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll update my Nostr profile.",
-          actions: ["NOSTR_PUBLISH_PROFILE"]
-        }
-      }
-    ]
-  ]
-};
-// src/actions/sendDm.ts
-import {
-  composePromptFromState as composePromptFromState2,
-  logger,
-  ModelType as ModelType2,
-  parseJSONObjectFromText as parseJSONObjectFromText2
-} from "@elizaos/core";
-var SEND_DM_TEMPLATE = `# Task: Extract Nostr DM parameters
-Based on the conversation, determine what message to send and to whom.
-
-Recent conversation:
-{{recentMessages}}
-
-Extract the following:
-- text: The message content to send
-- toPubkey: The target pubkey (npub or hex format, or "current" for the current conversation)
-
-Respond with a JSON object:
-\`\`\`json
-{
-  "text": "message content here",
-  "toPubkey": "npub1... or hex pubkey or current"
-}
-\`\`\``;
-var sendDm = {
-  name: "NOSTR_SEND_DM",
-  similes: ["SEND_NOSTR_DM", "NOSTR_MESSAGE", "NOSTR_TEXT", "DM_NOSTR"],
-  description: "Send an encrypted direct message via Nostr (NIP-04)",
-  validate: async (_runtime, message, _state) => {
-    return message.content.source === "nostr";
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    const nostrService = runtime.getService(NOSTR_SERVICE_NAME);
-    if (!nostrService || !nostrService.isConnected()) {
-      if (callback) {
-        callback({ text: "Nostr service is not available.", source: "nostr" });
-      }
-      return { success: false, error: "Nostr service not available" };
-    }
-    const currentState = state ?? await runtime.composeState(message);
-    const prompt = await composePromptFromState2({
-      template: SEND_DM_TEMPLATE,
-      state: currentState
-    });
-    let dmInfo = null;
-    for (let attempt = 0;attempt < 3; attempt++) {
-      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
-        prompt
-      });
-      const parsed = parseJSONObjectFromText2(String(response));
-      if (parsed?.text) {
-        dmInfo = {
-          text: String(parsed.text),
-          toPubkey: String(parsed.toPubkey || "current")
-        };
-        break;
-      }
-    }
-    if (!dmInfo || !dmInfo.text) {
-      if (callback) {
-        callback({
-          text: "I couldn't understand what message you want me to send. Please try again.",
-          source: "nostr"
-        });
-      }
-      return { success: false, error: "Could not extract message parameters" };
-    }
-    let targetPubkey;
-    if (dmInfo.toPubkey && dmInfo.toPubkey !== "current") {
-      if (isValidPubkey(dmInfo.toPubkey)) {
-        try {
-          targetPubkey = normalizePubkey(dmInfo.toPubkey);
-        } catch {}
-      }
-    }
-    if (!targetPubkey && currentState?.data?.senderPubkey) {
-      targetPubkey = currentState.data.senderPubkey;
-    }
-    if (!targetPubkey) {
-      if (callback) {
-        callback({
-          text: "I couldn't determine who to send the message to. Please specify a pubkey.",
-          source: "nostr"
-        });
-      }
-      return { success: false, error: "Could not determine target pubkey" };
-    }
-    const chunks = splitMessageForNostr(dmInfo.text);
-    let lastResult;
-    for (const chunk of chunks) {
-      const result = await nostrService.sendDm({
-        toPubkey: targetPubkey,
-        text: chunk
-      });
-      if (!result.success) {
-        if (callback) {
-          callback({
-            text: `Failed to send message: ${result.error}`,
-            source: "nostr"
-          });
-        }
-        return { success: false, error: result.error };
-      }
-      lastResult = { eventId: result.eventId, relays: result.relays };
-      logger.debug(`Sent Nostr DM: ${result.eventId}`);
-    }
-    if (callback) {
-      callback({
-        text: "Message sent successfully.",
-        source: message.content.source
-      });
-    }
-    return {
-      success: true,
-      data: {
-        toPubkey: targetPubkey,
-        eventId: lastResult?.eventId,
-        relays: lastResult?.relays,
-        chunksCount: chunks.length
-      }
-    };
-  },
-  examples: [
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Send them a message saying 'Hello!'" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll send that DM via Nostr.",
-          actions: ["NOSTR_SEND_DM"]
-        }
-      }
-    ],
-    [
-      {
-        name: "{{user1}}",
-        content: { text: "Message npub1abc... saying 'Thanks for the zap!'" }
-      },
-      {
-        name: "{{agent}}",
-        content: {
-          text: "I'll send that message to the specified pubkey.",
-          actions: ["NOSTR_SEND_DM"]
-        }
-      }
-    ]
-  ]
-};
-// src/providers/identityContext.ts
-var identityContextProvider = {
-  name: "nostrIdentityContext",
-  description: "Provides information about the bot's Nostr identity",
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "nostr") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const nostrService = runtime.getService(NOSTR_SERVICE_NAME);
-    if (!nostrService || !nostrService.isConnected()) {
-      return {
-        data: { connected: false },
-        values: { connected: false },
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const publicKey = nostrService.getPublicKey();
-    const npub = nostrService.getNpub();
-    const relays = nostrService.getRelays();
-    const responseText = `${agentName} is connected to Nostr with pubkey ${npub}. ` + `Connected to ${relays.length} relay(s): ${relays.join(", ")}. ` + `Nostr is a decentralized social protocol using cryptographic keys for identity.`;
-    return {
-      data: {
-        publicKey,
-        npub,
-        relays,
-        relayCount: relays.length,
-        connected: true
-      },
-      values: {
-        publicKey,
-        npub,
-        relayCount: relays.length
-      },
-      text: responseText
-    };
-  }
-};
-// src/providers/senderContext.ts
-var senderContextProvider = {
-  name: "nostrSenderContext",
-  description: "Provides information about the Nostr user in the current conversation",
-  get: async (runtime, message, state) => {
-    if (message.content.source !== "nostr") {
-      return {
-        data: {},
-        values: {},
-        text: ""
-      };
-    }
-    const nostrService = runtime.getService(NOSTR_SERVICE_NAME);
-    if (!nostrService || !nostrService.isConnected()) {
-      return {
-        data: { connected: false },
-        values: { connected: false },
-        text: ""
-      };
-    }
-    const agentName = state?.agentName || "The agent";
-    const senderPubkey = state?.data?.senderPubkey;
-    if (!senderPubkey) {
-      return {
-        data: { connected: true },
-        values: { connected: true },
-        text: ""
-      };
-    }
-    let senderNpub = "";
-    try {
-      senderNpub = pubkeyToNpub(senderPubkey);
-    } catch {}
-    const displayName = getPubkeyDisplayName(senderPubkey);
-    const responseText = `${agentName} is talking to ${displayName} on Nostr. ` + `Their pubkey is ${senderNpub || senderPubkey}. ` + `This is an encrypted direct message conversation using NIP-04.`;
-    return {
-      data: {
-        senderPubkey,
-        senderNpub,
-        displayName,
-        isEncrypted: true
-      },
-      values: {
-        senderPubkey,
-        senderNpub,
-        displayName
-      },
-      text: responseText
-    };
-  }
-};
-// src/service.ts
-import {
-  logger as logger2,
-  Service
-} from "@elizaos/core";
-import {
-  finalizeEvent,
-  getPublicKey,
-  SimplePool,
-  verifyEvent
-} from "nostr-tools";
-import { decrypt, encrypt } from "nostr-tools/nip04";
-class NostrService extends Service {
-  static serviceType = NOSTR_SERVICE_NAME;
-  capabilityDescription = "Provides Nostr protocol integration for encrypted direct messages";
-  settings = null;
-  pool = null;
-  privateKey = null;
-  connected = false;
-  seenEventIds = new Set;
-  static async start(runtime) {
-    logger2.info("Starting Nostr service...");
-    const service = new NostrService(runtime);
-    await service.initialize();
-    return service;
-  }
-  async initialize() {
-    this.settings = this.loadSettings();
-    this.validateSettings();
-    this.privateKey = validatePrivateKey(this.settings.privateKey);
-    this.pool = new SimplePool;
-    await this.startSubscription();
-    this.connected = true;
-    logger2.info(`Nostr service started (pubkey: ${this.settings.publicKey.slice(0, 16)}...)`);
-    this.runtime.emitEvent("NOSTR_CONNECTION_READY" /* CONNECTION_READY */, {
-      runtime: this.runtime,
-      service: this
-    });
-  }
-  async stop() {
-    logger2.info("Stopping Nostr service...");
-    this.connected = false;
-    if (this.pool) {
-      this.pool.close(this.settings?.relays || []);
-      this.pool = null;
-    }
-    this.privateKey = null;
-    this.seenEventIds.clear();
-    logger2.info("Nostr service stopped");
-  }
-  loadSettings() {
-    const runtime = this.runtime;
-    if (!runtime) {
-      throw new NostrConfigurationError("Runtime not initialized");
-    }
-    const privateKeySetting = runtime.getSetting("NOSTR_PRIVATE_KEY");
-    const privateKey = typeof privateKeySetting === "string" ? privateKeySetting : process.env.NOSTR_PRIVATE_KEY || "";
-    const relaysRawSetting = runtime.getSetting("NOSTR_RELAYS");
-    const relaysRaw = typeof relaysRawSetting === "string" ? relaysRawSetting : process.env.NOSTR_RELAYS || "";
-    const dmPolicySetting = runtime.getSetting("NOSTR_DM_POLICY");
-    const dmPolicy = typeof dmPolicySetting === "string" ? dmPolicySetting : process.env.NOSTR_DM_POLICY || "pairing";
-    const allowFromRawSetting = runtime.getSetting("NOSTR_ALLOW_FROM");
-    const allowFromRaw = typeof allowFromRawSetting === "string" ? allowFromRawSetting : process.env.NOSTR_ALLOW_FROM || "";
-    const enabledSetting = runtime.getSetting("NOSTR_ENABLED");
-    const enabled = typeof enabledSetting === "string" ? enabledSetting : process.env.NOSTR_ENABLED || "true";
-    const relays = relaysRaw ? relaysRaw.split(",").map((r) => r.trim()).filter(Boolean) : DEFAULT_NOSTR_RELAYS;
-    const allowFrom = allowFromRaw ? allowFromRaw.split(",").map((p) => {
-      try {
-        return normalizePubkey(p.trim());
-      } catch {
-        return p.trim();
-      }
-    }).filter(Boolean) : [];
-    let publicKey = "";
-    if (privateKey) {
-      try {
-        const sk = validatePrivateKey(privateKey);
-        publicKey = getPublicKey(sk);
-      } catch {}
-    }
-    return {
-      privateKey,
-      publicKey,
-      relays,
-      dmPolicy,
-      allowFrom,
-      enabled: enabled.toLowerCase() !== "false"
-    };
-  }
-  validateSettings() {
-    const settings = this.settings;
-    if (!settings) {
-      throw new NostrConfigurationError("Settings not loaded");
-    }
-    if (!settings.privateKey) {
-      throw new NostrConfigurationError("NOSTR_PRIVATE_KEY is required", "NOSTR_PRIVATE_KEY");
-    }
-    if (!settings.publicKey) {
-      throw new NostrConfigurationError("Invalid private key - could not derive public key", "NOSTR_PRIVATE_KEY");
-    }
-    if (settings.relays.length === 0) {
-      throw new NostrConfigurationError("At least one relay is required", "NOSTR_RELAYS");
-    }
-    for (const relay of settings.relays) {
-      if (!relay.startsWith("wss://") && !relay.startsWith("ws://")) {
-        throw new NostrConfigurationError(`Invalid relay URL: ${relay}`, "NOSTR_RELAYS");
-      }
-    }
-  }
-  async startSubscription() {
-    const settings = this.settings;
-    const pool = this.pool;
-    const privateKey = this.privateKey;
-    if (!settings || !pool || !privateKey) {
-      throw new NostrConfigurationError("Service not properly initialized");
-    }
-    const pk = settings.publicKey;
-    const since = Math.floor(Date.now() / 1000) - 120;
-    const filter = { kinds: [4], "#p": [pk], since };
-    pool.subscribeMany(settings.relays, [filter], {
-      onevent: async (event) => {
-        await this.handleEvent(event);
-      },
-      oneose: () => {
-        logger2.debug("Nostr EOSE received - initial sync complete");
-      }
-    });
-    logger2.info(`Subscribed to ${settings.relays.length} relay(s)`);
-  }
-  async handleEvent(event) {
-    const settings = this.settings;
-    const privateKey = this.privateKey;
-    if (!settings || !privateKey) {
-      return;
-    }
-    if (this.seenEventIds.has(event.id)) {
-      return;
-    }
-    this.seenEventIds.add(event.id);
-    if (this.seenEventIds.size > 1e4) {
-      const toDelete = Array.from(this.seenEventIds).slice(0, 5000);
-      for (const id of toDelete) {
-        this.seenEventIds.delete(id);
-      }
-    }
-    if (event.pubkey === settings.publicKey) {
-      return;
-    }
-    if (!verifyEvent(event)) {
-      logger2.warn(`Invalid signature on event ${event.id}`);
-      return;
-    }
-    const isToUs = event.tags.some((t) => t[0] === "p" && t[1] === settings.publicKey);
-    if (!isToUs) {
-      return;
-    }
-    if (settings.dmPolicy === "disabled") {
-      logger2.debug(`DM from ${event.pubkey} blocked - DMs disabled`);
-      return;
-    }
-    if (settings.dmPolicy === "allowlist") {
-      const allowed = settings.allowFrom.includes(event.pubkey);
-      if (!allowed) {
-        logger2.debug(`DM from ${event.pubkey} blocked - not in allowlist`);
-        return;
-      }
-    }
-    let plaintext;
-    try {
-      plaintext = decrypt(privateKey, event.pubkey, event.content);
-    } catch (err) {
-      logger2.warn(`Failed to decrypt DM from ${event.pubkey}: ${err}`);
-      return;
-    }
-    logger2.debug(`Received DM from ${event.pubkey.slice(0, 8)}...: ${plaintext.slice(0, 50)}...`);
-    if (this.runtime) {
-      this.runtime.emitEvent("NOSTR_MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */, {
-        runtime: this.runtime,
-        from: event.pubkey,
-        text: plaintext,
-        eventId: event.id,
-        createdAt: event.created_at
-      });
-    }
-  }
-  isConnected() {
-    return this.connected;
-  }
-  getPublicKey() {
-    return this.settings?.publicKey || "";
-  }
-  getNpub() {
-    const pk = this.getPublicKey();
-    return pk ? pubkeyToNpub(pk) : "";
-  }
-  getRelays() {
-    return this.settings?.relays || [];
-  }
-  async sendDm(options) {
-    const settings = this.settings;
-    const pool = this.pool;
-    const privateKey = this.privateKey;
-    if (!settings || !pool || !privateKey) {
-      return {
-        success: false,
-        error: "Service not initialized"
-      };
-    }
-    let toPubkey;
-    try {
-      toPubkey = normalizePubkey(options.toPubkey);
-    } catch (err) {
-      return {
-        success: false,
-        error: `Invalid target pubkey: ${err}`
-      };
-    }
-    let ciphertext;
-    try {
-      ciphertext = encrypt(privateKey, toPubkey, options.text);
-    } catch (err) {
-      return {
-        success: false,
-        error: `Encryption failed: ${err}`
-      };
-    }
-    const event = finalizeEvent({
-      kind: 4,
-      content: ciphertext,
-      tags: [["p", toPubkey]],
-      created_at: Math.floor(Date.now() / 1000)
-    }, privateKey);
-    const successRelays = [];
-    const errors = [];
-    for (const relay of settings.relays) {
-      try {
-        await pool.publish([relay], event);
-        successRelays.push(relay);
-      } catch (err) {
-        errors.push(`${relay}: ${err}`);
-      }
-    }
-    if (successRelays.length === 0) {
-      return {
-        success: false,
-        error: `Failed to publish to any relay: ${errors.join("; ")}`
-      };
-    }
-    logger2.debug(`DM sent to ${toPubkey.slice(0, 8)}... via ${successRelays.length} relay(s)`);
-    if (this.runtime) {
-      this.runtime.emitEvent("NOSTR_MESSAGE_SENT" /* MESSAGE_SENT */, {
-        runtime: this.runtime,
-        to: toPubkey,
-        eventId: event.id,
-        relays: successRelays
-      });
-    }
-    return {
-      success: true,
-      eventId: event.id,
-      relays: successRelays
-    };
-  }
-  async publishProfile(profile) {
-    const settings = this.settings;
-    const pool = this.pool;
-    const privateKey = this.privateKey;
-    if (!settings || !pool || !privateKey) {
-      return {
-        success: false,
-        error: "Service not initialized"
-      };
-    }
-    const content = JSON.stringify({
-      name: profile.name,
-      display_name: profile.displayName,
-      about: profile.about,
-      picture: profile.picture,
-      banner: profile.banner,
-      nip05: profile.nip05,
-      lud16: profile.lud16,
-      website: profile.website
-    });
-    const event = finalizeEvent({
-      kind: 0,
-      content,
-      tags: [],
-      created_at: Math.floor(Date.now() / 1000)
-    }, privateKey);
-    const successRelays = [];
-    const errors = [];
-    for (const relay of settings.relays) {
-      try {
-        await pool.publish([relay], event);
-        successRelays.push(relay);
-      } catch (err) {
-        errors.push(`${relay}: ${err}`);
-      }
-    }
-    if (successRelays.length === 0) {
-      return {
-        success: false,
-        error: `Failed to publish profile to any relay: ${errors.join("; ")}`
-      };
-    }
-    logger2.info(`Profile published via ${successRelays.length} relay(s)`);
-    if (this.runtime) {
-      this.runtime.emitEvent("NOSTR_PROFILE_PUBLISHED" /* PROFILE_PUBLISHED */, {
-        runtime: this.runtime,
-        eventId: event.id,
-        relays: successRelays
-      });
-    }
-    return {
-      success: true,
-      eventId: event.id,
-      relays: successRelays
-    };
-  }
-  getSettings() {
-    return this.settings;
-  }
-}
-// src/index.ts
-var nostrPlugin = {
-  name: "nostr",
-  description: "Nostr decentralized messaging plugin for ElizaOS agents",
-  services: [NostrService],
-  actions: [sendDm, publishProfile],
-  providers: [identityContextProvider, senderContextProvider],
-  tests: [],
-  init: async (config, _runtime) => {
-    logger3.info("Initializing Nostr plugin...");
-    const hasPrivateKey = Boolean(config.NOSTR_PRIVATE_KEY || process.env.NOSTR_PRIVATE_KEY);
-    const relaysRaw = config.NOSTR_RELAYS || process.env.NOSTR_RELAYS || "";
-    const relays = relaysRaw ? relaysRaw.split(",").length : DEFAULT_NOSTR_RELAYS.length;
-    logger3.info(`Nostr plugin configuration:`);
-    logger3.info(`  - Private key configured: ${hasPrivateKey ? "Yes" : "No"}`);
-    logger3.info(`  - Relays: ${relays} relay(s)`);
-    logger3.info(`  - DM policy: ${config.NOSTR_DM_POLICY || process.env.NOSTR_DM_POLICY || "pairing"}`);
-    if (!hasPrivateKey) {
-      logger3.warn("Nostr private key not configured. Set NOSTR_PRIVATE_KEY (hex or nsec format).");
-    }
-    logger3.info("Nostr plugin initialized");
-  }
-};
-var src_default = nostrPlugin;
-export {
-  validatePrivateKey,
-  splitMessageForNostr,
-  senderContextProvider,
-  sendDm,
-  publishProfile,
-  pubkeyToNpub,
-  normalizePubkey,
-  isValidPubkey,
-  identityContextProvider,
-  getPubkeyDisplayName,
-  src_default as default,
-  NostrService,
-  NostrRelayError,
-  NostrPluginError,
-  NostrEventTypes,
-  NostrCryptoError,
-  NostrConfigurationError,
-  NOSTR_SERVICE_NAME,
-  MAX_NOSTR_MESSAGE_LENGTH,
-  DEFAULT_NOSTR_RELAYS
-};
-
-//# debugId=210FEFBBF268CA8064756E2164756E21