@nekosuneprojects/vector-sdk 1.0.2 → 1.0.3

package/dist/bot.d.ts

@@ -0,0 +1,43 @@
+import { ClientConfig, VectorClient } from './client.js';
+import { ProgressCallback } from './upload.js';
+export interface ImageMetadata {
+    blurhash: string;
+    width: number;
+    height: number;
+}
+export declare class AttachmentFile {
+    bytes: Buffer;
+    extension: string;
+    imgMeta?: ImageMetadata | undefined;
+    constructor(bytes: Buffer, extension: string, imgMeta?: ImageMetadata | undefined);
+    static fromPath(path: string): Promise<AttachmentFile>;
+    static fromBytes(bytes: Buffer, extension?: string): Promise<AttachmentFile>;
+}
+export declare function loadFile(path: string): Promise<AttachmentFile>;
+export declare function createProgressCallback(): ProgressCallback;
+export declare class VectorBot {
+    name: string;
+    displayName: string;
+    about: string;
+    picture: string;
+    banner: string;
+    nip05: string;
+    lud16: string;
+    readonly publicKey: string;
+    readonly privateKey: string;
+    readonly privateKeyBytes: Uint8Array;
+    readonly client: VectorClient;
+    private constructor();
+    static quick(privateKey: string): Promise<VectorBot>;
+    static new(privateKey: string, name: string, displayName: string, about: string, picture: string, banner: string, nip05: string, lud16: string, clientConfig?: ClientConfig): Promise<VectorBot>;
+    getChat(recipient: string): Channel;
+}
+export declare class Channel {
+    readonly recipient: string;
+    readonly baseBot: VectorBot;
+    constructor(recipient: string, baseBot: VectorBot);
+    sendPrivateMessage(message: string): Promise<boolean>;
+    sendReaction(referenceId: string, emoji: string): Promise<boolean>;
+    sendTypingIndicator(): Promise<boolean>;
+    sendPrivateFile(file?: AttachmentFile): Promise<boolean>;
+}

package/dist/bot.js

@@ -0,0 +1,210 @@
+import { promises as fs } from 'fs';
+import mime from 'mime-types';
+import { fileTypeFromBuffer } from 'file-type';
+import { finalizeEvent } from 'nostr-tools/pure';
+import * as kinds from 'nostr-tools/kinds';
+import * as nip04 from 'nostr-tools/nip04';
+import * as nip59 from 'nostr-tools/nip59';
+import { buildClient } from './client.js';
+import { createMetadata } from './metadata.js';
+import { calculateFileHash, encryptData, generateEncryptionParams } from './crypto.js';
+import { getServerConfig, uploadDataWithProgress } from './upload.js';
+import { normalizePublicKey } from './keys.js';
+export class AttachmentFile {
+    constructor(bytes, extension, imgMeta) {
+        this.bytes = bytes;
+        this.extension = extension;
+        this.imgMeta = imgMeta;
+    }
+    static async fromPath(path) {
+        const bytes = await fs.readFile(path);
+        return AttachmentFile.fromBytes(bytes);
+    }
+    static async fromBytes(bytes, extension) {
+        const resolvedExtension = extension ?? (await inferExtensionFromBytes(bytes));
+        return new AttachmentFile(bytes, resolvedExtension);
+    }
+}
+export async function loadFile(path) {
+    return AttachmentFile.fromPath(path);
+}
+async function inferExtensionFromBytes(bytes) {
+    const fileType = await fileTypeFromBuffer(bytes);
+    return fileType?.ext ?? 'bin';
+}
+export function createProgressCallback() {
+    return (percentage) => {
+        if (percentage !== null) {
+            console.log(`Upload progress: ${percentage}%`);
+        }
+    };
+}
+function sanitizeUrl(candidate, fallback) {
+    try {
+        return new URL(candidate).toString();
+    }
+    catch (error) {
+        console.error('Invalid URL provided, falling back', error);
+        return fallback;
+    }
+}
+export class VectorBot {
+    constructor(privateKey, name, displayName, about, picture, banner, nip05, lud16, client) {
+        this.name = name;
+        this.displayName = displayName;
+        this.about = about;
+        this.picture = picture;
+        this.banner = banner;
+        this.nip05 = nip05;
+        this.lud16 = lud16;
+        this.privateKey = privateKey;
+        this.privateKeyBytes = client.privateKeyBytes;
+        this.publicKey = client.publicKey;
+        this.client = client;
+    }
+    static async quick(privateKey) {
+        return VectorBot.new(privateKey, 'vector bot', 'Vector Bot', 'vector bot created with quick', 'https://example.com/avatar.png', 'https://example.com/banner.png', 'example@example.com', 'example@example.com');
+    }
+    static async new(privateKey, name, displayName, about, picture, banner, nip05, lud16, clientConfig) {
+        const resolvedPicture = sanitizeUrl(picture, 'https://example.com/avatar.png');
+        const resolvedBanner = sanitizeUrl(banner, 'https://example.com/banner.png');
+        const client = buildClient(privateKey, clientConfig);
+        const metadata = createMetadata(name, displayName, about, resolvedPicture, resolvedBanner, nip05, lud16);
+        try {
+            await client.setMetadata(metadata);
+        }
+        catch (error) {
+            console.error('Failed to set metadata', error);
+        }
+        return new VectorBot(client.privateKey, name, displayName, about, resolvedPicture, resolvedBanner, nip05, lud16, client);
+    }
+    getChat(recipient) {
+        return new Channel(recipient, this);
+    }
+}
+export class Channel {
+    constructor(recipient, baseBot) {
+        this.recipient = normalizePublicKey(recipient);
+        this.baseBot = baseBot;
+    }
+    async sendPrivateMessage(message) {
+        const createdAt = Math.floor(Date.now() / 1000);
+        const tags = [
+            ['p', this.recipient],
+            ['ms', (Date.now() % 1000).toString()],
+        ];
+        let sent = false;
+        try {
+            const payload = await nip04.encrypt(this.baseBot.privateKey, this.recipient, message);
+            const event = finalizeEvent({
+                kind: kinds.EncryptedDirectMessage,
+                created_at: createdAt,
+                tags,
+                content: payload,
+            }, this.baseBot.privateKeyBytes);
+            await this.baseBot.client.publishEvent(event);
+            sent = true;
+        }
+        catch (error) {
+            console.error('Failed to send NIP-04 private message', error);
+        }
+        try {
+            const rumor = {
+                kind: kinds.PrivateDirectMessage,
+                created_at: createdAt,
+                tags,
+                content: message,
+            };
+            const wrapped = nip59.wrapEvent(rumor, this.baseBot.privateKeyBytes, this.recipient);
+            await this.baseBot.client.publishEvent(wrapped);
+            sent = true;
+        }
+        catch (error) {
+            console.error('Failed to send NIP-59 gift-wrap', error);
+        }
+        return sent;
+    }
+    async sendReaction(referenceId, emoji) {
+        try {
+            const event = finalizeEvent({
+                kind: kinds.Reaction,
+                created_at: Math.floor(Date.now() / 1000),
+                tags: [
+                    ['e', referenceId],
+                    ['p', this.recipient],
+                    ['ms', (Date.now() % 1000).toString()],
+                ],
+                content: emoji,
+            }, this.baseBot.privateKeyBytes);
+            await this.baseBot.client.publishEvent(event);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to send reaction', error);
+            return false;
+        }
+    }
+    async sendTypingIndicator() {
+        try {
+            const now = Math.floor(Date.now() / 1000);
+            const event = finalizeEvent({
+                kind: kinds.Application,
+                created_at: now,
+                tags: [
+                    ['p', this.recipient],
+                    ['ms', (Date.now() % 1000).toString()],
+                    ['expiration', (now + 3600).toString()],
+                ],
+                content: 'typing',
+            }, this.baseBot.privateKeyBytes);
+            await this.baseBot.client.publishEvent(event);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to send typing indicator', error);
+            return false;
+        }
+    }
+    async sendPrivateFile(file) {
+        if (!file) {
+            console.error('No file provided for sendPrivateFile');
+            return false;
+        }
+        try {
+            const rawMimeType = mime.lookup(file.extension);
+            const mimeType = typeof rawMimeType === 'string' ? rawMimeType : 'application/octet-stream';
+            const params = generateEncryptionParams();
+            const encrypted = encryptData(file.bytes, params);
+            const fileHash = calculateFileHash(file.bytes);
+            const serverConfig = await getServerConfig();
+            const progressCallback = createProgressCallback();
+            const url = await uploadDataWithProgress(this.baseBot.privateKey, serverConfig, encrypted, mimeType, undefined, progressCallback);
+            const tags = [
+                ['p', this.recipient],
+                ['file-type', mimeType],
+                ['size', encrypted.length.toString()],
+                ['encryption-algorithm', 'aes-gcm'],
+                ['decryption-key', params.key],
+                ['decryption-nonce', params.nonce],
+                ['ox', fileHash],
+                ['ms', (Date.now() % 1000).toString()],
+            ];
+            if (file.imgMeta) {
+                tags.push(['blurhash', file.imgMeta.blurhash]);
+                tags.push(['dim', `${file.imgMeta.width}x${file.imgMeta.height}`]);
+            }
+            const event = finalizeEvent({
+                kind: kinds.FileMessage,
+                created_at: Math.floor(Date.now() / 1000),
+                tags,
+                content: url,
+            }, this.baseBot.privateKeyBytes);
+            await this.baseBot.client.publishEvent(event);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to send private file', error);
+            return false;
+        }
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+import { SimplePool, Event } from 'nostr-tools';
+import type { Metadata } from './metadata.js';
+export interface ClientConfig {
+    proxy?: string;
+    defaultRelays?: string[];
+}
+export declare class VectorClient {
+    readonly pool: SimplePool;
+    readonly relays: string[];
+    readonly publicKey: string;
+    readonly privateKey: string;
+    readonly privateKeyBytes: Uint8Array;
+    constructor(keys: string, config?: ClientConfig);
+    setMetadata(metadata: Metadata): Promise<void>;
+    publishEvent(event: Event, relays?: string[]): Promise<void>;
+    private publish;
+}
+export declare function buildClient(keys: string, config?: ClientConfig): VectorClient;

package/dist/client.js

@@ -0,0 +1,42 @@
+import { SimplePool } from 'nostr-tools';
+import { finalizeEvent, getPublicKey } from 'nostr-tools/pure';
+import { normalizePrivateKey } from './keys.js';
+const DEFAULT_RELAYS = [
+    'wss://jskitty.cat/nostr',
+    'wss://relay.damus.io',
+    'wss://auth.nostr1.com',
+    'wss://nostr.computingcache.com',
+];
+export class VectorClient {
+    constructor(keys, config) {
+        this.pool = new SimplePool();
+        const normalized = normalizePrivateKey(keys);
+        this.privateKey = normalized.hex;
+        this.privateKeyBytes = normalized.bytes;
+        this.publicKey = getPublicKey(this.privateKeyBytes);
+        this.relays = config?.defaultRelays ?? DEFAULT_RELAYS;
+    }
+    async setMetadata(metadata) {
+        const event = finalizeEvent({
+            kind: 0,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [],
+            content: JSON.stringify(metadata),
+        }, this.privateKeyBytes);
+        await this.publish(event, this.relays);
+    }
+    async publishEvent(event, relays) {
+        return this.publish(event, relays ?? this.relays);
+    }
+    async publish(event, relays) {
+        const results = await Promise.allSettled(this.pool.publish(relays, event));
+        const rejected = results.find((result) => result.status === 'rejected');
+        if (rejected && rejected.status === 'rejected') {
+            const reason = rejected.reason instanceof Error ? rejected.reason : new Error(String(rejected.reason));
+            throw reason;
+        }
+    }
+}
+export function buildClient(keys, config) {
+    return new VectorClient(keys, config);
+}

package/dist/crypto.d.ts

@@ -0,0 +1,9 @@
+export interface EncryptionParams {
+    key: string;
+    nonce: string;
+}
+export declare class CryptoError extends Error {
+}
+export declare function generateEncryptionParams(): EncryptionParams;
+export declare function encryptData(data: Buffer | Uint8Array, params: EncryptionParams): Buffer;
+export declare function calculateFileHash(data: Buffer): string;

package/dist/crypto.js

@@ -0,0 +1,19 @@
+import { randomBytes, createCipheriv, createHash } from 'crypto';
+export class CryptoError extends Error {
+}
+export function generateEncryptionParams() {
+    const key = randomBytes(32).toString('hex');
+    const nonce = randomBytes(16).toString('hex');
+    return { key, nonce };
+}
+export function encryptData(data, params) {
+    const key = Buffer.from(params.key, 'hex');
+    const nonce = Buffer.from(params.nonce, 'hex');
+    const cipher = createCipheriv('aes-256-gcm', key, nonce);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([encrypted, tag]);
+}
+export function calculateFileHash(data) {
+    return createHash('sha256').update(data).digest('hex');
+}

package/dist/demo.d.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from 'events';
+import type { Event } from 'nostr-tools';
+export type BotProfile = {
+    name: string;
+    displayName: string;
+    about: string;
+    picture: string;
+    banner: string;
+    nip05: string;
+    lud16: string;
+};
+export type BotClientOptions = {
+    privateKey: string;
+    relays: string[];
+    debug?: boolean;
+    profile?: Partial<BotProfile>;
+    reconnect?: boolean;
+    reconnectIntervalMs?: number;
+};
+export type MessageTags = {
+    pubkey: string;
+    kind: number;
+    rawEvent: Event;
+    wrapped?: boolean;
+    displayName?: string;
+};
+export declare class VectorBotClient extends EventEmitter {
+    private bot?;
+    private giftWrapSubscription?;
+    private dmSubscription?;
+    private readonly options;
+    private readonly profileCache;
+    private readonly connectionState;
+    private readonly reconnectingRelays;
+    private connectionMonitor?;
+    constructor(options: BotClientOptions);
+    connect(): Promise<void>;
+    sendMessage(recipient: string, message: string): Promise<boolean>;
+    sendFile(recipient: string, filePath: string): Promise<boolean>;
+    close(): void;
+    private startConnectionMonitor;
+    private reconnectRelay;
+    private setupSubscriptions;
+    private handleGiftWrap;
+    private handleDirectMessage;
+    private emitMessage;
+    private getProfile;
+    private log;
+}

package/dist/demo.js

@@ -0,0 +1,210 @@
+import { EventEmitter } from 'events';
+import * as nip04 from 'nostr-tools/nip04';
+import * as nip59 from 'nostr-tools/nip59';
+import { EncryptedDirectMessage, PrivateDirectMessage } from 'nostr-tools/kinds';
+import { VectorBot } from './bot.js';
+import { createGiftWrapSubscription } from './subscription.js';
+import { loadFile } from './bot.js';
+export class VectorBotClient extends EventEmitter {
+    constructor(options) {
+        super();
+        this.profileCache = new Map();
+        this.connectionState = new Map();
+        this.reconnectingRelays = new Set();
+        this.options = options;
+    }
+    async connect() {
+        if (!this.options.privateKey) {
+            throw new Error('Missing private key for bot client');
+        }
+        if (!this.options.relays.length) {
+            throw new Error('At least one relay is required');
+        }
+        const profile = {
+            name: 'vector-bot',
+            displayName: 'Vector Bot',
+            about: 'Vector bot created with the SDK',
+            picture: 'https://example.com/avatar.png',
+            banner: 'https://example.com/banner.png',
+            nip05: '',
+            lud16: '',
+            ...this.options.profile,
+        };
+        const bot = await VectorBot.new(this.options.privateKey, profile.name, profile.displayName, profile.about, profile.picture, profile.banner, profile.nip05, profile.lud16, { defaultRelays: this.options.relays });
+        this.bot = bot;
+        this.log('Connected. Bot public key:', bot.publicKey);
+        this.setupSubscriptions(bot);
+        this.startConnectionMonitor(bot);
+        this.emit('ready', {
+            pubkey: bot.publicKey,
+            profile: {
+                name: profile.name,
+                displayName: profile.displayName,
+            },
+        });
+    }
+    async sendMessage(recipient, message) {
+        if (!this.bot) {
+            throw new Error('Bot is not connected');
+        }
+        const channel = this.bot.getChat(recipient);
+        const sent = await channel.sendPrivateMessage(message);
+        this.log('Sent message to', recipient, 'status:', sent);
+        return sent;
+    }
+    async sendFile(recipient, filePath) {
+        if (!this.bot) {
+            throw new Error('Bot is not connected');
+        }
+        const channel = this.bot.getChat(recipient);
+        const file = await loadFile(filePath);
+        const sent = await channel.sendPrivateFile(file);
+        this.log('Sent file to', recipient, 'status:', sent);
+        return sent;
+    }
+    close() {
+        if (!this.bot) {
+            return;
+        }
+        if (this.connectionMonitor) {
+            clearInterval(this.connectionMonitor);
+            this.connectionMonitor = undefined;
+        }
+        this.giftWrapSubscription?.close('shutdown');
+        this.dmSubscription?.close('shutdown');
+        this.bot.client.pool.close(this.bot.client.relays);
+    }
+    startConnectionMonitor(bot) {
+        if (this.connectionMonitor) {
+            clearInterval(this.connectionMonitor);
+        }
+        const shouldReconnect = this.options.reconnect !== false;
+        const interval = this.options.reconnectIntervalMs ?? 15000;
+        this.connectionMonitor = setInterval(() => {
+            const status = bot.client.pool.listConnectionStatus();
+            for (const relay of bot.client.relays) {
+                const connected = status.get(relay) ?? false;
+                const previous = this.connectionState.get(relay);
+                this.connectionState.set(relay, connected);
+                if (previous === undefined) {
+                    if (!connected) {
+                        this.emit('disconnect', { relay, error: new Error('Relay disconnected') });
+                    }
+                }
+                else if (!connected && previous) {
+                    this.emit('disconnect', { relay, error: new Error('Relay disconnected') });
+                }
+                else if (connected && previous === false) {
+                    this.emit('reconnect', { relay });
+                }
+                if (shouldReconnect && !connected) {
+                    this.reconnectRelay(bot, relay);
+                }
+            }
+        }, interval);
+    }
+    async reconnectRelay(bot, relay) {
+        if (this.reconnectingRelays.has(relay)) {
+            return;
+        }
+        this.reconnectingRelays.add(relay);
+        try {
+            await bot.client.pool.ensureRelay(relay);
+            this.connectionState.set(relay, true);
+            this.emit('reconnect', { relay });
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+        finally {
+            this.reconnectingRelays.delete(relay);
+        }
+    }
+    setupSubscriptions(bot) {
+        const giftWrapFilter = createGiftWrapSubscription(bot.publicKey);
+        this.giftWrapSubscription = bot.client.pool.subscribe(bot.client.relays, giftWrapFilter, {
+            onevent: (event) => this.handleGiftWrap(bot, event),
+            onclose: (reasons) => {
+                this.log('Gift-wrap subscription closed:', reasons);
+                this.emit('disconnect', { relay: 'gift-wrap', error: new Error(reasons.join(', ')) });
+            },
+        });
+        const dmFilter = {
+            kinds: [EncryptedDirectMessage, PrivateDirectMessage],
+            '#p': [bot.publicKey],
+        };
+        this.dmSubscription = bot.client.pool.subscribe(bot.client.relays, dmFilter, {
+            onevent: (event) => this.handleDirectMessage(bot, event),
+            onclose: (reasons) => {
+                this.log('DM subscription closed:', reasons);
+                this.emit('disconnect', { relay: 'dm', error: new Error(reasons.join(', ')) });
+            },
+        });
+    }
+    handleGiftWrap(bot, event) {
+        try {
+            const rumor = nip59.unwrapEvent(event, bot.privateKeyBytes);
+            this.log('Gift-wrap rumor:', rumor);
+            if (rumor.kind === PrivateDirectMessage && rumor.content) {
+                this.emitMessage(bot, rumor.pubkey, rumor.kind, event, rumor.content, true);
+            }
+        }
+        catch (error) {
+            this.log('Failed to unwrap gift-wrap:', error);
+            this.emit('error', error);
+        }
+    }
+    handleDirectMessage(bot, event) {
+        if (event.kind !== EncryptedDirectMessage) {
+            this.log('Unhandled DM event:', event);
+            return;
+        }
+        try {
+            const message = nip04.decrypt(bot.privateKey, event.pubkey, event.content);
+            this.emitMessage(bot, event.pubkey, event.kind, event, message, false);
+        }
+        catch (error) {
+            this.log('Failed to decrypt NIP-04 DM:', error);
+            this.emit('error', error);
+        }
+    }
+    async emitMessage(bot, pubkey, kind, rawEvent, content, wrapped) {
+        const profile = await this.getProfile(bot, pubkey);
+        this.emit('message', profile?.displayName || profile?.name || pubkey, {
+            pubkey,
+            kind,
+            rawEvent,
+            wrapped,
+            displayName: profile?.displayName || profile?.name,
+        }, content, false);
+    }
+    async getProfile(bot, pubkey) {
+        if (this.profileCache.has(pubkey)) {
+            return this.profileCache.get(pubkey);
+        }
+        try {
+            const event = await bot.client.pool.get(bot.client.relays, { kinds: [0], authors: [pubkey], limit: 1 });
+            if (event && event.content) {
+                const metadata = JSON.parse(event.content);
+                const profile = {
+                    name: metadata.name,
+                    displayName: metadata.displayName,
+                };
+                this.profileCache.set(pubkey, profile);
+                return profile;
+            }
+        }
+        catch (error) {
+            this.log('Failed to load profile for', pubkey, error);
+            this.emit('error', error);
+        }
+        this.profileCache.set(pubkey, {});
+        return undefined;
+    }
+    log(...args) {
+        if (!this.options.debug) {
+            return;
+        }
+        console.log('[vector-bot]', ...args);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './bot.js';
+export * from './client.js';
+export * from './metadata.js';
+export * from './subscription.js';
+export * from './crypto.js';
+export * from './keys.js';
+export * from './upload.js';
+export * from './demo.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './bot.js';
+export * from './client.js';
+export * from './metadata.js';
+export * from './subscription.js';
+export * from './crypto.js';
+export * from './keys.js';
+export * from './upload.js';
+export * from './demo.js';

package/dist/keys.d.ts

@@ -0,0 +1,7 @@
+export declare class KeyFormatError extends Error {
+}
+export declare function normalizePrivateKey(privateKey: string): {
+    hex: string;
+    bytes: Uint8Array;
+};
+export declare function normalizePublicKey(publicKey: string): string;

package/dist/keys.js

@@ -0,0 +1,33 @@
+import { nip19 } from 'nostr-tools';
+import { bytesToHex, hexToBytes } from 'nostr-tools/utils';
+export class KeyFormatError extends Error {
+}
+export function normalizePrivateKey(privateKey) {
+    const trimmed = privateKey.trim();
+    if (trimmed.startsWith('nsec1')) {
+        const decoded = nip19.decode(trimmed);
+        if (decoded.type !== 'nsec') {
+            throw new KeyFormatError('Invalid nsec private key');
+        }
+        return { hex: bytesToHex(decoded.data), bytes: decoded.data };
+    }
+    if (!/^[0-9a-fA-F]{64}$/.test(trimmed)) {
+        throw new KeyFormatError('Private key must be a 32-byte hex string or nsec');
+    }
+    const hex = trimmed.toLowerCase();
+    return { hex, bytes: hexToBytes(hex) };
+}
+export function normalizePublicKey(publicKey) {
+    const trimmed = publicKey.trim();
+    if (trimmed.startsWith('npub1')) {
+        const decoded = nip19.decode(trimmed);
+        if (decoded.type !== 'npub') {
+            throw new KeyFormatError('Invalid npub public key');
+        }
+        return decoded.data;
+    }
+    if (!/^[0-9a-fA-F]{64}$/.test(trimmed)) {
+        throw new KeyFormatError('Public key must be a 32-byte hex string or npub');
+    }
+    return trimmed.toLowerCase();
+}

package/dist/metadata.d.ts

@@ -0,0 +1,42 @@
+export interface Metadata {
+    name: string;
+    displayName: string;
+    about: string;
+    picture?: string;
+    banner?: string;
+    nip05?: string;
+    lud16?: string;
+    bot?: true;
+}
+export interface MetadataConfigFields {
+    name: string;
+    displayName: string;
+    about: string;
+    picture?: string;
+    banner?: string;
+    nip05?: string;
+    lud16?: string;
+}
+export declare class MetadataConfig {
+    name: string;
+    displayName: string;
+    about: string;
+    picture?: string | undefined;
+    banner?: string | undefined;
+    nip05?: string | undefined;
+    lud16?: string | undefined;
+    constructor(name: string, displayName: string, about: string, picture?: string | undefined, banner?: string | undefined, nip05?: string | undefined, lud16?: string | undefined);
+    build(): Metadata;
+}
+export declare class MetadataConfigBuilder {
+    private config;
+    name(value: string): this;
+    displayName(value: string): this;
+    about(value: string): this;
+    picture(value: string): this;
+    banner(value: string): this;
+    nip05(value: string): this;
+    lud16(value: string): this;
+    build(): Metadata;
+}
+export declare function createMetadata(name: string, displayName: string, about: string, picture?: string, banner?: string, nip05?: string, lud16?: string): Metadata;

package/dist/metadata.js

@@ -0,0 +1,66 @@
+export class MetadataConfig {
+    constructor(name, displayName, about, picture, banner, nip05, lud16) {
+        this.name = name;
+        this.displayName = displayName;
+        this.about = about;
+        this.picture = picture;
+        this.banner = banner;
+        this.nip05 = nip05;
+        this.lud16 = lud16;
+    }
+    build() {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            about: this.about,
+            picture: this.picture,
+            banner: this.banner,
+            nip05: this.nip05,
+            lud16: this.lud16,
+            bot: true,
+        };
+    }
+}
+export class MetadataConfigBuilder {
+    constructor() {
+        this.config = {
+            name: '',
+            displayName: '',
+            about: '',
+        };
+    }
+    name(value) {
+        this.config.name = value;
+        return this;
+    }
+    displayName(value) {
+        this.config.displayName = value;
+        return this;
+    }
+    about(value) {
+        this.config.about = value;
+        return this;
+    }
+    picture(value) {
+        this.config.picture = value;
+        return this;
+    }
+    banner(value) {
+        this.config.banner = value;
+        return this;
+    }
+    nip05(value) {
+        this.config.nip05 = value;
+        return this;
+    }
+    lud16(value) {
+        this.config.lud16 = value;
+        return this;
+    }
+    build() {
+        return new MetadataConfig(this.config.name, this.config.displayName, this.config.about, this.config.picture, this.config.banner, this.config.nip05, this.config.lud16).build();
+    }
+}
+export function createMetadata(name, displayName, about, picture, banner, nip05, lud16) {
+    return new MetadataConfig(name, displayName, about, picture, banner, nip05, lud16).build();
+}

package/dist/subscription.d.ts

@@ -0,0 +1,10 @@
+import { Filter } from 'nostr-tools';
+export declare class SubscriptionError extends Error {
+}
+export interface SubscriptionConfig {
+    pubkey: string;
+    kind: number;
+    limit: number;
+}
+export declare const DEFAULT_SUBSCRIPTION_CONFIG: SubscriptionConfig;
+export declare function createGiftWrapSubscription(pubkey: string, kind?: number, limit?: number): Filter;

package/dist/subscription.js

@@ -0,0 +1,20 @@
+import { GiftWrap } from 'nostr-tools/kinds';
+export class SubscriptionError extends Error {
+}
+export const DEFAULT_SUBSCRIPTION_CONFIG = {
+    pubkey: '',
+    kind: GiftWrap,
+    limit: 0,
+};
+export function createGiftWrapSubscription(pubkey, kind, limit) {
+    const resolvedKind = kind ?? GiftWrap;
+    const resolvedLimit = limit ?? 0;
+    if (resolvedLimit > 1000) {
+        throw new SubscriptionError('Limit exceeds maximum allowed value (1000)');
+    }
+    return {
+        kinds: [resolvedKind],
+        '#p': [pubkey],
+        limit: resolvedLimit,
+    };
+}

package/dist/upload.d.ts

@@ -0,0 +1,20 @@
+export interface ServerConfig {
+    api_url: string;
+}
+export declare class UploadConfig {
+    connectTimeout: number;
+    stallThreshold: number;
+    poolMaxIdle: number;
+    constructor(connectTimeout?: number, stallThreshold?: number, poolMaxIdle?: number);
+}
+export declare class UploadParams {
+    retryCount: number;
+    retrySpacing: number;
+    chunkSize: number;
+    constructor(retryCount?: number, retrySpacing?: number, chunkSize?: number);
+}
+export type ProgressCallback = (percentage: number | null, bytes?: number) => void;
+export declare class UploadError extends Error {
+}
+export declare function getServerConfig(): Promise<ServerConfig>;
+export declare function uploadDataWithProgress(signerPrivateKey: string, config: ServerConfig, fileData: Buffer, mimeType: string | undefined, proxy: string | undefined, progressCallback: ProgressCallback, params?: UploadParams, _config?: UploadConfig): Promise<string>;

package/dist/upload.js

@@ -0,0 +1,93 @@
+import fetch from 'node-fetch';
+import FormData from 'form-data';
+import { sha256 } from '@noble/hashes/sha256';
+import * as secp from '@noble/secp256k1';
+import { bytesToHex } from '@noble/hashes/utils';
+import { getPublicKey } from 'nostr-tools/pure';
+import { normalizePrivateKey } from './keys.js';
+const TRUSTED_PRIVATE_NIP96 = 'https://medea-1-swiss.vectorapp.io';
+export class UploadConfig {
+    constructor(connectTimeout = 5000, stallThreshold = 200, poolMaxIdle = 2) {
+        this.connectTimeout = connectTimeout;
+        this.stallThreshold = stallThreshold;
+        this.poolMaxIdle = poolMaxIdle;
+    }
+}
+export class UploadParams {
+    constructor(retryCount = 3, retrySpacing = 2000, chunkSize = 64 * 1024) {
+        this.retryCount = retryCount;
+        this.retrySpacing = retrySpacing;
+        this.chunkSize = chunkSize;
+    }
+}
+export class UploadError extends Error {
+}
+let cachedConfig = null;
+export async function getServerConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const response = await fetch(TRUSTED_PRIVATE_NIP96);
+    if (!response.ok) {
+        throw new UploadError('Failed to fetch NIP-96 server configuration');
+    }
+    const payload = (await response.json());
+    if (!payload.api_url) {
+        throw new UploadError('Malformed server configuration');
+    }
+    cachedConfig = { api_url: payload.api_url };
+    return cachedConfig;
+}
+async function buildNip98Authorization(privateKey, method, url, payload) {
+    const normalized = normalizePrivateKey(privateKey);
+    const dataHash = bytesToHex(sha256(payload));
+    const message = `${method.toUpperCase()}\n${url}\n${dataHash}`;
+    const messageHash = bytesToHex(sha256(Buffer.from(message, 'utf8')));
+    const signature = bytesToHex(await secp.sign(messageHash, normalized.hex));
+    const publicKey = getPublicKey(normalized.bytes);
+    return `NIP98 ${publicKey}:${signature}`;
+}
+export async function uploadDataWithProgress(signerPrivateKey, config, fileData, mimeType, proxy, progressCallback, params = new UploadParams(), _config = new UploadConfig()) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= params.retryCount; attempt += 1) {
+        if (attempt > 0) {
+            await new Promise((resolve) => setTimeout(resolve, params.retrySpacing));
+        }
+        try {
+            const authHeader = await buildNip98Authorization(signerPrivateKey, 'POST', config.api_url, fileData);
+            const form = new FormData();
+            form.append('file', fileData, {
+                filename: 'attachment',
+                contentType: mimeType ?? 'application/octet-stream',
+            });
+            progressCallback(0, 0);
+            const response = await fetch(config.api_url, {
+                method: 'POST',
+                headers: {
+                    Authorization: authHeader,
+                    ...form.getHeaders(),
+                },
+                body: form,
+            });
+            if (!response.ok) {
+                throw new UploadError(`Upload failed (${response.status})`);
+            }
+            progressCallback(100, fileData.length);
+            const payload = (await response.json());
+            if (payload.status === 'error') {
+                throw new UploadError(payload.message ?? 'Upload server reported an error');
+            }
+            const tags = payload.nip94_event?.tags ?? [];
+            const urlTag = tags.find((tag) => tag[0] === 'u' || tag[0] === 'url');
+            const url = urlTag?.[1];
+            if (!url) {
+                throw new UploadError('Upload response is missing a URL tag');
+            }
+            return url;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new UploadError('Unknown upload error');
+        }
+    }
+    throw lastError ?? new UploadError('Upload failed without a recorded error');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nekosuneprojects/vector-sdk",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Node.js reimplementation of the Vector Bot SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepack": "npm run build",
     "test": "npm run build"
   },
   "repository": {