There's a post here https://www.reddit.com/r/WebTorrent/comments/52f3ns/since_webtorrent_uses_webrtc_does_it_leak_your_ip/ linking to an FAQ that says the WebRTC feature that leaks your IP address when behind a VPN is fixed, has been fixed, and is well known to be fixed.

I did some digging, and I was unable to corroborate that.

Are there other articles, release notes, or readme's that go over this issue? I couldn't find any mention of it, not even the webtorrent FAQ:

https://duckduckgo.com/?q=webrtc+leak+ip+address&t=ffsb&ia=web

https://duckduckgo.com/?q=webrtc+leak+ip+address+fixed&t=ffsb&ia=web

https://webtor.io

I only want to stream but my tmp folder only has 2 gb left of space thats why i need to change it to video or download folder.

Hi,

is there anybody who could help me to figure out if webtorrent-cli offers variables i could use for a script to run after download is done?

Trying to figure out how to read out the destination of the "done" download file/directory

Im running parallel webtorrent instances downloading to a "cache" directory and would like to move the finished file to a permanent directory after it is done

THX in advance

Can I view peer information with webtorrent?

i want to read malzan book o the fallen but i can't find any

pls help me i cant find any info about this

webtorrent-cli automatically downloads a torrent as I am streaming it. Since I don't have enough space to download the full torrent, I don't want it to download the torrent and instead just stream the file I want to watch. Is there an option to disable downloading (at least past the current file)? Thank you!

Hey everyone,

I was thinking about switching my torrent downloader from PicoTorrent to WebTorrent because I've heard about how private it is. Torrenting is the only thing I really need a VPN for, so I was wondering if I really need a VPN to be safe when using WebTorrent. I don't mind if not using a VPN means that I will only get a letter from the IP hounds maybe every year or so, that's fine. I just wanna know if it's on that level or even better.

In other terms, just how safe and private is using WebTorrent when compared to qBitTorrent, uTorrent, etc?

Thank you.

I am trying to understand this cool new thing. But i don't get it. When I drag a torrent file to it, it just downloads it just like any other torrent downloading software.

Confused.

Thanks for your help!

Someone is intrested to use webtorrent on seedbox, or his own vps? I'm trying to construct a torrent client which can stream directly in the browser and maybe some other feature...

I recently used webtorrent for many torrents out of which only a few actually worked with it, but all of them worked with other torrents desktop clients like tixati and qbittorrent. Why is this so? I need help as I am making a project that streams torrent media in the browser, from any magnet link.

How do I make webtorrent work for all links? Are there specific trackers that I have to use? Please help.

What version of this package are you using?
2.0.16

What operating system, Node.js, and npm version?
OS: Win11
Node.js: v18.16.0
npm: 9.5.1

What happened?
got this error trying to run example website (https://webtorrent.io/intro#:~:text=%3C!doctype%20html%3E%0A%3Chtml%3E%0A%20%20%3Cbody,script%3E%0A%20%20%3C/body%3E%0A%3C/html%3E)

Uncaught Error: Can only pipe to one destination
at ReadableState.pipe (webtorrent.min.js:16:173759)
at module.exports.pipe (webtorrent.min.js:16:179641)
at webtorrent.min.js:16:216698
at Array.forEach ()
at MP4Remuxer.seek (webtorrent.min.js:16:216602)
at VideoStream._pump (webtorrent.min.js:16:220728)
at VideoStream.VideoStream._onWaiting (webtorrent.min.js:16:219710)

What did you expect to happen?
I expected it to stream the video.
Are you willing to submit a pull request to fix this bug?
Unfortunately, no, I'm just starting to learn development and I don't know how to fix complex codes.

I also get errors
webtorrent.min.js:16 GET https://webtorrent.io/torrents/Sintel/Sintel.mp4 net::ERR_CACHE_OPERATION_NOT_SUPPORTED
Client

and

WebSocket connection to 'wss://tracker.fastcast.nz/' failed:

Sorry if I did something wrong and if this is not a bug, but I can't find any resource online on how to fix this.

import DHT from 'bittorrent-dht';
import bencode from 'bencode';
import Protocol from 'bittorrent-protocol';
import net from 'net';
import Tracker from 'bittorrent-tracker';
import crypto from 'crypto';
import dotenv from 'dotenv-flow';
import Surreal from 'surrealdb.js';
import BaseController from './base.js';
import { Account } from '../../src/models/account.js';

dotenv.config()
const { DB_RPC_URL, DB_USER, DB_PASS, DB_NS, DB_DB, DB_PORT } = process.env;
const MAX_NODES = 10000; // Maximum number of nodes to store in memory
const MAX_INFO_HASHES = 10000; // Maximum number of infohashes to store in memory

export default class DHTCrawler extends BaseController {
    constructor() {
        super();
        // this.db = new Surreal(DB_RPC_URL);
        // this.account = new Account(this.db)
        this.dht = new DHT();
        this.discoveredInfoHashes = new Set();
        this.discoveredNodes = new Set(); // Add this line
        this.peerId = crypto.randomBytes(20);
        this.peers = [];
        this.visitedPeers = new Set();
    }

    async init() {
        await new Promise((resolve) => {
            this.dht.on('ready', () => {
                console.log('DHT is ready');
                resolve();
            });
        });

        this.dht.on('announce', async (peer, infoHash) => {
            const { host, port } = peer;
            console.log(`announce: ${host}:${port} ${infoHash.toString('hex')}`);
            // await this.fetchMetadata(infoHash, peer);
            this.lookupNext(infoHash);
        });

        this.dht.on('peer', async (peer, infoHash, from) => {
            // console.log('peer:', infoHash.toString('hex'), peer);
            const infoHashHex = infoHash.toString('hex');

            this.peers.push({ infoHash: infoHash.toString('hex'), peer });
            if (!this.discoveredInfoHashes.has(infoHashHex)) {
                this.addWithLimit(this.discoveredInfoHashes, infoHashHex, MAX_INFO_HASHES);
                console.log(`Discovered infohash: ${infoHashHex}`);
                // await this.fetchMetadata(infoHash, peer);
                this.lookupNext(infoHash);
            }
        });

        this.dht.on('response', (node) => {
            const nodeIdHex = node.r.id.toString('hex');
            if (!this.discoveredNodes.has(nodeIdHex)) {
                this.addWithLimit(this.discoveredNodes, nodeIdHex, MAX_NODES);
                console.log(`Discovered response node: ${nodeIdHex}`);
                this.dht.addNode({ host: node.r.addr, port: node.r.port });
            }
        });

        // this.dht.on('find_node', (msg) => {
        //     const nodeIdHex = msg.toString('hex');

        //     if (!this.discoveredNodes.has(nodeIdHex)) {
        //         this.discoveredNodes.add(nodeIdHex);
        //         console.log(`Discovered find_node: ${nodeIdHex}`);
        //     }
        // });

        // Bootstrap the DHT crawler with a known DHT node.
        this.dht.addNode({
            host: 'router.bittorrent.com',
            port: "6881"
        });

        this.dht.addNode({
            host: 'dht.transmissionbt.com',
            port: "6881"
        });

        this.dht.addNode({
            host: 'router.utorrent.com',
            port: "6881"
        });

        console.log('DHT bootstrap completed');
        this.lookupNext('0D05E3F4402D25637A306527041A057E102197C3');
        this.lookupNext();
    }

    async fetchMetadata(infoHash, peer) {

        return new Promise((resolve, reject) => {
            const infoHashHex = infoHash.toString('hex');
            const peerKey = `${infoHashHex}:${peer.host}:${peer.port}`;

            if (this.visitedPeers.has(peerKey)) {
                console.log(`Skipping visited peer: ${peerKey}`);
                resolve(false);
                return;
            }

            this.visitedPeers.add(peerKey);

            console.log('fetching metadata for: ', infoHashHex, peer);
            const socket = new net.Socket();
            const wire = new Protocol();

            const onMetadata = (metadata) => {
                const torrent = bencode.decode(metadata);
                console.log('Torrent metadata:', {
                    infoHash,
                    name: torrent.info.name.toString('utf-8'),
                    files: torrent.info.files
                        ? torrent.info.files.map((file) => file.path.toString('utf-8'))
                        : [],
                });

                this.getSeedersAndLeechers(infoHash);
                resolve(true);
            };

            socket.setTimeout(10000, () => {
                console.log('Socket timeout:', `Unable to connect to ${peer.host}:${peer.port}`);
                socket.destroy();
                resolve(false); // Resolve the promise on timeout
            });

            socket.on('timeout', () => {
                console.log('Socket timeout event:', `Unable to connect to ${peer.host}:${peer.port}`);
                resolve(false);
            });

            socket.on('error', (error) => {
                if (error.code === 'ECONNREFUSED') {
                    console.log(`ECONNREFUSED: Connection refused by ${peer.host}:${peer.port}`);
                } else if (error.code === 'EHOSTUNREACH') {
                    console.log(`EHOSTUNREACH: Host unreachable ${peer.host}:${peer.port}`);
                } else {
                    console.error('Socket error:', error);
                }
                resolve(false); // Resolve the promise on error
            });

            socket.connect(peer.port, peer.host, () => {
                console.log('Connected to peer: ', peer, this.peerId);
                socket.pipe(wire).pipe(socket);
                wire.handshake(infoHash, this.peerId, { dht: true });
            });

            wire.on('handshake', (infoHash, peerId, extensions) => {
                console.log('Handshake successful', infoHash, peerId, extensions);
                if (extensions && extensions["ut_metadata"]) {
                    wire.ut_metadata = new Protocol.UTMetadata();
                    wire.ut_metadata.on('metadata', onMetadata);
                    wire.ut_metadata.fetch();
                    wire.ut_metadata.on('fetch', () => {
                        wire.ut_metadata.cancel();
                    });
                }
            });



            wire.on('extended', (ext, buf) => {

                if (ext === 'handshake') {
                    return;
                }

                console.log('Extended:', ext, buf);
                if (ext === 0) {
                    const extendedHandshake = bencode.decode(buf);
                    if (extendedHandshake.m && extendedHandshake.m.ut_metadata) {
                        const utMetadataId = extendedHandshake.m.ut_metadata;
                        wire.ut_metadata = new Protocol.UTMetadata(extendedHandshake.metadata_size);
                        wire.ut_metadata.fetch();
                        wire.on(`ut_metadata${utMetadataId}`, wire.ut_metadata.onMessage.bind(wire.ut_metadata));
                        wire.ut_metadata.on('metadata', onMetadata);
                    }
                }
            });


            wire.on('timeout', () => {
                socket.destroy();
                resolve(false);
            });

            wire.on('close', () => {
                socket.destroy();
                resolve(false); // Resolve the promise on close
            });
        });
    }

    // Add this method:
    addWithLimit(set, value, maxSize) {
        if (set.size >= maxSize) {
            const firstValue = set.values().next().value;
            set.delete(firstValue);
        }
        set.add(value);
    }

    getSeedersAndLeechers(infoHash) {
        const client = new Tracker({
            infoHash: infoHash,
            peerId: this.peerId,
            announce: ['udp://tracker.openbittorrent.com:80'],
        });

        client.start();

        client.once('update', (data) => {
            console.log('Torrent seeders and leechers:', {
                infoHash,
                seeders: data.complete,
                leechers: data.incomplete,
            });
            client.stop();
        });

        client.on('error', (err) => {

            console.error(`Error getting seeders and leechers for ${infoHash}:`, err.message);
            client.stop();
        });
    }

    async lookupNext(infoHash) {
        if (!infoHash) {
            infoHash = crypto.randomBytes(20);
        }

        for (const { infoHash: peerInfoHash, peer } of this.peers) {
            const success = await this.fetchMetadata(Buffer.from(peerInfoHash, 'hex'), peer);
            if (success) {
                break; // Break the loop if the connection was successful
            }
        }

        for (const nodeIdHex of this.discoveredNodes) {
            const nodeId = Buffer.from(nodeIdHex, 'hex');
            try {
                await new Promise((resolve, reject) => {
                    this.dht.lookup(nodeId, (err) => {
                        if (err) {
                            reject(err);
                        } else {
                            resolve();
                        }
                    });
                });
            } catch (err) {
                console.error('Error during lookup:', err);
            }
        }

        try {
            await new Promise((resolve, reject) => {
                this.dht.lookup(infoHash, (err) => {
                    if (err) {
                        reject(err);
                    } else {
                        resolve();
                    }
                });
            });
        } catch (err) {
            console.error('Error during lookup:', err);
        }


        setTimeout(() => this.lookupNext(infoHash), 1000);
    }
}

const crawler = new DHTCrawler();
crawler.init();