tauri-plugin-nostrnative 0.1.2

package/README.md

@@ -0,0 +1,106 @@
+# tauri-plugin-nostrnative
+
+A modular, high-performance Nostr library and Tauri plugin for Rust and JavaScript. Designed to be clean, easy to integrate, and highly customizable through feature flags.
+
+## Features
+
+- **Modular Design:** Only include the components you need (Calendar, Bookmarks, Blossom, etc.).
+- **Tauri Integration:** First-class support for Tauri v2 with a seamless plugin system and typed frontend bindings.
+- **Async-First:** Built on `tokio` and `nostr-sdk` for efficient network operations.
+- **Comprehensive NIP Support:** Includes implementations for NIP-01, NIP-44 (Encryption), NIP-46 (Nostr Connect), NIP-51 (Bookmarks), NIP-52 (Calendar), and more.
+
+## Installation
+
+### Rust (Backend)
+
+Add `tauri-plugin-nostrnative` to your `src-tauri/Cargo.toml`:
+
+```toml
+[dependencies]
+# Use specific features to keep your binary small
+tauri-plugin-nostrnative = { path = "../../nostrnative", features = ["calendar", "bookmarks", "tauri-plugin"] }
+
+# Or enable everything
+# tauri-plugin-nostrnative = { path = "../../nostrnative", features = ["full", "tauri-plugin"] }
+```
+
+### JavaScript (Frontend)
+
+Install the plugin bindings in your Tauri app's frontend directory:
+
+```bash
+npm install tauri-plugin-nostrnative
+```
+
+## Setup in Tauri
+
+### 1. Register the Plugin
+
+In your `src-tauri/src/lib.rs` (or `main.rs`), initialize the plugin:
+
+```rust
+pub fn run() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_nostrnative::init()) // Initialize the plugin
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+### 2. Use the JavaScript API
+
+Import the typed bindings in your frontend code:
+
+```typescript
+import * as nostr from 'tauri-plugin-nostrnative';
+
+// Examples
+const nsec = await nostr.generateNewNsec();
+const pubkey = await nostr.parsePubkey(somePubkey);
+
+const events = await nostr.fetchCalendarEvents(pubkey, ["wss://relay.damus.io"], {
+  rangeStart: Math.floor(Date.now() / 1000)
+});
+```
+
+## Available Features
+
+| Feature        | Description                                                 |
+| -------------- | ----------------------------------------------------------- |
+| `keys`         | Basic key management (generate, parse, verify).             |
+| `calendar`     | Calendar events (NIP-52) and RSVPs.                         |
+| `profile`      | User profiles (NIP-01) and contact lists (NIP-02).          |
+| `messages`     | Direct messages (NIP-44).                                   |
+| `bookmarks`    | Public and private bookmarks (NIP-51).                      |
+| `blossom`      | Blob Storage Server Operations (mirror, upload, get).       |
+| `chat`         | Advanced chat functionality with PNS key derivation.        |
+| `tauri-plugin` | Exports all enabled features as Tauri commands.             |
+| `full`         | Enables all functional features (excluding `tauri-plugin`). |
+
+## Standalone Library Usage
+
+You can also use the core logic directly in any Rust project:
+
+```rust
+use tauri_plugin_nostrnative::calendar::fetch_calendar_events_core;
+
+#[tokio::main]
+async fn main() {
+    let relays = vec!["wss://relay.damus.io".to_string()];
+    let events = fetch_calendar_events_core(
+        "your_pubkey",
+        None, // nsec
+        &relays,
+        None, // start
+        None, // end
+        None, // authors
+        None  // client_nsec
+    ).await;
+
+    println!("Fetched events: {:?}", events);
+}
+```
+
+## Permissions
+
+This plugin includes a set of default permissions. Check the `permissions/` directory for details on how to configure access to specific Nostr commands in your Tauri application.

package/dist-js/index.cjs

@@ -0,0 +1,288 @@
+'use strict';
+
+var core = require('@tauri-apps/api/core');
+
+// Keys
+async function generateNewNsec() {
+    return await core.invoke('plugin:nostrnative|generate_new_nsec');
+}
+async function parsePubkey(pubkey) {
+    return await core.invoke('plugin:nostrnative|parse_pubkey', { pubkey });
+}
+async function verifyNsec(nsec) {
+    return await core.invoke('plugin:nostrnative|verify_nsec', { nsec });
+}
+// Calendar
+async function fetchCalendarEvents(pubkey, relays, options) {
+    return await core.invoke('plugin:nostrnative|fetch_calendar_events', {
+        pubkey,
+        nsec: options?.nsec,
+        relays,
+        rangeStart: options?.rangeStart,
+        rangeEnd: options?.rangeEnd,
+        authors: options?.authors,
+        clientNsec: options?.clientNsec
+    });
+}
+async function publishBatchCalendarEvents(nsec, relays, events, clientNsec) {
+    return await core.invoke('plugin:nostrnative|publish_batch_calendar_events', {
+        nsec,
+        relays,
+        events,
+        clientNsec
+    });
+}
+async function publishCalendarEvent(nsec, relays, eventData, clientNsec) {
+    return await core.invoke('plugin:nostrnative|publish_calendar_event', {
+        nsec,
+        relays,
+        eventData,
+        clientNsec
+    });
+}
+async function deleteCalendarEvent(nsec, relays, eventIds, clientNsec) {
+    return await core.invoke('plugin:nostrnative|delete_calendar_event', {
+        nsec,
+        relays,
+        eventIds,
+        clientNsec
+    });
+}
+async function fetchCalendars(pubkey, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_calendars', {
+        pubkey,
+        relays
+    });
+}
+async function publishCalendar(nsec, relays, calendar, clientNsec) {
+    return await core.invoke('plugin:nostrnative|publish_calendar', {
+        nsec,
+        relays,
+        calendar,
+        clientNsec
+    });
+}
+async function deleteCalendar(nsec, relays, identifier, clientNsec) {
+    return await core.invoke('plugin:nostrnative|delete_calendar', {
+        nsec,
+        relays,
+        identifier,
+        clientNsec
+    });
+}
+// RSVP
+async function fetchRsvps(eventCoordinate, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_rsvps', {
+        eventCoordinate,
+        relays
+    });
+}
+async function fetchUserRsvps(pubkey, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_user_rsvps', {
+        pubkey,
+        relays
+    });
+}
+async function fetchReceivedRsvps(pubkey, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_received_rsvps', {
+        pubkey,
+        relays
+    });
+}
+async function publishRsvp(nsec, relays, eventCoordinate, status, eventAuthor, clientNsec) {
+    return await core.invoke('plugin:nostrnative|publish_rsvp', {
+        nsec,
+        relays,
+        eventCoordinate,
+        status,
+        eventAuthor,
+        clientNsec
+    });
+}
+// Profile
+async function fetchProfiles(pubkeys, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_profiles', { pubkeys, relays });
+}
+async function fetchContactList(pubkey, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_contact_list', {
+        pubkey,
+        relays
+    });
+}
+async function updateContactList(nsec, relays, contacts, clientNsec) {
+    return await core.invoke('plugin:nostrnative|update_contact_list', {
+        nsec,
+        relays,
+        contacts,
+        clientNsec
+    });
+}
+// Messages
+async function sendDirectMessage(nsec, receiverPubkey, message, relays, clientNsec) {
+    return await core.invoke('plugin:nostrnative|send_direct_message', {
+        nsec,
+        receiverPubkey,
+        message,
+        relays,
+        clientNsec
+    });
+}
+// Bookmarks
+async function fetchBookmarks(pubkey, relays, nsec, clientNsec) {
+    return await core.invoke('plugin:nostrnative|fetch_bookmarks', {
+        pubkey,
+        nsec,
+        relays,
+        clientNsec
+    });
+}
+async function fetchEventDetails(identifiers, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_event_details', {
+        identifiers,
+        relays
+    });
+}
+async function saveBookmark(nsec, relays, eventId, source, clientNsec) {
+    return await core.invoke('plugin:nostrnative|save_bookmark', {
+        nsec,
+        relays,
+        eventId,
+        source,
+        clientNsec
+    });
+}
+async function removeBookmark(nsec, relays, eventId, source, clientNsec) {
+    return await core.invoke('plugin:nostrnative|remove_bookmark', {
+        nsec,
+        relays,
+        eventId,
+        source,
+        clientNsec
+    });
+}
+// Blossom
+async function blossomMirror(serverUrl, nsec, url, clientNsec) {
+    return await core.invoke('plugin:nostrnative|blossom_mirror', {
+        serverUrl,
+        nsec,
+        url,
+        clientNsec
+    });
+}
+async function blossomUpload(serverUrl, nsec, filePath, clientNsec) {
+    return await core.invoke('plugin:nostrnative|blossom_upload', {
+        serverUrl,
+        nsec,
+        filePath,
+        clientNsec
+    });
+}
+async function blossomUploadContent(serverUrl, nsec, content, filename, mediaType, clientNsec) {
+    return await core.invoke('plugin:nostrnative|blossom_upload_content', {
+        serverUrl,
+        nsec,
+        content,
+        filename,
+        mediaType,
+        clientNsec
+    });
+}
+async function blossomGetBlob(serverUrl, hash) {
+    return await core.invoke('plugin:nostrnative|blossom_get_blob', {
+        serverUrl,
+        hash
+    });
+}
+// Chat
+async function derivePnsKeys(deviceKeyHex) {
+    return await core.invoke('plugin:nostrnative|derive_pns_keys', {
+        deviceKeyHex
+    });
+}
+async function createDiscoveryEvent(nsec, deviceKeyToStore, relays, clientNsec) {
+    return await core.invoke('plugin:nostrnative|create_discovery_event', {
+        nsec,
+        deviceKeyToStore,
+        relays,
+        clientNsec
+    });
+}
+async function decryptDiscoveryEvent(nsec, content, clientNsec) {
+    return await core.invoke('plugin:nostrnative|decrypt_discovery_event', {
+        nsec,
+        content,
+        clientNsec
+    });
+}
+async function publishChatMessage(pnsNsec, mainPubkey, msg, relays, clientNsec) {
+    return await core.invoke('plugin:nostrnative|publish_chat_message', {
+        pnsNsec,
+        mainPubkey,
+        msg,
+        relays,
+        clientNsec
+    });
+}
+async function decryptPnsEvent(pnsNsec, content, clientNsec) {
+    return await core.invoke('plugin:nostrnative|decrypt_pns_event', {
+        pnsNsec,
+        content,
+        clientNsec
+    });
+}
+async function fetchPnsEvents(pnsPubkey, relays, eventId) {
+    return await core.invoke('plugin:nostrnative|fetch_pns_events', {
+        pnsPubkey,
+        relays,
+        eventId
+    });
+}
+async function deleteChatMessages(pnsNsec, relays, eventIds, clientNsec) {
+    return await core.invoke('plugin:nostrnative|delete_chat_messages', {
+        pnsNsec,
+        relays,
+        eventIds,
+        clientNsec
+    });
+}
+async function fetchDiscoveryEvents(pubkey, relays) {
+    return await core.invoke('plugin:nostrnative|fetch_discovery_events', {
+        pubkey,
+        relays
+    });
+}
+
+exports.blossomGetBlob = blossomGetBlob;
+exports.blossomMirror = blossomMirror;
+exports.blossomUpload = blossomUpload;
+exports.blossomUploadContent = blossomUploadContent;
+exports.createDiscoveryEvent = createDiscoveryEvent;
+exports.decryptDiscoveryEvent = decryptDiscoveryEvent;
+exports.decryptPnsEvent = decryptPnsEvent;
+exports.deleteCalendar = deleteCalendar;
+exports.deleteCalendarEvent = deleteCalendarEvent;
+exports.deleteChatMessages = deleteChatMessages;
+exports.derivePnsKeys = derivePnsKeys;
+exports.fetchBookmarks = fetchBookmarks;
+exports.fetchCalendarEvents = fetchCalendarEvents;
+exports.fetchCalendars = fetchCalendars;
+exports.fetchContactList = fetchContactList;
+exports.fetchDiscoveryEvents = fetchDiscoveryEvents;
+exports.fetchEventDetails = fetchEventDetails;
+exports.fetchPnsEvents = fetchPnsEvents;
+exports.fetchProfiles = fetchProfiles;
+exports.fetchReceivedRsvps = fetchReceivedRsvps;
+exports.fetchRsvps = fetchRsvps;
+exports.fetchUserRsvps = fetchUserRsvps;
+exports.generateNewNsec = generateNewNsec;
+exports.parsePubkey = parsePubkey;
+exports.publishBatchCalendarEvents = publishBatchCalendarEvents;
+exports.publishCalendar = publishCalendar;
+exports.publishCalendarEvent = publishCalendarEvent;
+exports.publishChatMessage = publishChatMessage;
+exports.publishRsvp = publishRsvp;
+exports.removeBookmark = removeBookmark;
+exports.saveBookmark = saveBookmark;
+exports.sendDirectMessage = sendDirectMessage;
+exports.updateContactList = updateContactList;
+exports.verifyNsec = verifyNsec;

package/dist-js/index.d.ts

@@ -0,0 +1,105 @@
+export interface CalendarEventRequest {
+    title: string;
+    description?: string;
+    start: number;
+    end?: number;
+    location?: string;
+    is_all_day: boolean;
+    identifier: string;
+    reminder_minutes?: number;
+    old_event_id?: string;
+    calendar_id?: string;
+    color?: string;
+    p_tags?: string[];
+    is_private?: boolean;
+    parent?: string;
+    freq?: string;
+    until?: number;
+    use_different_timestamp?: boolean;
+}
+export interface CalendarRequest {
+    name: string;
+    description?: string;
+    identifier: string;
+}
+export interface Contact {
+    pubkey: string;
+    alias?: string | null;
+}
+export interface UserProfile {
+    pubkey: string;
+    name?: string | null;
+    display_name?: string | null;
+    about?: string | null;
+    picture?: string | null;
+    banner?: string | null;
+    website?: string | null;
+    nip05?: string | null;
+}
+export type BookmarkSource = 'public' | 'private' | 'website';
+export interface EventResponse {
+    id: string;
+    pubkey: string;
+    created_at: number;
+    kind: number;
+    tags: string[][];
+    content: string;
+    is_private: boolean;
+    bech32?: string;
+    private_tags?: string[][];
+    source?: BookmarkSource;
+}
+export interface ChatMessageRequest {
+    content: string;
+    conversation_id: string;
+    role: string;
+    client: string;
+    reply_to?: string;
+    event_id?: string;
+    context_ids?: string[];
+    blob_hashes?: string[];
+}
+export interface PnsDerivedKeys {
+    public_key: string;
+    secret_key: string;
+}
+export declare function generateNewNsec(): Promise<string>;
+export declare function parsePubkey(pubkey: string): Promise<string>;
+export declare function verifyNsec(nsec: string): Promise<string>;
+export declare function fetchCalendarEvents(pubkey: string, relays: string[], options?: {
+    nsec?: string;
+    rangeStart?: number;
+    rangeEnd?: number;
+    authors?: string[];
+    clientNsec?: string;
+}): Promise<EventResponse[]>;
+export declare function publishBatchCalendarEvents(nsec: string, relays: string[], events: CalendarEventRequest[], clientNsec?: string): Promise<string[]>;
+export declare function publishCalendarEvent(nsec: string, relays: string[], eventData: CalendarEventRequest, clientNsec?: string): Promise<string>;
+export declare function deleteCalendarEvent(nsec: string, relays: string[], eventIds: string[], clientNsec?: string): Promise<string>;
+export declare function fetchCalendars(pubkey: string, relays: string[]): Promise<EventResponse[]>;
+export declare function publishCalendar(nsec: string, relays: string[], calendar: CalendarRequest, clientNsec?: string): Promise<string>;
+export declare function deleteCalendar(nsec: string, relays: string[], identifier: string, clientNsec?: string): Promise<string>;
+export declare function fetchRsvps(eventCoordinate: string, relays: string[]): Promise<EventResponse[]>;
+export declare function fetchUserRsvps(pubkey: string, relays: string[]): Promise<EventResponse[]>;
+export declare function fetchReceivedRsvps(pubkey: string, relays: string[]): Promise<EventResponse[]>;
+export declare function publishRsvp(nsec: string, relays: string[], eventCoordinate: string, status: string, eventAuthor?: string, clientNsec?: string): Promise<string>;
+export declare function fetchProfiles(pubkeys: string[], relays: string[]): Promise<UserProfile[]>;
+export declare function fetchContactList(pubkey: string, relays: string[]): Promise<Contact[]>;
+export declare function updateContactList(nsec: string, relays: string[], contacts: Contact[], clientNsec?: string): Promise<string>;
+export declare function sendDirectMessage(nsec: string, receiverPubkey: string, message: string, relays: string[], clientNsec?: string): Promise<string>;
+export declare function fetchBookmarks(pubkey: string, relays: string[], nsec?: string, clientNsec?: string): Promise<EventResponse[]>;
+export declare function fetchEventDetails(identifiers: string[], relays: string[]): Promise<EventResponse[]>;
+export declare function saveBookmark(nsec: string, relays: string[], eventId: string, source: BookmarkSource, clientNsec?: string): Promise<string>;
+export declare function removeBookmark(nsec: string, relays: string[], eventId: string, source: BookmarkSource, clientNsec?: string): Promise<string>;
+export declare function blossomMirror(serverUrl: string, nsec: string, url: string, clientNsec?: string): Promise<string>;
+export declare function blossomUpload(serverUrl: string, nsec: string, filePath: string, clientNsec?: string): Promise<string>;
+export declare function blossomUploadContent(serverUrl: string, nsec: string, content: string, filename?: string, mediaType?: string, clientNsec?: string): Promise<string>;
+export declare function blossomGetBlob(serverUrl: string, hash: string): Promise<number[]>;
+export declare function derivePnsKeys(deviceKeyHex: string): Promise<PnsDerivedKeys>;
+export declare function createDiscoveryEvent(nsec: string, deviceKeyToStore: string, relays: string[], clientNsec?: string): Promise<string>;
+export declare function decryptDiscoveryEvent(nsec: string, content: string, clientNsec?: string): Promise<string>;
+export declare function publishChatMessage(pnsNsec: string, mainPubkey: string, msg: ChatMessageRequest, relays: string[], clientNsec?: string): Promise<string>;
+export declare function decryptPnsEvent(pnsNsec: string, content: string, clientNsec?: string): Promise<any>;
+export declare function fetchPnsEvents(pnsPubkey: string, relays: string[], eventId?: string): Promise<EventResponse[]>;
+export declare function deleteChatMessages(pnsNsec: string, relays: string[], eventIds: string[], clientNsec?: string): Promise<string>;
+export declare function fetchDiscoveryEvents(pubkey: string, relays: string[]): Promise<EventResponse[]>;