GitHub - watzon/magnetar: A high-performance BitTorrent parsing and manipulation library

v install https://github.com/watzon/magnetar

git clone https://github.com/watzon/magnetar.git

import magnet

// Parse a magnet URI
magnet_uri := 'magnet:?xt=urn:btih:1234567890abcdef1234567890abcdef12345678&dn=Example%20File&tr=http://tracker.example.com:8080/announce'

mag := magnet.parse(magnet_uri) or {
    eprintln('Failed to parse magnet: ${err}')
    return
}

println('Info hash: ${mag.info_hash}')
println('Display name: ${mag.display_name}')
println('Trackers: ${mag.trackers}')

import magnet

// Using the builder pattern
mut builder := magnet.new_builder()
builder.set_info_hash('1234567890abcdef1234567890abcdef12345678')
builder.set_display_name('My File')
builder.add_tracker('http://tracker.example.com:8080/announce')
builder.add_tracker('udp://backup.tracker.com:8080')

mag := builder.build() or {
    eprintln('Failed to build magnet: ${err}')
    return
}

magnet_uri := mag.to_string()
println('Generated magnet: ${magnet_uri}')

import magnet

// Simple magnet with just hash and name
mag1 := magnet.create_simple_magnet(
    '1234567890abcdef1234567890abcdef12345678',
    'Simple File'
) or { panic(err) }

// Magnet with tracker
mag2 := magnet.create_magnet_with_tracker(
    '1234567890abcdef1234567890abcdef12345678',
    'File with Tracker',
    'http://tracker.example.com:8080/announce'
) or { panic(err) }

// Hybrid torrent (v1 + v2)
mag3 := magnet.create_hybrid_magnet(
    '1234567890abcdef1234567890abcdef12345678',        // v1 hash
    '1220d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2', // v2 hash
    'Hybrid Torrent'
) or { panic(err) }

import torrent
import magnet
import os

// Parse a torrent file
torrent_data := os.read_file('example.torrent') or { panic(err) }
metadata := torrent.parse_torrent_data(torrent_data.bytes()) or {
    eprintln('Failed to parse torrent: ${err}')
    return
}

println('Torrent name: ${metadata.info.name}')
println('Piece length: ${metadata.info.piece_length}')
println('Total size: ${metadata.total_size()}')

// Convert torrent to magnet link
mag := magnet.from_torrent(metadata)
magnet_uri := mag.to_string()
println('Magnet URI: ${magnet_uri}')

import bencode

// Create bencode data structures
announce := bencode.BencodeString{ value: 'http://tracker.example.com:8080/announce'.bytes() }
name := bencode.BencodeString{ value: 'example.txt'.bytes() }
length := bencode.BencodeInteger{ value: 1024 }

mut info_dict := bencode.BencodeDictionary{ pairs: map[string]bencode.BencodeValue{} }
info_dict.pairs['name'] = name
info_dict.pairs['length'] = length

mut root_dict := bencode.BencodeDictionary{ pairs: map[string]bencode.BencodeValue{} }
root_dict.pairs['announce'] = announce
root_dict.pairs['info'] = info_dict

// Encode the data
encoded := bencode.encode(root_dict)
println('Encoded: ${encoded}')

// Decode it back
original_data := bencode.decode(encoded) or { panic(err) }
println('Decoded: ${original_data}')

import magnet

mut builder := magnet.new_builder()

// Set hashes
builder.set_info_hash('1234567890abcdef1234567890abcdef12345678')
builder.set_info_hash_v2('1220d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2')

// Set metadata
builder.set_display_name('Complete Example')
builder.set_exact_length(1073741824) // 1GB

// Add trackers and peers
builder.add_tracker('http://tracker1.example.com:8080/announce')
builder.add_tracker('udp://tracker2.example.com:8080')
builder.add_peer('192.168.1.1:6881')
builder.add_peer('peer.example.com:6882')

// Add web seeds
builder.add_web_seed('http://webseed1.example.com/file')
builder.add_web_seed('http://webseed2.example.com/file')

// Add keywords
builder.add_keyword('video')
builder.add_keyword('movie')
builder.add_keyword('hd')

// Set file selection (download only specific files)
builder.set_select_only([0, 2, 4, 5, 6, 7]) // files 0, 2, and 4-7

// Add custom extensions
builder.add_extension('x.custom', 'custom_value')

mag := builder.build() or { panic(err) }

import magnet

// All parsing operations return Result types
magnet_uri := 'invalid-magnet-uri'

if mag := magnet.parse(magnet_uri) {
    println('Parsed successfully: ${mag.display_name}')
} else {
    eprintln('Parse error: ${err}')
    // Handle specific error types by checking message content
    if err.msg().contains('missing required field') {
        eprintln('Missing required info hash')
    } else if err.msg().contains('invalid hash') {
        eprintln('Invalid hash format')
    } else {
        eprintln('Other error: ${err}')
    }
}

import magnet

// Validate peer addresses
valid_peers := [
    '192.168.1.1:6881',      // IPv4
    'example.com:8080',       // hostname
    '[::1]:6881',            // IPv6
    '[2001:db8::1]:8080'     // IPv6 with port
]

for peer in valid_peers {
    if magnet.is_valid_peer_address(peer) {
        println('${peer} is valid')
    }
}