Create a Torrent Application with Node from scratch.

const path = require('path');const { readdir, stat } = require('fs/promises');const index = new Map();async function* findFiles (folder) {  for (let filename of await readdir(folder)) {    const filepath = path.resolve(folder, filename);    const filestats = await stat(filepath);    if (filestats.isDirectory()) {      yield* findFiles(filepath);    } else {      yield { path: filepath, size: filestats.size };    }  }};(async () => {  console.log('Start indexing files...');  for await (let { path, size } of findFiles(process.cwd())) {    const [name] = path.split('/').slice(-1);    const hash = await hashFile(path);    index.set(hash, { hash, size, name, path });  }  console.log(`Directory content indexed, ${index.size} files found`);})();

const EventEmitter = require('events');const createNode = require('swenssonp2p');const main = new EventEmitter();const node = createNode();const port = Number(process.argv[2]);setTimeout(() => {  node.listen(port, () => main.emit('startup', port));}, 0);

main.on('startup', (port) => {  console.log(`Node is up on ${port}.`);  console.log('');  main.emit('help');  process.stdin.on('data', (data) => main.emit('command', data.toString()));});

main.on('help', () => {  console.log('  write "connect IP:PORT" to connect to other nodes on the network.');});main.on('command', (text) => {  if (text.startsWith('connect')) {    const ipport = text.substr(8);    const [ip, port] = ipport.split(':');    console.log(`Connecting to ${ip} at ${Number(port)}...`);    node.connect(ip, Number(port), () => {      console.log(`Connection to ${ip} established.`);    });  }});

main.on('help', () => {  console.log('  write "search FILENAME" to look for files.');});// Once the command arrives, we broadcast the search message on the networkmain.on('command', (text) => {  if (text.startsWith('search')) {    const searchRequest = text.substr(7).trim();    console.log(`Searching for file by "${searchRequest}"...`);    node.broadcast({ type: 'search', meta: searchRequest });  }});// Once we receive this message (on another node), we reply with resultsnode.on('broadcast', ({ origin, message: { type, meta }}) => {  if (type === 'search' && origin !== node.id) {    for (let key of index.keys()) {      const data = index.get(key);      if (data.name.toLowerCase().includes(meta.toLowerCase())) {        node.direct(origin, { type: 'search/response', meta: data });      }    }  }});// Once we receive the response from the file holder, we display itnode.on('direct', ({ origin, message: { type, meta: { name, size, hash } }}) => {  if (type === 'search/response') {    console.log(`  ${name} ${formatSize(size)} ${hash}`);  }});

main.on('help', () => {  console.log('  write "download HASH" to start downloading file');});main.on('command', (text) => {  if (text.startsWith('download')) {    const hash = text.substr(9).trim();    main.emit('download', hash);  }});

const downloads = {};main.on('download', (hash) => {  node.broadcast({ type: 'download', meta: hash });});node.on('broadcast', ({ origin, message: { type, meta } }) => {  if (type === 'download' && origin !== node.id) {    const data = index.get(meta);    if (!!data) {      node.direct(origin, { type: 'download/response', meta: { ip: Array.from(node.addresses)[0], hash: data.hash, size: data.size, name: data.name } })    }  }});node.on('direct', ({ origin, message: { type, meta } }) => {  if (type === 'download/response') {    if (!downloads[meta.hash]) {      downloads[meta.hash] = {        hash,        name: meta.name,        size: meta.size,        seeds: [meta.ip],        chunks: [],      };      main.emit('download/ready', meta.hash);    } else {      downloads[meta.hash].seeds.push(meta.ip);      main.emit('download/update', meta.hash);    }  }});

const FILES_SERVER_PORT = 9019;const CHUNK_SIZE = 512;const filesServer = net.createServer((socket) => {  socket.on('data', (data) => {    const { hash, offset } = JSON.parse(data);    const meta = index.get(hash);    const chunk = Buffer.alloc(CHUNK_SIZE);    const file = await open(meta.path, 'r');    await file.read(chunk, 0, CHUNK_SIZE, offset * CHUNK_SIZE);    await file.close();    socket.write(JSON.stringify({ hash, offset, chunk }));  });}).listen(FILES_SERVER_PORT);

main.on('download/ready', async (hash) => {  downloads[hash].chunks = [...new Array(Math.ceil(downloads[hash].size / CHUNK_SIZE))].map(() => ({ state: 0 }));});

downloads[hash].path = path.resolve(DOWNLOADS_PATH, `${hash}.download`);  const file = await open(downloads[hash].path, 'w');

  const sockets = {};  const updateSocketsList = async ($hash) => {    if ($hash !== hash) {      return;    }    for (let ip of downloads[hash].seeds) {      if (!sockets[ip]) {        const socket = new net.Socket();        socket.connect(FILES_SERVER_PORT, ip, () => {          sockets[ip] = { socket, busy: false };        });      }    }  };  updateSocketsList(hash);  main.on('download/update', updateSocketsList);  // ... TODO  main.off('download/update', updateSocketsList);

while (!!downloads[hash].chunks.find((chunk) => chunk.state !== 2)) {    const availableChunkIndex = downloads[hash].chunks.findIndex((chunk) => chunk.state === 0);    const availableSocket = Object.values(sockets).find(({ busy }) => !busy);    if (!availableSocket || !availableChunkIndex) {      await new Promise((resolve) => setTimeout(() => resolve(), 50));      continue;    }    availableSocket.busy = true;    downloads[hash].chunks[availableChunkIndex].state = 1;    ;(async () => {      const chunk = await downloadChunk(availableSocket.socket, hash, availableChunkIndex);      await file.write(Buffer.from(chunk), 0, CHUNK_SIZE, availableChunkIndex * CHUNK_SIZE);      downloads[hash].chunks[availableChunkIndex].state = 2;      availableSocket.busy = false;    })();  }

const downloadChunk = (socket, hash, offset) => new Promise((resolve) => {  socket.write(JSON.stringify({ hash, offset }));  const listener = (message) => {    if (hash === message.hash && offset === message.offset) {      resolve(message.chunk);      socket.off('data', listener);    }  };  socket.on('data', listener);});

await file.close();  await rename(downloads[hash].path, path.resolve(DOWNLOADS_PATH, downloads[hash].name));  main.off('download/update', updateSocketsList);  for (let { socket } of Object.values(sockets)) {    socket.destroy();  }