🐈‍⬛ on Nostr: ``` import { NSecSigner, NRelay1, NSchema as n } from '@nostrify/nostrify'; import { ...

```
import { NSecSigner, NRelay1, NSchema as n } from '@nostrify/nostrify';
import { BlossomUploader } from '@nostrify/nostrify/uploaders';
import * as nip19 from 'nostr-tools/nip19';

// Helper function to convert a hex string to Uint8Array
function hexToUint8Array(hex: string): Uint8Array {
if (hex.length % 2 !== 0) {
throw new Error("Hex string must have an even length");
}
const array = new Uint8Array(hex.length / 2);
for (let i = 0; i < hex.length; i += 2) {
array[i / 2] = parseInt(hex.substr(i, 2), 16);
}
return array;
}

// Function to read uploaded files from JSON
async function readUploadedFiles(uploadedFilesPath: string): Promise<Set<string>> {
try {
const data = await Deno.readTextFile(uploadedFilesPath);
return new Set(JSON.parse(data));
} catch {
return new Set();
}
}

// Function to write uploaded files to JSON
async function writeUploadedFiles(uploadedFiles: Set<string>, uploadedFilesPath: string) {
await Deno.writeTextFile(uploadedFilesPath, JSON.stringify(Array.from(uploadedFiles)));
}

// Function to append a URL to a text file
async function appendUrlToFile(fileUrl: string, urlFilePath: string) {
try {
await Deno.writeTextFile(urlFilePath, fileUrl + '\n', { append: true });
console.log(`Appended URL to file: ${fileUrl}`);
} catch (error) {
console.error('Error appending URL to file:', error);
}
}

// Function to sign, parse, and upload a media file
async function signAndUploadMedia(
filePath: string,
uploadedFiles: Set<string>,
urlFilePath: string,
signer: NSecSigner,
relays: { relay: NRelay1; url: string }[]
) {
try {
// Check if the file has already been uploaded
if (uploadedFiles.has(filePath)) {
console.log(`File ${filePath} has already been uploaded. Skipping.`);
return;
}

// Get the public key from the signer
const pubkey = await signer.getPublicKey();

// Initialize the uploader
const uploader = new BlossomUploader({
servers: [
'https://cdn.satellite.earth';,
'https://nstore.nostrver.se';,
'https://blossom.puhcho.me';,
'https://blossom.primal.net';,
'https://cdn.nostrcheck.me';
],
signer: signer,
});

// Read the file
const fileBuffer = await Deno.readFile(filePath);
const file = new File([fileBuffer], filePath.split('/').pop()!);

// Upload the file and get the tags
const tags = await uploader.upload(file);

// Find the URL in the tags
let fileUrl = 'Unknown URL';
for (const tag of tags) {
if (tag[0] === "url" && tag[1]) {
fileUrl = tag[1];
break;
}
}

// Append the URL to the text file
await appendUrlToFile(fileUrl, urlFilePath);

// Create event data
const eventData = {
kind: 1,
content: `${fileUrl}`,
tags: tags,
created_at: Math.floor(Date.now() / 1000),
};

// Sign the event to get id and sig
const signedEvent = await signer.signEvent(eventData);
const completeEventData = {
...eventData,
id: signedEvent.id,
pubkey: pubkey,
sig: signedEvent.sig,
};

// Parse and validate the complete event data using NSchema
const event = n.event().parse(completeEventData);
console.log('Parsed and validated event:', event);

// Send the event to each relay
for (const { relay, url } of relays) {
try {
console.log(`Sending event to relay ${url}`);
await relay.event(event);
console.log(`Event sent successfully to ${url}`);
} catch (error) {
console.error(`Error sending event to relay ${url}:`, error);
} finally {
try {
await relay.close();
console.log(`Relay ${url} closed`);
} catch (closeError) {
console.error(`Error closing relay ${url}:`, closeError);
}
}
}

// Add the file to the uploaded files set and update the JSON file
uploadedFiles.add(filePath);
await writeUploadedFiles(uploadedFiles, './uploaded_files.json');

console.log("Done!");
} catch (error) {
console.error('Error signing and uploading media:', error);
}
}

// Function to select a random valid file from a folder
async function getRandomValidFileFromFolder(folderPath: string, uploadedFiles: Set<string>): Promise<string | null> {
const validExtensions = ['jpg', 'mp4', 'webp', 'gif'];
const files: string[] = [];

for await (const dirEntry of Deno.readDir(folderPath)) {
if (dirEntry.isFile) {
const extension = dirEntry.name.split('.').pop()?.toLowerCase();
if (extension && validExtensions.includes(extension)) {
files.push(dirEntry.name);
}
}
}

// Filter out files that have already been uploaded
const unuploadedFiles = files.filter(file => !uploadedFiles.has(`${folderPath}/${file}`));

if (unuploadedFiles.length === 0) {
console.log('All files have been uploaded. Selecting a random URL to publish.');
return null;
}

const randomIndex = Math.floor(Math.random() * unuploadedFiles.length);
return `${folderPath}/${unuploadedFiles[randomIndex]}`;
}

// Function to publish a Nostr event with a random URL
async function publishRandomUrlEvent(urlFilePath: string, signer: NSecSigner, relays: { relay: NRelay1; url: string }[]) {
try {
const urls = (await Deno.readTextFile(urlFilePath)).trim().split('\n');

if (urls.length === 0) {
console.error('No URLs found in the URL file.');
return;
}

const randomUrl = urls[Math.floor(Math.random() * urls.length)];

// Create event data
const eventData = {
kind: 1,
content: `${randomUrl}`,
tags: [],
created_at: Math.floor(Date.now() / 1000),
};

// Sign the event to get id and sig
const signedEvent = await signer.signEvent(eventData);
const completeEventData = {
...eventData,
id: signedEvent.id,
pubkey: await signer.getPublicKey(),
sig: signedEvent.sig,
};

// Parse and validate the complete event data using NSchema
const event = n.event().parse(completeEventData);
console.log('Parsed and validated event:', event);

for (const { relay, url } of relays) {
try {
console.log(`Sending event to relay ${url}`);
await relay.event(event);
console.log(`Event sent successfully to ${url}`);
} catch (error) {
console.error(`Error sending event to relay ${url}:`, error);
} finally {
try {
await relay.close();
console.log(`Relay ${url} closed`);
} catch (closeError) {
console.error(`Error closing relay ${url}:`, closeError);
}
}
}

console.log("Published random URL event successfully!");

} catch (error) {

console.error('Error publishing random URL event:', error);

}

}

// Main function to execute the script
async function main() {

const hexSecretKey = Deno.env.get('SECRET_KEY_HEX');
if (!hexSecretKey) {

console.error('Environment variable "SECRET_KEY_HEX" is not set.');
Deno.exit(1);

return;

}

const secretKey: Uint8Array = hexToUint8Array(hexSecretKey);

// Initialize the signer with your secret key

const signer = new NSecSigner(secretKey);

// Define the relay URLs

const relayUrls = [

'wss://nostr.mom',
'wss://nos.lol',
'wss://relay.primal.net',
'wss://e.nos.lol',
'wss://relay.damus.io',
'wss://nostr.lu.ke',
'wss://nostr.oxtr.dev',
'wss://relay.nostrcheck.me',
'wss://nostr.data.haus',
'wss://ditto.puhcho.me/relay',
'wss://offchain.pub',
'wss://strfry.iris.to'

];

// Create an array of NRelay1 instances with their URLs

const relays = relayUrls.map(url => ({ relay: new NRelay1(url), url }));

// Path to the JSON file that stores uploaded files

const uploadedFilesPath = './home/user/test_bloom/uploaded_files.json';

// Path to the text file that stores uploaded URLs

const urlFilePath = './home/user/test_bloom/uploaded_urls.txt';

// Example usage

const folderPath = Deno.env.get('MEDIA_FOLDER_PATH');

if (folderPath) {

try {

const uploadedFiles = await readUploadedFiles(uploadedFilesPath);

const randomFilePath = await getRandomValidFileFromFolder(folderPath, uploadedFiles);

if (randomFilePath) {

await signAndUploadMedia(randomFilePath, uploadedFiles, urlFilePath, signer, relays);

} else {

await publishRandomUrlEvent(urlFilePath, signer, relays);

}

} catch (error) {

console.error('Error during execution:', error);

} finally {

Deno.exit();

}

} else {

console.error('Environment variable "MEDIA_FOLDER_PATH" is not set.');

Deno.exit(1);

}

}

// Execute main function

main();

```

Better as it was uploading to just one blossom.