node-red-contrib-nostr 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Humanjava Enterprises
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,222 @@
+# node-red-contrib-nostr
+
+[![npm version](https://badge.fury.io/js/node-red-contrib-nostr.svg)](https://badge.fury.io/js/node-red-contrib-nostr)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node-RED](https://img.shields.io/badge/Node--RED-Contribution-red.svg)](https://flows.nodered.org/node/node-red-contrib-nostr)
+[![Tests](https://github.com/HumanjavaEnterprises/node-red-contrib-nostr/actions/workflows/test.yml/badge.svg)](https://github.com/HumanjavaEnterprises/node-red-contrib-nostr/actions/workflows/test.yml)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+[![Known Vulnerabilities](https://snyk.io/test/github/HumanJavaEnterprise/node-red-contrib-nostr/badge.svg)](https://snyk.io/test/github/HumanJavaEnterprise/node-red-contrib-nostr)
+
+A [Node-RED](http://nodered.org) node for integrating with the Nostr protocol. This node allows you to connect to Nostr relays, publish events, and subscribe to events in the Nostr network.
+
+## ⚠️ Security Note
+
+A private key is **only required** if you want to:
+- Publish events to relays
+- Send encrypted direct messages
+- Perform any action that requires signing
+
+For just listening to relays or subscribing to events, **no private key is needed**.
+
+If you do need to publish events, follow these security guidelines:
+
+1. Generate a separate key pair specifically for your Node-RED automation using services like:
+   - [nsec.app](https://nsec.app/)
+   - [Alby](https://getalby.com/)
+   - [Nostr.band](https://nostr.band/)
+
+2. Keep the scope of this automation key limited:
+   - Only give it permissions it actually needs
+   - Consider it like a "bot account"
+   - Regularly rotate the key if possible
+
+3. Store the private key securely:
+   - Use Node-RED's encrypted credentials
+   - Never share or expose the key
+   - Don't commit it to version control
+
+## Description
+
+This package provides nodes for interacting with Nostr relays, allowing you to:
+- Connect to multiple relays simultaneously
+- Monitor specific NPUBs for events
+- Filter events by type (text notes, DMs, etc.)
+- Post events to relays (using a dedicated automation key)
+- Support for multiple NIPs (see Supported NIPs section)
+- TypeScript support with full type definitions
+- Secure credential management
+- Automatic reconnection handling
+
+## Technical Architecture
+
+### Module System
+This package uses a hybrid approach to module systems to ensure maximum compatibility:
+- Built as CommonJS for Node-RED compatibility
+- Handles ESM dependencies through dynamic imports
+- Supports both modern and legacy Node.js environments
+
+### WebSocket Management
+Built on [nostr-websocket-utils](https://github.com/yourusername/nostr-websocket-utils) for enterprise-grade reliability:
+- **Automatic Reconnection**: Smart backoff strategy for connection drops
+- **Connection Health**: Built-in heartbeat monitoring
+- **Type Safety**: Full TypeScript support
+- **Error Resilience**: Comprehensive error handling
+- **Memory Efficient**: Proper cleanup of resources
+- **Debug Support**: Detailed logging
+
+## Install
+
+### From npm (Recommended)
+Run the following command in your Node-RED user directory - typically `~/.node-red`
+
+```bash
+npm install node-red-contrib-nostr
+```
+
+### From Source
+```bash
+cd ~/.node-red
+git clone https://github.com/HumanjavaEnterprises/node-red-contrib-nostr.git
+cd node-red-contrib-nostr
+npm install
+npm run build
+```
+
+### Using Docker
+```bash
+git clone https://github.com/HumanjavaEnterprises/node-red-contrib-nostr.git
+cd node-red-contrib-nostr
+docker compose up -d
+```
+
+## Nodes
+
+### 1. Nostr Relay Config Node
+Configuration node for managing relay connections:
+- Multiple relay support
+- Secure private key storage
+- Automatic reconnection handling
+- Connection status monitoring
+- Dynamic import of ESM dependencies
+
+### 2. Nostr Filter Node
+Specialized node for event filtering:
+- Filter by event kinds
+- Filter by authors (NPUBs)
+- Filter by tags
+- Time-based filtering
+- Custom filter combinations
+- Real-time event processing
+
+### 3. Nostr NPUB Filter Node
+Dedicated node for NPUB-based filtering:
+- Monitor specific NPUBs
+- Filter by event types
+- Real-time NPUB event tracking
+- Automatic hex key conversion
+
+## Example Flows
+
+### Basic Event Monitoring
+```json
+{
+    "id": "basic-monitor",
+    "type": "nostr-filter",
+    "relay": "wss://relay.example.com",
+    "filterType": "kind",
+    "eventKinds": [1],
+    "wires": [["debug"]]
+}
+```
+
+### NPUB Tracking
+```json
+{
+    "id": "npub-track",
+    "type": "nostr-npub-filter",
+    "relay": "wss://relay.example.com",
+    "npubValue": "npub1...",
+    "eventKinds": [1, 6],
+    "wires": [["debug"]]
+}
+```
+
+## Error Handling
+
+The nodes implement comprehensive error handling:
+- Invalid private key detection
+- Relay connection failures
+- Message parsing errors
+- NPUB validation
+- WebSocket connection issues
+
+## Development
+
+### Building from Source
+```bash
+npm install
+npm run build
+```
+
+### Running Tests
+```bash
+npm test
+```
+
+Test coverage includes:
+- Unit tests for all nodes
+- WebSocket connection handling
+- Event filtering logic
+- Error handling
+
+### Docker Development
+```bash
+docker compose -f docker-compose.dev.yml up
+```
+
+## Supported NIPs
+
+| NIP | Description | Status |
+|-----|------------|--------|
+| [NIP-01](https://github.com/nostr-protocol/nips/blob/master/01.md) | Basic Protocol | ✅ Implemented |
+| [NIP-02](https://github.com/nostr-protocol/nips/blob/master/02.md) | Contact List and Petnames | ✅ Implemented |
+| [NIP-03](https://github.com/nostr-protocol/nips/blob/master/03.md) | OpenTimestamps Attestations | 🚧 Planned |
+| [NIP-04](https://github.com/nostr-protocol/nips/blob/master/04.md) | Encrypted Direct Messages | 🚧 Planned |
+| [NIP-09](https://github.com/nostr-protocol/nips/blob/master/09.md) | Event Deletion | 🚧 Planned |
+| [NIP-11](https://github.com/nostr-protocol/nips/blob/master/11.md) | Relay Information Document | ✅ Implemented |
+| [NIP-15](https://github.com/nostr-protocol/nips/blob/master/15.md) | End of Stored Events Notice | ✅ Implemented |
+| [NIP-20](https://github.com/nostr-protocol/nips/blob/master/20.md) | Command Results | ✅ Implemented |
+| [NIP-28](https://github.com/nostr-protocol/nips/blob/master/28.md) | Public Chat | 🚧 Planned |
+| [NIP-40](https://github.com/nostr-protocol/nips/blob/master/40.md) | Expiration Timestamp | 🚧 Planned |
+
+Legend:
+- ✅ Implemented: Fully supported
+- 🚧 Planned: On the roadmap
+- ❌ Not Planned: Not currently planned for implementation
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'feat: add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Node-RED Specific Tags
+
+This module provides nodes for working with Nostr protocol in Node-RED.
+
+### Node Properties
+
+* Category: network
+* Name: node-red-contrib-nostr
+* Types: nostr-relay-config, nostr-filter, nostr-npub-filter
+* Description: Node-RED nodes for interacting with Nostr protocol
+* Author: Vveerrgg
+* Keywords: node-red,nostr,websocket,relay,filter,npub
+* Dependencies: @humanjavaenterprises/nostr-tools,nostr-websocket-utils
+* Node-RED: >= 2.0.0

package/dist/core/event.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from '../nodes/shared/types';
+export declare class EventBuilder {
+    private static keyManager;
+    static createEvent(kind: number, content: string, privateKey: string, tags?: string[][]): Promise<NostrEvent>;
+    static validateEvent(event: NostrEvent): Promise<boolean>;
+}

package/dist/core/event.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBuilder = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_1 = require("@noble/hashes/utils");
+const keys_1 = require("../crypto/keys");
+class EventBuilder {
+    static async createEvent(kind, content, privateKey, tags = []) {
+        const pubkey = await this.keyManager.getPublicKey(privateKey);
+        const created_at = Math.floor(Date.now() / 1000);
+        const event = {
+            kind,
+            content,
+            created_at,
+            pubkey,
+            tags,
+            id: '',
+            sig: ''
+        };
+        // Calculate event ID
+        const serialized = JSON.stringify([
+            0,
+            event.pubkey,
+            event.created_at,
+            event.kind,
+            event.tags,
+            event.content
+        ]);
+        event.id = (0, utils_1.bytesToHex)((0, sha256_1.sha256)(Buffer.from(serialized)));
+        // Sign the event
+        event.sig = await this.keyManager.sign(privateKey, event.id);
+        return event;
+    }
+    static async validateEvent(event) {
+        // Verify all required fields exist
+        if (!event.id || !event.pubkey || !event.created_at ||
+            !event.kind || !event.tags || !event.content || !event.sig) {
+            return false;
+        }
+        // Verify event ID
+        const serialized = JSON.stringify([
+            0,
+            event.pubkey,
+            event.created_at,
+            event.kind,
+            event.tags,
+            event.content
+        ]);
+        const id = (0, utils_1.bytesToHex)((0, sha256_1.sha256)(Buffer.from(serialized)));
+        if (id !== event.id) {
+            return false;
+        }
+        // Verify signature
+        return await this.keyManager.verify(event.pubkey, event.id, event.sig);
+    }
+}
+exports.EventBuilder = EventBuilder;
+EventBuilder.keyManager = new keys_1.KeyManager();

package/dist/core/filter.d.ts

@@ -0,0 +1,14 @@
+import { NostrFilter } from '../nodes/shared/types';
+export declare class FilterBuilder {
+    private filter;
+    withIds(ids: string[]): FilterBuilder;
+    withAuthors(authors: string[]): FilterBuilder;
+    withKinds(kinds: number[]): FilterBuilder;
+    withSince(timestamp: number): FilterBuilder;
+    withUntil(timestamp: number): FilterBuilder;
+    withLimit(limit: number): FilterBuilder;
+    withSearch(search: string): FilterBuilder;
+    build(): NostrFilter;
+    static createTextNoteFilter(limit?: number): NostrFilter;
+    static createUserMetadataFilter(pubkeys: string[]): NostrFilter;
+}

package/dist/core/filter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterBuilder = void 0;
+class FilterBuilder {
+    constructor() {
+        this.filter = {};
+    }
+    withIds(ids) {
+        this.filter.ids = ids;
+        return this;
+    }
+    withAuthors(authors) {
+        this.filter.authors = authors;
+        return this;
+    }
+    withKinds(kinds) {
+        this.filter.kinds = kinds;
+        return this;
+    }
+    withSince(timestamp) {
+        this.filter.since = timestamp;
+        return this;
+    }
+    withUntil(timestamp) {
+        this.filter.until = timestamp;
+        return this;
+    }
+    withLimit(limit) {
+        this.filter.limit = limit;
+        return this;
+    }
+    withSearch(search) {
+        this.filter.search = search;
+        return this;
+    }
+    build() {
+        return { ...this.filter };
+    }
+    static createTextNoteFilter(limit = 10) {
+        return new FilterBuilder()
+            .withKinds([1])
+            .withLimit(limit)
+            .build();
+    }
+    static createUserMetadataFilter(pubkeys) {
+        return new FilterBuilder()
+            .withKinds([0])
+            .withAuthors(pubkeys)
+            .build();
+    }
+}
+exports.FilterBuilder = FilterBuilder;

package/dist/crypto/keys.d.ts

@@ -0,0 +1,38 @@
+export declare const DEFAULT_READER_KEYS: {
+    privateKey: string;
+    publicKey: string;
+};
+/**
+ * Generate a new Nostr key pair
+ * @returns {Promise<Object>} Object containing private and public keys
+ */
+export declare function generateKeyPair(): Promise<{
+    privateKey: string;
+    publicKey: string;
+}>;
+/**
+ * Convert a hex public key to npub format
+ * @param {string} publicKeyHex - Public key in hex format
+ * @returns {string} npub formatted public key
+ */
+export declare function hexToNpub(publicKeyHex: string): string;
+/**
+ * Convert an npub to hex format
+ * @param {string} npub - npub formatted public key
+ * @returns {string} Public key in hex format
+ */
+export declare function npubToHex(npub: string): string;
+/**
+ * Get public key from private key
+ * @param {string} privateKeyHex - Private key in hex format
+ * @returns {Promise<string>} Public key in hex format
+ */
+export declare function getPublicKey(privateKeyHex: string): Promise<string>;
+export declare class KeyManager {
+    private secp256k1Promise;
+    constructor();
+    generatePrivateKey(): Promise<string>;
+    getPublicKey(privateKey: string): Promise<string>;
+    sign(privateKey: string, message: string): Promise<string>;
+    verify(publicKey: string, message: string, signature: string): Promise<boolean>;
+}

package/dist/crypto/keys.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyManager = exports.DEFAULT_READER_KEYS = void 0;
+exports.generateKeyPair = generateKeyPair;
+exports.hexToNpub = hexToNpub;
+exports.npubToHex = npubToHex;
+exports.getPublicKey = getPublicKey;
+const bech32_1 = require("bech32");
+const utils_1 = require("@noble/hashes/utils");
+const sha256_1 = require("@noble/hashes/sha256");
+// Default read-only key pair for basic operations
+// This is a dedicated key for node-red-contrib-nostr that's only used for reading events
+exports.DEFAULT_READER_KEYS = {
+    privateKey: '5acf32b3374c8c0aa6e483e0f7c6ba8c4b2d2f35d1d5854f08c8c9555d81903b',
+    publicKey: '04dbc5c6c357e5f33e19c89a2c0b2c1c41f7b15cc3e8f6a63f5e0e8c5d5c5c5c',
+};
+let secp256k1;
+async function initSecp256k1() {
+    if (!secp256k1) {
+        secp256k1 = await Promise.resolve().then(() => __importStar(require('@noble/secp256k1')));
+    }
+    return secp256k1;
+}
+/**
+ * Generate a new Nostr key pair
+ * @returns {Promise<Object>} Object containing private and public keys
+ */
+async function generateKeyPair() {
+    const secp = await initSecp256k1();
+    const privateKey = secp.utils.randomPrivateKey();
+    const publicKey = secp.getPublicKey(privateKey, true);
+    return {
+        privateKey: Buffer.from(privateKey).toString('hex'),
+        publicKey: Buffer.from(publicKey).toString('hex')
+    };
+}
+/**
+ * Convert a hex public key to npub format
+ * @param {string} publicKeyHex - Public key in hex format
+ * @returns {string} npub formatted public key
+ */
+function hexToNpub(publicKeyHex) {
+    const words = bech32_1.bech32.toWords(Buffer.from(publicKeyHex, 'hex'));
+    return bech32_1.bech32.encode('npub', words);
+}
+/**
+ * Convert an npub to hex format
+ * @param {string} npub - npub formatted public key
+ * @returns {string} Public key in hex format
+ */
+function npubToHex(npub) {
+    const { words } = bech32_1.bech32.decode(npub);
+    return Buffer.from(bech32_1.bech32.fromWords(words)).toString('hex');
+}
+/**
+ * Get public key from private key
+ * @param {string} privateKeyHex - Private key in hex format
+ * @returns {Promise<string>} Public key in hex format
+ */
+async function getPublicKey(privateKeyHex) {
+    const secp = await initSecp256k1();
+    const publicKey = secp.getPublicKey(privateKeyHex, true);
+    return Buffer.from(publicKey).toString('hex');
+}
+class KeyManager {
+    constructor() {
+        this.secp256k1Promise = initSecp256k1();
+    }
+    async generatePrivateKey() {
+        const secp = await this.secp256k1Promise;
+        const privateKey = secp.utils.randomPrivateKey();
+        return Buffer.from(privateKey).toString('hex');
+    }
+    async getPublicKey(privateKey) {
+        const secp = await this.secp256k1Promise;
+        const publicKey = secp.getPublicKey(privateKey, true);
+        return Buffer.from(publicKey).toString('hex');
+    }
+    async sign(privateKey, message) {
+        const secp = await this.secp256k1Promise;
+        const messageHash = (0, sha256_1.sha256)(Buffer.from(message));
+        const signature = await secp.sign(messageHash, privateKey);
+        return (0, utils_1.bytesToHex)(signature.toCompactRawBytes());
+    }
+    async verify(publicKey, message, signature) {
+        const secp = await this.secp256k1Promise;
+        const messageHash = (0, sha256_1.sha256)(Buffer.from(message));
+        return secp.verify(signature, messageHash, publicKey);
+    }
+}
+exports.KeyManager = KeyManager;

package/dist/nips/nip01.d.ts

@@ -0,0 +1,22 @@
+import { NostrEvent, NostrFilter } from '../nodes/shared/types';
+export declare enum MessageType {
+    EVENT = "EVENT",
+    REQ = "REQ",
+    CLOSE = "CLOSE",
+    NOTICE = "NOTICE",
+    EOSE = "EOSE",
+    OK = "OK"
+}
+export interface RelayMessage {
+    type: MessageType;
+    subscriptionId?: string;
+    event?: NostrEvent;
+    message?: string;
+    filters?: NostrFilter[];
+    success?: boolean;
+    error?: string;
+}
+export declare function parseRelayMessage(message: string): RelayMessage | null;
+export declare function createEventMessage(event: NostrEvent): string;
+export declare function createSubscriptionMessage(subscriptionId: string, filters: NostrFilter[]): string;
+export declare function createCloseMessage(subscriptionId: string): string;

package/dist/nips/nip01.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageType = void 0;
+exports.parseRelayMessage = parseRelayMessage;
+exports.createEventMessage = createEventMessage;
+exports.createSubscriptionMessage = createSubscriptionMessage;
+exports.createCloseMessage = createCloseMessage;
+var MessageType;
+(function (MessageType) {
+    MessageType["EVENT"] = "EVENT";
+    MessageType["REQ"] = "REQ";
+    MessageType["CLOSE"] = "CLOSE";
+    MessageType["NOTICE"] = "NOTICE";
+    MessageType["EOSE"] = "EOSE";
+    MessageType["OK"] = "OK";
+})(MessageType || (exports.MessageType = MessageType = {}));
+function parseRelayMessage(message) {
+    try {
+        const parsed = JSON.parse(message);
+        if (!Array.isArray(parsed))
+            return null;
+        const [type, ...params] = parsed;
+        switch (type) {
+            case MessageType.EVENT:
+                const [subscriptionId, event] = params;
+                return {
+                    type: MessageType.EVENT,
+                    subscriptionId,
+                    event
+                };
+            case MessageType.NOTICE:
+                return {
+                    type: MessageType.NOTICE,
+                    message: params[0]
+                };
+            case MessageType.EOSE:
+                return {
+                    type: MessageType.EOSE,
+                    subscriptionId: params[0]
+                };
+            case MessageType.OK:
+                const [eventId, success, message] = params;
+                return {
+                    type: MessageType.OK,
+                    message: eventId,
+                    success,
+                    error: message
+                };
+            default:
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function createEventMessage(event) {
+    return JSON.stringify([MessageType.EVENT, event]);
+}
+function createSubscriptionMessage(subscriptionId, filters) {
+    return JSON.stringify([MessageType.REQ, subscriptionId, ...filters]);
+}
+function createCloseMessage(subscriptionId) {
+    return JSON.stringify([MessageType.CLOSE, subscriptionId]);
+}

package/dist/nips/nip02.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from '../nodes/shared/types';
+export interface Contact {
+    pubkey: string;
+    relayUrl: string;
+    petname?: string;
+}
+export declare class ContactList {
+    static parseContactList(event: NostrEvent): Contact[];
+    static createContactListEvent(contacts: Contact[], privateKey: string): Promise<NostrEvent>;
+    static getContactListFilter(pubkey: string): {
+        kinds: number[];
+        authors: string[];
+        limit: number;
+    };
+}

package/dist/nips/nip02.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactList = void 0;
+const event_1 = require("../core/event");
+class ContactList {
+    static parseContactList(event) {
+        if (event.kind !== 3)
+            throw new Error('Not a contact list event');
+        return event.tags
+            .filter(tag => tag[0] === 'p')
+            .map(tag => ({
+            pubkey: tag[1],
+            relayUrl: tag[2] || '',
+            petname: tag[3]
+        }));
+    }
+    static async createContactListEvent(contacts, privateKey) {
+        const tags = contacts.map(contact => [
+            'p',
+            contact.pubkey,
+            contact.relayUrl,
+            contact.petname || ''
+        ]);
+        return await event_1.EventBuilder.createEvent(3, '', // Content can be empty or contain additional metadata
+        privateKey, tags);
+    }
+    static getContactListFilter(pubkey) {
+        return {
+            kinds: [3],
+            authors: [pubkey],
+            limit: 1
+        };
+    }
+}
+exports.ContactList = ContactList;