nostr-crypto-utils 0.2.0 → 0.4.0

package/README.md

@@ -1,11 +1,14 @@
 # nostr-crypto-utils
 
-A comprehensive TypeScript library providing cryptographic utilities and protocol-compliant message handling for Nostr applications, designed to work seamlessly with [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/HumanjavaEnterprises/nostr-nsec-seedphrase).
+A lightweight, type-safe TypeScript library for Nostr cryptography, designed to complement [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/HumanjavaEnterprises/nostr-nsec-seedphrase). Together, they provide a robust, security-focused alternative to larger Nostr client libraries.
 
 [![npm version](https://badge.fury.io/js/%40humanjavaenterprises%2Fnostr-crypto-utils.svg)](https://www.npmjs.com/package/@humanjavaenterprises/nostr-crypto-utils)
 [![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/HumanjavaEnterprises/nostr-crypto-utils/blob/main/LICENSE)
 [![Documentation](https://img.shields.io/badge/docs-TypeDoc-blue.svg)](https://humanjavaenterprises.github.io/nostr-crypto-utils/)
+[![Build Status](https://img.shields.io/github/workflow/status/HumanjavaEnterprises/nostr-crypto-utils/CI)](https://github.com/HumanjavaEnterprises/nostr-crypto-utils/actions)
+[![Coverage Status](https://coveralls.io/repos/github/HumanjavaEnterprises/nostr-crypto-utils/badge.svg?branch=main)](https://coveralls.io/github/HumanjavaEnterprises/nostr-crypto-utils?branch=main)
+[![Known Vulnerabilities](https://snyk.io/test/github/HumanjavaEnterprises/nostr-crypto-utils/badge.svg)](https://snyk.io/test/github/HumanjavaEnterprises/nostr-crypto-utils)
 
 ## Security Notice
 
@@ -13,6 +16,15 @@ A comprehensive TypeScript library providing cryptographic utilities and protoco
 
 If you discover a security vulnerability, please follow our [Security Policy](SECURITY.md) and report it through [GitHub's Security Advisory feature](https://github.com/humanjavaenterprises/nostr-crypto-utils/security/advisories/new).
 
+## Why Choose nostr-crypto-utils?
+
+- **Lightweight**: Only 208.7KB unpacked, focusing on essential cryptographic operations
+- **Type-First**: Built from the ground up with TypeScript for maximum type safety
+- **Minimal Dependencies**: Reduced attack surface and easier auditing
+- **Modular Design**: Perfect for projects that need cryptographic operations without full client functionality
+- **Complementary**: Works seamlessly with nostr-nsec-seedphrase for complete key management
+- **Security Focused**: Strict validation and comprehensive test coverage
+
 ## Features
 
 - **Complete NIP Compliance**: Implements all required cryptographic operations according to Nostr Implementation Possibilities (NIPs)
@@ -21,6 +33,8 @@ If you discover a security vulnerability, please follow our [Security Policy](SE
 - **Message Formatting**: Protocol-compliant message formatting for relay communication
 - **Encryption**: Secure encryption and decryption for direct messages (NIP-04)
 - **Validation**: Comprehensive validation for events, filters, and subscriptions
+- **Cross-Platform**: Works in both Node.js and browser environments
+- **Zero Dependencies**: Minimal external dependencies for better security
 
 ## Features and Capabilities
 
@@ -30,71 +44,383 @@ If you discover a security vulnerability, please follow our [Security Policy](SE
 | Event Creation            | ✅     | Create and validate Nostr events                      |
 | Event Signing             | ✅     | Sign events with schnorr signatures                   |
 | Event Verification        | ✅     | Verify event signatures and validate event structure  |
-| Message Encryption        | ✅     | NIP-04 compliant message encryption                   |
-| Message Decryption        | ✅     | NIP-04 compliant message decryption                  |
-| Event Serialization       | ✅     | Protocol-compliant event serialization               |
-| Event Hashing            | ✅     | Generate and verify event IDs                        |
+| Direct Messages (NIP-04)  | ✅     | Encrypt and decrypt direct messages                   |
+| Message Formatting        | ✅     | Format messages for relay communication               |
+| Type Safety              | ✅     | Full TypeScript support with strict typing           |
+| Browser Support          | ✅     | Works in modern browsers with Web Crypto API         |
+| Node.js Support         | ✅     | Full support for Node.js environments               |
+
+## Integration with nostr-nsec-seedphrase
+
+This library is designed to work seamlessly with [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/HumanjavaEnterprises/nostr-nsec-seedphrase) to provide a complete solution for Nostr key management and cryptographic operations:
+
+```typescript
+import { generateSeedPhrase } from '@humanjavaenterprises/nostr-nsec-seedphrase';
+import { createTextNoteEvent, signEvent } from '@humanjavaenterprises/nostr-crypto-utils';
+
+// Generate keys using nostr-nsec-seedphrase
+const seedPhrase = generateSeedPhrase();
+const keyPair = seedPhraseToKeyPair(seedPhrase);
+
+// Use nostr-crypto-utils for event creation and signing
+const event = createTextNoteEvent({
+  content: 'Hello Nostr!',
+  pubkey: keyPair.publicKey,
+  created_at: Math.floor(Date.now() / 1000)
+});
+
+const signedEvent = signEvent(event, keyPair.privateKey);
+```
+
+Together, these libraries provide:
+- Secure key generation and recovery through seed phrases
+- Type-safe cryptographic operations
+- Comprehensive event handling
+- Minimal bundle size and dependencies
+
+## Delegate Token Creation (NIP-26)
+
+You can use this library to create delegate tokens for use on web servers or other applications. This implements [NIP-26](https://github.com/nostr-protocol/nips/blob/master/26.md) for delegation of signing authority.
+
+### Basic Delegation Example
+
+```typescript
+import { createDelegation, validateDelegation } from '@humanjavaenterprises/nostr-crypto-utils';
+
+// Create a delegation token (delegator's perspective)
+const delegatorKeyPair = await generateKeyPair();
+const delegateePubkey = 'npub1...'; // The public key you're delegating to
+
+const delegation = await createDelegation({
+  delegatorPrivkey: delegatorKeyPair.privateKey,
+  delegateePubkey,
+  conditions: {
+    kind: 1,  // Only allow text notes
+    until: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60  // 30 days
+  }
+});
+
+// Validate a delegation token (delegatee's perspective)
+const isValid = await validateDelegation({
+  token: delegation.token,
+  delegatorPubkey: delegatorKeyPair.publicKey,
+  delegateePubkey,
+  kind: 1
+});
+```
+
+### Web Server Example
+
+Here's how to use delegation tokens in a web server context:
+
+```typescript
+import { createEvent, signEventWithDelegation } from '@humanjavaenterprises/nostr-crypto-utils';
+
+// On your server, store these securely
+const DELEGATE_PRIVKEY = 'nsec1...';  // Your server's private key
+const DELEGATION_TOKEN = 'nostr:delegation:...';  // Token from the delegator
+const DELEGATOR_PUBKEY = 'npub1...';  // Delegator's public key
+
+// Create and sign an event on behalf of the delegator
+const event = await createEvent({
+  kind: 1,
+  content: 'Posted via delegation!',
+  pubkey: DELEGATOR_PUBKEY,  // Original delegator's pubkey
+  created_at: Math.floor(Date.now() / 1000)
+});
+
+const signedEvent = await signEventWithDelegation({
+  event,
+  delegatePrivkey: DELEGATE_PRIVKEY,
+  delegation: {
+    token: DELEGATION_TOKEN,
+    conditions: {
+      kind: 1,
+      until: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60
+    }
+  }
+});
+```
+
+### Conditional Delegation
+
+You can create more specific delegations with conditions:
+
+```typescript
+// Create a delegation with multiple conditions
+const delegation = await createDelegation({
+  delegatorPrivkey: delegatorKeyPair.privateKey,
+  delegateePubkey,
+  conditions: {
+    kinds: [1, 6],  // Allow only text notes and reposts
+    until: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,  // 1 week
+    since: Math.floor(Date.now() / 1000),  // Starting from now
+    tags: [
+      ['t', 'nostr'],  // Only allow posts with tag 't' = 'nostr'
+      ['p', delegateePubkey]  // Only allow mentions of the delegatee
+    ]
+  }
+});
+```
+
+### Security Considerations
+
+When working with delegated tokens:
+
+1. **Store Securely**: Always store delegation tokens and private keys securely
+2. **Check Expiration**: Validate the delegation's time constraints before using
+3. **Validate Conditions**: Check all conditions before signing or accepting delegated events
+4. **Limit Scope**: Only delegate the minimum required permissions
+5. **Monitor Usage**: Keep track of how delegated tokens are being used
+
+For more details on delegation, see the [NIP-26 specification](https://github.com/nostr-protocol/nips/blob/master/26.md).
+
+## Type System Improvements
+
+### Enhanced Type System
+
+- **Consolidated Type Definitions**: Improved consistency and safety through unified type definitions
+- **Better Type Inference**: Enhanced type inference for easier development and better code completion
+- **Stricter Type Checks**: Improved type safety with stricter checks for better error prevention
+
+### Improved Type Documentation
+
+- **Better JSDoc Comments**: Improved documentation with clear and concise JSDoc comments
+- **NIP References**: Added references to relevant NIPs for better understanding of the underlying protocol
+
+## Troubleshooting
+
+### Common Issues and Solutions
+
+#### 1. Invalid Delegation Token
+
+```typescript
+// ❌ Common mistake: Using expired delegation
+const delegation = await createDelegation({
+  delegatorPrivkey,
+  delegateePubkey,
+  conditions: {
+    until: Math.floor(Date.now() / 1000) - 3600  // Already expired!
+  }
+});
+
+// ✅ Correct: Ensure future expiration
+const delegation = await createDelegation({
+  delegatorPrivkey,
+  delegateePubkey,
+  conditions: {
+    until: Math.floor(Date.now() / 1000) + (24 * 60 * 60)  // 24 hours from now
+  }
+});
+```
+
+#### 2. Signature Verification Failures
+
+```typescript
+// ❌ Common mistake: Using wrong key format
+const wrongPubkey = 'npub1...';  // Using bech32 format directly
+const event = await signEventWithDelegation({ pubkey: wrongPubkey, ... });
+
+// ✅ Correct: Convert from bech32 to hex format first
+import { nip19 } from 'nostr-tools';
+const { data: pubkeyHex } = nip19.decode(pubkey);
+const event = await signEventWithDelegation({ pubkey: pubkeyHex, ... });
+```
+
+#### 3. Permission Issues
+
+```typescript
+// ❌ Common mistake: Mismatched event kinds
+const delegation = await createDelegation({
+  conditions: { kind: 1 }  // Only allows kind 1
+});
+const event = createEvent({ kind: 4 });  // Trying to create kind 4
+// This will fail!
+
+// ✅ Correct: Match delegation conditions
+const delegation = await createDelegation({
+  conditions: { kinds: [1, 4] }  // Allow both kinds
+});
+const event = createEvent({ kind: 4 });  // Now works!
+```
+
+#### 4. Token Format Issues
+
+```typescript
+// ❌ Common mistake: Invalid token parsing
+const token = 'nostr:delegation:...';
+const parts = token.split(':');  // Naive splitting
+
+// ✅ Correct: Use proper token parsing
+import { parseDelegationToken } from '@humanjavaenterprises/nostr-crypto-utils';
+const { delegator, conditions } = parseDelegationToken(token);
+```
+
+### Debug Mode
+
+Enable debug mode to get detailed logging:
+
+```typescript
+import { setDebugLevel } from '@humanjavaenterprises/nostr-crypto-utils';
+
+// Enable debug logging
+setDebugLevel('debug');
+
+// Or for even more detail
+setDebugLevel('trace');
+```
+
+### Common Error Messages
+
+| Error Message | Likely Cause | Solution |
+|--------------|--------------|----------|
+| "Invalid delegation token" | Token expired or malformed | Check token expiration and format |
+| "Signature verification failed" | Wrong key format or corrupted signature | Verify key formats and conversion |
+| "Condition check failed" | Event doesn't match delegation conditions | Check event kind and other conditions |
+| "Invalid pubkey format" | Using bech32 instead of hex | Convert pubkey to correct format |
+| "Token expired" | Delegation token past expiration | Create new delegation with future expiration |
+
+### Validation Checks
+
+When troubleshooting, verify these common points:
+
+1. **Key Formats**
+   - Private keys should be in hex format
+   - Public keys should be in hex format (not bech32)
+   - Signatures should be 64 bytes in hex format
+
+2. **Time Constraints**
+   - Token expiration should be in the future
+   - Check system clock synchronization
+   - Use UTC timestamps consistently
+
+3. **Permission Scope**
+   - Verify event kinds match delegation conditions
+   - Check any tag restrictions
+   - Confirm time window restrictions
+
+4. **Network Issues**
+   - Verify relay connections
+   - Check for rate limiting
+   - Confirm proper websocket handling
+
+### Testing Tools
+
+```typescript
+// Test delegation validity
+const testDelegation = async (delegation) => {
+  const result = await validateDelegation({
+    token: delegation.token,
+    delegatorPubkey: delegation.delegator,
+    delegateePubkey: delegation.delegatee,
+    kind: 1
+  });
+  
+  console.log('Delegation valid:', result.isValid);
+  if (!result.isValid) {
+    console.error('Validation error:', result.error);
+  }
+  
+  return result;
+};
+
+// Test event signing
+const testEventSigning = async (event, delegation) => {
+  try {
+    const signed = await signEventWithDelegation({
+      event,
+      delegatePrivkey: delegation.privateKey,
+      delegation: delegation.token
+    });
+    console.log('Event signed successfully:', signed.id);
+    return true;
+  } catch (error) {
+    console.error('Signing failed:', error);
+    return false;
+  }
+};
+```
+
+For more help, join our [Discord community](https://discord.gg/nostr) or [open an issue](https://github.com/humanjavaenterprises/nostr-crypto-utils/issues).
 
 ## Installation
 
 ```bash
-npm install nostr-crypto-utils
+npm install @humanjavaenterprises/nostr-crypto-utils
 ```
 
 ## Quick Start
 
 ```typescript
-import { generateKeyPair, signEvent, verifyEvent } from 'nostr-crypto-utils';
+import { createKeyPair, createTextNoteEvent, signEvent } from '@humanjavaenterprises/nostr-crypto-utils';
 
-// Generate a new keypair
-const keyPair = await generateKeyPair();
-console.log('Public Key:', keyPair.publicKey);
-console.log('Private Key:', keyPair.privateKey);
+// Generate a new key pair
+const keyPair = createKeyPair();
 
-// Create and sign an event
-const event = await signEvent({
-  kind: 1,
+// Create a text note event
+const event = createTextNoteEvent({
   content: 'Hello Nostr!',
-  tags: []
-}, keyPair.privateKey);
+  pubkey: keyPair.publicKey,
+  created_at: Math.floor(Date.now() / 1000)
+});
 
-// Verify the event
-const isValidEvent = await verifyEvent(event);
+// Sign the event
+const signedEvent = signEvent(event, keyPair.privateKey);
 ```
 
 ## Documentation
 
-For detailed API documentation, visit our [TypeDoc Documentation](https://humanjavaenterprises.github.io/nostr-crypto-utils/).
+Comprehensive documentation is available at [https://humanjavaenterprises.github.io/nostr-crypto-utils/](https://humanjavaenterprises.github.io/nostr-crypto-utils/)
 
-## Support & Community
+## Type Safety
 
-We welcome your feedback and contributions! Here's how you can get involved:
+This library is written in TypeScript and provides comprehensive type definitions for all functions and data structures. Type checking is enforced at compile time to catch potential errors early.
 
-- 🐛 [Report bugs](https://github.com/humanjavaenterprises/nostr-crypto-utils/issues/new?labels=bug&template=bug_report.md)
-- 💡 [Request features](https://github.com/humanjavaenterprises/nostr-crypto-utils/issues/new?labels=enhancement&template=feature_request.md)
-- 💬 [Start a discussion](https://github.com/humanjavaenterprises/nostr-crypto-utils/discussions)
-- 📖 [Read documentation](https://humanjavaenterprises.github.io/nostr-crypto-utils/)
-- 🔒 [Report security issues](https://github.com/humanjavaenterprises/nostr-crypto-utils/security/advisories/new)
+```typescript
+import { NostrEvent, NostrFilter, ValidationResult } from '@humanjavaenterprises/nostr-crypto-utils';
 
-## Contributing
+// All types are properly defined
+const filter: NostrFilter = {
+  kinds: [1],
+  authors: ['pubkey1', 'pubkey2'],
+  limit: 10
+};
 
-We welcome contributions! Please follow these steps:
+// Validation results include type information
+const result: ValidationResult = validateEvent(event);
+```
 
-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
+## Contributing
 
-Before contributing:
-- Read our [Code of Conduct](CODE_OF_CONDUCT.md)
-- Check our [Contributing Guidelines](.github/CONTRIBUTING.md)
-- Review our [Security Policy](SECURITY.md)
-- Search [existing issues](https://github.com/humanjavaenterprises/nostr-crypto-utils/issues) before creating a new one
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
 
 ## License
 
-[MIT](LICENSE)
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Changelog
+
+### v0.3.0 (2024-12-28)
+- 🔒 Improved type safety with stricter TypeScript checks
+- 🐛 Fixed crypto implementation for cross-platform compatibility
+- ✨ Added comprehensive validation for all message types
+- 📝 Updated documentation with more examples
+
+### v0.2.0 (2024-12-26)
+- 🎉 Initial public release
+- ✨ Added support for NIP-01 and NIP-04
+- 🔑 Implemented key pair generation and management
+- 📝 Added comprehensive documentation
+
+## Support
+
+- 📖 [Documentation](https://humanjavaenterprises.github.io/nostr-crypto-utils/)
+- 🐛 [Issue Tracker](https://github.com/humanjavaenterprises/nostr-crypto-utils/issues)
+- 💬 [Discussions](https://github.com/humanjavaenterprises/nostr-crypto-utils/discussions)
+
+## Related Projects
+
+- [@humanjavaenterprises/nostr-nsec-seedphrase](https://github.com/HumanjavaEnterprises/nostr-nsec-seedphrase) - Generate and manage Nostr private keys using BIP-39 seed phrases
 
 ---
 <div align="center">

package/dist/__tests__/setup.d.ts

@@ -1 +1,5 @@
+/**
+ * @module test/setup
+ * @description Test setup and configuration
+ */
 export {};

package/dist/__tests__/setup.js

@@ -1,5 +1,18 @@
+/**
+ * @module test/setup
+ * @description Test setup and configuration
+ */
+import { afterEach, beforeEach } from 'vitest';
 import { webcrypto } from 'node:crypto';
 // Configure crypto for test environment
 if (typeof globalThis.crypto === 'undefined') {
     globalThis.crypto = webcrypto;
 }
+// Set up global test environment
+beforeEach(() => {
+    // Add any global setup here
+});
+afterEach(() => {
+    // Add any cleanup here
+});
+// Add any custom matchers or global test utilities here

package/dist/constants.d.ts

@@ -1,99 +1,49 @@
 /**
- * Constants used in the Nostr protocol
- * @module constants
- */
-/**
- * Nostr protocol message types as defined in NIP-01
- * @constant
- * @type {const}
+ * Constants used throughout the library
  */
 export declare const NOSTR_MESSAGE_TYPE: {
-    /** Client sending an event to a relay */
     readonly EVENT: "EVENT";
-    /** Client requesting events from a relay */
     readonly REQ: "REQ";
-    /** Client closing a subscription */
     readonly CLOSE: "CLOSE";
-    /** Relay sending a notice/message to a client */
     readonly NOTICE: "NOTICE";
-    /** Relay acknowledging an event */
+    readonly EOSE: "EOSE";
     readonly OK: "OK";
-    /** Relay requesting client authentication */
     readonly AUTH: "AUTH";
-    /** Relay indicating end of stored events */
-    readonly EOSE: "EOSE";
+    readonly ERROR: "ERROR";
 };
-/**
- * Standard Nostr event kinds as defined in various NIPs
- * @constant
- * @type {const}
- */
-export declare const NOSTR_KIND: {
-    /** User metadata (NIP-01) */
-    readonly METADATA: 0;
-    /** Text note (NIP-01) */
+export declare const NOSTR_EVENT_KIND: {
+    readonly SET_METADATA: 0;
     readonly TEXT_NOTE: 1;
-    /** Relay recommendation (NIP-01) */
     readonly RECOMMEND_SERVER: 2;
-    /** Contact list (NIP-02) */
-    readonly CONTACTS: 3;
-    /** Encrypted direct message (NIP-04) */
+    readonly CONTACT_LIST: 3;
     readonly ENCRYPTED_DIRECT_MESSAGE: 4;
-    /** Event deletion (NIP-09) */
     readonly DELETE: 5;
-    /** Event repost (NIP-18) */
     readonly REPOST: 6;
-    /** Reaction (NIP-25) */
     readonly REACTION: 7;
-    /** Badge award (NIP-58) */
     readonly BADGE_AWARD: 8;
-    /** Channel creation (NIP-28) */
     readonly CHANNEL_CREATE: 40;
-    /** Channel metadata (NIP-28) */
     readonly CHANNEL_METADATA: 41;
-    /** Channel message (NIP-28) */
     readonly CHANNEL_MESSAGE: 42;
-    /** Channel hide message (NIP-28) */
     readonly CHANNEL_HIDE_MESSAGE: 43;
-    /** Channel mute user (NIP-28) */
     readonly CHANNEL_MUTE_USER: 44;
-    /** File header (NIP-94) */
-    readonly FILE_HEADER: 1063;
-    /** File chunk (NIP-94) */
-    readonly FILE_CHUNK: 1064;
-};
-/**
- * Common Nostr tags as defined in various NIPs
- * @constant
- * @type {const}
- */
-export declare const NOSTR_TAG: {
-    /** Reference to another event */
-    readonly EVENT: "e";
-    /** Reference to a pubkey */
-    readonly PUBKEY: "p";
-    /** Reference to a replaceable event */
-    readonly REFERENCE: "a";
-    /** NIP-26 delegation tag */
-    readonly DELEGATION: "delegation";
-    /** Identifier for replaceable events */
-    readonly DEDUPLICATION: "d";
-    /** Event expiration timestamp */
-    readonly EXPIRATION: "expiration";
-    /** Event kind being referenced */
-    readonly KIND: "k";
-    /** Relay URL */
-    readonly RELAY: "r";
-    /** Subject or title */
-    readonly SUBJECT: "subject";
-    /** Content warning */
-    readonly CONTENT_WARNING: "content-warning";
-    /** Proof of work nonce */
-    readonly NONCE: "nonce";
+    readonly CHANNEL_RESERVED_FIRST: 40;
+    readonly CHANNEL_RESERVED_LAST: 49;
+    readonly REPORTING: 1984;
+    readonly ZAP_REQUEST: 9734;
+    readonly ZAP: 9735;
+    readonly MUTE_LIST: 10000;
+    readonly PIN_LIST: 10001;
+    readonly RELAY_LIST_METADATA: 10002;
+    readonly CLIENT_AUTH: 22242;
+    readonly CLIENT_ERROR: 23;
+    readonly PARAMETERIZED_REPLACEABLE_FIRST: 30000;
+    readonly PARAMETERIZED_REPLACEABLE_LAST: 39999;
+    readonly REPLACEABLE_FIRST: 10000;
+    readonly REPLACEABLE_LAST: 19999;
+    readonly EPHEMERAL_FIRST: 20000;
+    readonly EPHEMERAL_LAST: 29999;
+    readonly REGULAR_FIRST: 1000;
+    readonly REGULAR_LAST: 9999;
+    readonly CUSTOM_FIRST: 40000;
+    readonly CUSTOM_LAST: 49999;
 };
-/** Type for message types extracted from NOSTR_MESSAGE_TYPE constant */
-export type NostrMessageType = typeof NOSTR_MESSAGE_TYPE[keyof typeof NOSTR_MESSAGE_TYPE];
-/** Type for event kinds extracted from NOSTR_KIND constant */
-export type NostrKind = typeof NOSTR_KIND[keyof typeof NOSTR_KIND];
-/** Type for tags extracted from NOSTR_TAG constant */
-export type NostrTag = typeof NOSTR_TAG[keyof typeof NOSTR_TAG];