node-red-contrib-nostr 0.1.0

package/dist/nips/nip04.d.ts

@@ -0,0 +1,8 @@
+import { NostrEvent } from '../nodes/shared/types';
+export declare class NIP04 {
+    static encrypt(privateKey: string, publicKey: string, text: string): Promise<string>;
+    static decrypt(privateKey: string, publicKey: string, encryptedText: string): Promise<string>;
+    static createEncryptedEvent(recipientPubkey: string, content: string, privateKey: string): Promise<NostrEvent>;
+    static decryptEvent(event: NostrEvent, privateKey: string): Promise<string>;
+    static getDMFilter(pubkey: string, otherPubkey?: string): any;
+}

package/dist/nips/nip04.js

@@ -0,0 +1,89 @@
+"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.NIP04 = void 0;
+const secp256k1 = __importStar(require("@noble/secp256k1"));
+const utils_1 = require("@noble/hashes/utils");
+const sha256_1 = require("@noble/hashes/sha256");
+const event_1 = require("../core/event");
+class NIP04 {
+    static async encrypt(privateKey, publicKey, text) {
+        const sharedPoint = secp256k1.getSharedSecret((0, utils_1.hexToBytes)(privateKey), (0, utils_1.hexToBytes)(publicKey));
+        const sharedX = sharedPoint.slice(1, 33);
+        // In a real implementation, we'd use this shared secret with
+        // proper encryption. This is just a placeholder.
+        const key = (0, sha256_1.sha256)(sharedX);
+        // TODO: Implement actual encryption using AES-256-CBC
+        return (0, utils_1.bytesToHex)(key);
+    }
+    static async decrypt(privateKey, publicKey, encryptedText) {
+        const sharedPoint = secp256k1.getSharedSecret((0, utils_1.hexToBytes)(privateKey), (0, utils_1.hexToBytes)(publicKey));
+        const sharedX = sharedPoint.slice(1, 33);
+        // TODO: Implement actual decryption using AES-256-CBC
+        return "decrypted text";
+    }
+    static async createEncryptedEvent(recipientPubkey, content, privateKey) {
+        const encryptedContent = await this.encrypt(privateKey, recipientPubkey, content);
+        const tags = [['p', recipientPubkey]];
+        return await event_1.EventBuilder.createEvent(4, // NIP-04 Direct Message kind
+        encryptedContent, privateKey, tags);
+    }
+    static async decryptEvent(event, privateKey) {
+        if (event.kind !== 4)
+            throw new Error('Not a DM event');
+        const recipientTag = event.tags.find(tag => tag[0] === 'p');
+        if (!recipientTag)
+            throw new Error('No recipient tag found');
+        return await this.decrypt(privateKey, event.pubkey, event.content);
+    }
+    static getDMFilter(pubkey, otherPubkey) {
+        const filter = {
+            kinds: [4],
+            limit: 100
+        };
+        if (otherPubkey) {
+            filter['#p'] = [otherPubkey];
+            filter.authors = [pubkey];
+        }
+        else {
+            filter.$or = [
+                { authors: [pubkey] },
+                { '#p': [pubkey] }
+            ];
+        }
+        return filter;
+    }
+}
+exports.NIP04 = NIP04;

package/dist/nips/nip05.d.ts

@@ -0,0 +1,8 @@
+export declare class InternetIdentifier {
+    static verify(identifier: string, pubkey: string): Promise<boolean>;
+    static parseIdentifier(identifier: string): {
+        name: string;
+        domain: string;
+    };
+    static getRelays(identifier: string, pubkey: string): Promise<string[]>;
+}

package/dist/nips/nip05.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternetIdentifier = void 0;
+class InternetIdentifier {
+    static async verify(identifier, pubkey) {
+        try {
+            const [name, domain] = identifier.split('@');
+            if (!name || !domain)
+                return false;
+            const url = `https://${domain}/.well-known/nostr.json?name=${name}`;
+            const response = await fetch(url);
+            const data = await response.json();
+            return data.names[name] === pubkey;
+        }
+        catch {
+            return false;
+        }
+    }
+    static parseIdentifier(identifier) {
+        const [name, domain] = identifier.split('@');
+        if (!name || !domain) {
+            throw new Error('Invalid NIP-05 identifier format');
+        }
+        return { name, domain };
+    }
+    static async getRelays(identifier, pubkey) {
+        const { name, domain } = this.parseIdentifier(identifier);
+        const url = `https://${domain}/.well-known/nostr.json?name=${name}`;
+        try {
+            const response = await fetch(url);
+            const data = await response.json();
+            if (data.relays && data.relays[pubkey]) {
+                return data.relays[pubkey];
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.InternetIdentifier = InternetIdentifier;

package/dist/nodes/example/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/example/example.html

@@ -0,0 +1,27 @@
+<script type="text/html" data-template-name="example">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-message"><i class="fa fa-envelope"></i> Message</label>
+        <input type="text" id="node-input-message" placeholder="Hello World">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('example',{
+        category: 'example',
+        color: '#a6bbcf',
+        defaults: {
+            name: {value:""},
+            message: {value:"Hello World"}
+        },
+        inputs:1,
+        outputs:1,
+        icon: "file.png",
+        label: function() {
+            return this.name||"example";
+        }
+    });
+</script>

package/dist/nodes/example/example.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = function (RED) {
+    function ExampleNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        node.on('input', function (msg) {
+            msg.payload = config.message;
+            node.send(msg);
+        });
+    }
+    RED.nodes.registerType("example", ExampleNode);
+};
+//# sourceMappingURL=example.js.map

package/dist/nodes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './nostr-filter/nostr-filter';
+export * from './nostr-relay/nostr-relay';
+export * from './nostr-relay-config/nostr-relay-config';

package/dist/nodes/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// This file is just to export all nodes
+__exportStar(require("./nostr-filter/nostr-filter"), exports);
+__exportStar(require("./nostr-relay/nostr-relay"), exports);
+__exportStar(require("./nostr-relay-config/nostr-relay-config"), exports);

package/dist/nodes/nostr-filter/nostr-filter.d.ts

@@ -0,0 +1,2 @@
+import { NodeAPI } from 'node-red';
+export default function (RED: NodeAPI): void;

package/dist/nodes/nostr-filter/nostr-filter.html

@@ -0,0 +1,142 @@
+<script type="text/html" data-template-name="nostr-filter">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-relay"><i class="fa fa-globe"></i> Relay</label>
+        <input type="text" id="node-input-relay">
+    </div>
+    <div class="form-row">
+        <label for="node-input-filterType"><i class="fa fa-filter"></i> Filter Type</label>
+        <select id="node-input-filterType">
+            <option value="npub">Track User (npub)</option>
+            <option value="kind">Event Kind</option>
+            <option value="tag">Tag</option>
+            <option value="since">Time Since</option>
+            <option value="custom">Custom</option>
+        </select>
+    </div>
+    <div class="form-row filter-npub">
+        <label for="node-input-npubValue"><i class="fa fa-user"></i> Nostr Public Key</label>
+        <input type="text" id="node-input-npubValue" placeholder="npub1...">
+        <div class="form-tips">Enter the npub of the user you want to track</div>
+    </div>
+    <div class="form-row filter-npub">
+        <label for="node-input-npubEventKinds"><i class="fa fa-list"></i> Event Types</label>
+        <select id="node-input-npubEventKinds" multiple>
+            <option value="0">Profile Metadata</option>
+            <option value="1">Text Notes</option>
+            <option value="3">Contacts</option>
+            <option value="6">Reposts</option>
+            <option value="7">Reactions</option>
+            <option value="9735">Zaps</option>
+        </select>
+        <div class="form-tips">Select which types of events to track for this user</div>
+    </div>
+    <div class="form-row filter-kind">
+        <label for="node-input-eventKinds"><i class="fa fa-list"></i> Event Kinds</label>
+        <select id="node-input-eventKinds" multiple>
+            <option value="0">Metadata (0)</option>
+            <option value="1">Text Note (1)</option>
+            <option value="3">Contacts (3)</option>
+            <option value="4">DM (4)</option>
+            <option value="6">Repost (6)</option>
+            <option value="7">Reaction (7)</option>
+            <option value="9735">Zap (9735)</option>
+        </select>
+    </div>
+    <div class="form-row filter-tag">
+        <label for="node-input-tagName"><i class="fa fa-tag"></i> Tag Name</label>
+        <input type="text" id="node-input-tagName" placeholder="e, p, t, etc">
+    </div>
+    <div class="form-row filter-tag">
+        <label for="node-input-tagValue"><i class="fa fa-tag"></i> Tag Value</label>
+        <input type="text" id="node-input-tagValue" placeholder="Tag value to match">
+    </div>
+    <div class="form-row filter-since">
+        <label for="node-input-sinceMinutes"><i class="fa fa-clock-o"></i> Minutes</label>
+        <input type="number" id="node-input-sinceMinutes" placeholder="Time window in minutes">
+    </div>
+    <div class="form-row filter-custom">
+        <label for="node-input-customFilter"><i class="fa fa-code"></i> Custom Filter</label>
+        <input type="text" id="node-input-customFilter" placeholder='{"kinds":[1],"#e":["..."]}'>
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('nostr-filter', {
+        category: 'protocol',
+        color: '#a6bbcf',
+        defaults: {
+            name: { value: "" },
+            relay: { type: "nostr-relay-config", required: true },
+            filterType: { value: "npub" },
+            npubValue: { value: "", required: false },
+            npubEventKinds: { value: [0, 1], required: false },
+            eventKinds: { value: [1], required: false },
+            tagName: { value: "", required: false },
+            tagValue: { value: "", required: false },
+            sinceMinutes: { value: 60, required: false, validate: RED.validators.number() },
+            customFilter: { value: "", required: false }
+        },
+        label: function() {
+            if (this.filterType === 'npub' && this.npubValue) {
+                return this.name || `Track ${this.npubValue.substring(0, 12)}...`;
+            }
+            return this.name || "nostr filter";
+        },
+        oneditprepare: function() {
+            function showHideFields() {
+                $('.form-row').hide();
+                $('.form-row:first-child').show();
+                $('.form-row:nth-child(2)').show();
+                $('.form-row:nth-child(3)').show();
+                $(`.filter-${$('#node-input-filterType').val()}`).show();
+            }
+            
+            $('#node-input-filterType').on('change', showHideFields);
+            showHideFields();
+        }
+    });
+</script>
+
+<script type="text/html" data-help-name="nostr-filter">
+    <p>Filters Nostr events based on various criteria.</p>
+    
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Relay
+            <span class="property-type">config</span>
+        </dt>
+        <dd>Select the Nostr relay configuration to use</dd>
+    </dl>
+    
+    <h3>Filter Types</h3>
+    <dl class="message-properties">
+        <dt>Track User (npub)
+            <span class="property-type">string</span>
+        </dt>
+        <dd>Track events from a specific Nostr user by their npub. Select which types of events to track.</dd>
+        
+        <dt>Event Kind
+            <span class="property-type">array</span>
+        </dt>
+        <dd>Filter events by their kind (e.g., text notes, reactions, etc.)</dd>
+        
+        <dt>Tag
+            <span class="property-type">string</span>
+        </dt>
+        <dd>Filter events by tag name and value</dd>
+        
+        <dt>Time Since
+            <span class="property-type">number</span>
+        </dt>
+        <dd>Filter events within a time window (in minutes)</dd>
+        
+        <dt>Custom
+            <span class="property-type">json</span>
+        </dt>
+        <dd>Specify a custom Nostr filter in JSON format</dd>
+    </dl>
+</script>

package/dist/nodes/nostr-filter/nostr-filter.js

@@ -0,0 +1,174 @@
+"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.default = default_1;
+function default_1(RED) {
+    // Create a function to initialize the node
+    async function initializeNode(config) {
+        RED.nodes.createNode(this, config);
+        // Get the relay configuration node
+        this.relay = RED.nodes.getNode(config.relay);
+        if (!this.relay) {
+            this.error("No relay configuration found");
+            this.status({ fill: "red", shape: "ring", text: "Missing relay config" });
+            return;
+        }
+        this.filterType = config.filterType;
+        this.npubValue = config.npubValue;
+        this.npubEventKinds = config.npubEventKinds || [0, 1]; // Default to metadata and text notes
+        this.eventKinds = config.eventKinds;
+        this.tagName = config.tagName;
+        this.tagValue = config.tagValue;
+        this.sinceMinutes = config.sinceMinutes;
+        this.customFilter = config.customFilter;
+        try {
+            // Dynamically import ESM dependencies
+            const { nip19 } = await Promise.resolve().then(() => __importStar(require('nostr-tools')));
+            // Convert npub to hex if needed
+            if (this.filterType === 'npub' && this.npubValue) {
+                try {
+                    const decoded = nip19.decode(this.npubValue);
+                    if (decoded.type === 'npub') {
+                        this.hexPubkey = decoded.data;
+                        this.status({ fill: "green", shape: "dot", text: "Ready" });
+                    }
+                    else {
+                        throw new Error("Invalid npub format");
+                    }
+                }
+                catch (err) {
+                    this.error("Invalid npub: " + err.message);
+                    this.status({ fill: "red", shape: "dot", text: "Invalid npub" });
+                    return;
+                }
+            }
+            // Set up message handler
+            this.relay._ws?.on('message', (msg) => {
+                if (msg.type === 'EVENT' && msg.event) {
+                    const event = msg.event;
+                    // Apply filters based on type
+                    let shouldForward = false;
+                    switch (this.filterType) {
+                        case 'npub':
+                            if (this.hexPubkey && event.pubkey === this.hexPubkey) {
+                                shouldForward = this.npubEventKinds.includes(event.kind);
+                            }
+                            break;
+                        case 'kind':
+                            shouldForward = this.eventKinds.includes(event.kind);
+                            break;
+                        case 'tag':
+                            if (this.tagName && this.tagValue) {
+                                shouldForward = event.tags.some(tag => tag[0] === this.tagName && tag[1] === this.tagValue);
+                            }
+                            break;
+                        case 'since':
+                            if (this.sinceMinutes > 0) {
+                                const cutoff = Math.floor(Date.now() / 1000) - (this.sinceMinutes * 60);
+                                shouldForward = event.created_at >= cutoff;
+                            }
+                            break;
+                        case 'custom':
+                            if (this.customFilter) {
+                                try {
+                                    const filter = JSON.parse(this.customFilter);
+                                    shouldForward = Object.entries(filter).every(([key, value]) => {
+                                        if (Array.isArray(value)) {
+                                            return value.includes(event[key]);
+                                        }
+                                        return event[key] === value;
+                                    });
+                                }
+                                catch (err) {
+                                    this.error("Invalid custom filter: " + err.message);
+                                }
+                            }
+                            break;
+                    }
+                    if (shouldForward) {
+                        this.send({ payload: event });
+                    }
+                }
+            });
+            // Subscribe to events based on filter
+            const filter = {};
+            switch (this.filterType) {
+                case 'npub':
+                    if (this.hexPubkey) {
+                        filter.authors = [this.hexPubkey];
+                        filter.kinds = this.npubEventKinds;
+                    }
+                    break;
+                case 'kind':
+                    filter.kinds = this.eventKinds;
+                    break;
+                case 'tag':
+                    if (this.tagName && this.tagValue) {
+                        filter[`#${this.tagName}`] = [this.tagValue];
+                    }
+                    break;
+                case 'since':
+                    if (this.sinceMinutes > 0) {
+                        filter.since = Math.floor(Date.now() / 1000) - (this.sinceMinutes * 60);
+                    }
+                    break;
+                case 'custom':
+                    if (this.customFilter) {
+                        try {
+                            Object.assign(filter, JSON.parse(this.customFilter));
+                        }
+                        catch (err) {
+                            this.error("Invalid custom filter: " + err.message);
+                        }
+                    }
+                    break;
+            }
+            if (Object.keys(filter).length > 0) {
+                this.relay._ws?.subscribe('sub', filter);
+            }
+        }
+        catch (err) {
+            this.error("Failed to initialize node: " + err.message);
+            this.status({ fill: "red", shape: "dot", text: "Error" });
+        }
+    }
+    // Register the node
+    RED.nodes.registerType("nostr-filter", function (config) {
+        // Initialize asynchronously
+        initializeNode.call(this, config).catch((err) => {
+            this.error("Failed to initialize node: " + err.message);
+        });
+    });
+}

package/dist/nodes/nostr-npub-filter/nostr-npub-filter.d.ts

@@ -0,0 +1,2 @@
+import { NodeAPI } from 'node-red';
+export default function (RED: NodeAPI): void;