Bittorrent Integration [draft]

.gitignore

@@ -46,4 +46,4 @@ docker/prometheus-data
 nim.cfg
 tests/integration/logs
 
-data/
+data*/

codex/bittorrent/bencoding.nim

@@ -0,0 +1,29 @@
+## Nim-Codex
+## Copyright (c) 2025 Status Research & Development GmbH
+## Licensed under either of
+##  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+##  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+## at your option.
+## This file may not be copied, modified, or distributed except according to
+## those terms.
+
+{.push raises: [].}
+
+import std/strformat
+
+import pkg/stew/byteutils
+
+func bencode*(value: uint64): seq[byte] =
+  fmt"i{value}e".toBytes
+
+func bencode*(value: int64): seq[byte] =
+  fmt"i{value}e".toBytes
+
+func bencode*(value: openArray[byte]): seq[byte] =
+  fmt"{value.len}:".toBytes & @value
+
+func bencode*(value: string): seq[byte] =
+  bencode(value.toBytes)
+
+proc bencode*[T: not byte](value: openArray[T]): seq[byte] =
+  fmt"l{value.mapIt(bencode(it).toString).join}e".toBytes

codex/bittorrent/magnetlink.nim

@@ -0,0 +1,107 @@
+import std/strutils
+import std/sequtils
+
+import pkg/stew/byteutils
+import pkg/libp2p/[multicodec, multihash]
+import pkg/questionable
+import pkg/questionable/results
+
+import ../errors
+import ./manifest/manifest
+
+type
+  TorrentVersion* = enum
+    v1
+    v2
+    hybrid
+
+  MagnetLink* = ref object
+    version: TorrentVersion
+    infoHashV1: ?MultiHash
+    infoHashV2: ?MultiHash
+
+proc version*(self: MagnetLink): TorrentVersion =
+  ## Get the version of the magnet link
+  ##
+  ## returns: the version of the magnet link
+  result = self.version
+
+proc infoHashV1*(self: MagnetLink): ?MultiHash =
+  ## Get the info hash of the magnet link
+  ##
+  ## returns: the info hash of the magnet link
+  result = self.infoHashV1
+
+proc infoHashV2*(self: MagnetLink): ?MultiHash =
+  ## Get the info hash of the magnet link
+  ##
+  ## returns: the info hash of the magnet link
+  result = self.infoHashV2
+
+proc parseMagnetLink(link: string): ?!MagnetLink =
+  let prefix = "magnet:?"
+  if not link.startsWith(prefix):
+    return failure("Invalid magnet link format (missing 'magnet:?' prefix)")
+  let infoHashParts = link[prefix.len .. ^1].split("&").filterIt(it.startsWith("xt="))
+  if infoHashParts.len < 1:
+    return
+      failure("Invalid magnet link format (at least one info hash part is required)")
+  let v1Prefix = "xt=urn:btih:"
+  let v2Prefix = "xt=urn:btmh:"
+  var infoHashV1 = none(MultiHash)
+  var infoHashV2 = none(MultiHash)
+  for infoHashPart in infoHashParts:
+    # var a = infoHashPart[v1Prefix.len .. ^1]
+    if infoHashPart.startsWith(v1Prefix):
+      without infoHash =? BitTorrentInfo.buildMultiHash(
+        infoHashPart[v1Prefix.len .. ^1]
+      ), err:
+        return failure("Error parsing info hash: " & err.msg)
+      infoHashV1 = some(infoHash)
+    elif infoHashPart.startsWith(v2Prefix):
+      without infoHash =? BitTorrentInfo.buildMultiHash(
+        infoHashPart[v2Prefix.len .. ^1]
+      ), err:
+        return failure("Error parsing info hash: " & err.msg)
+      infoHashV2 = some(infoHash)
+
+  if infoHashV1.isNone and infoHashV2.isNone:
+    return failure("Invalid magnet link format (missing info hash part)")
+
+  var version: TorrentVersion
+  if infoHashV1.isSome and infoHashV2.isSome:
+    version = TorrentVersion.hybrid
+  elif infoHashV1.isSome:
+    version = TorrentVersion.v1
+  else:
+    version = TorrentVersion.v2
+
+  let magnetLink =
+    MagnetLink(version: version, infoHashV1: infoHashV1, infoHashV2: infoHashV2)
+  return success(magnetLink)
+
+proc getHashHex(multiHash: MultiHash): string =
+  ## Get the info hash of the magnet link as a hex string
+  result = byteutils.toHex(multiHash.data.buffer[multiHash.dpos .. ^1]).toUpperAscii()
+
+proc `$`*(self: MagnetLink): string =
+  ## Convert the magnet link to a string
+  ##
+  ## returns: the magnet link as a string
+  if self.version == TorrentVersion.hybrid:
+    result =
+      "magnet:?xt=urn:btih:" & (!self.infoHashV1).getHashHex() & "&xt=urn:btmh:" &
+      (!self.infoHashV2).hex
+  elif self.version == v1:
+    result = "magnet:?xt=urn:btih:" & (!self.infoHashV1).getHashHex()
+  else:
+    result = "magnet:?xt=urn:btmh:" & (!self.infoHashV2).hex
+
+proc newMagnetLink*(magnetLinkString: string): ?!MagnetLink =
+  ## Create a new magnet link
+  ##
+  ## version: the version of the magnet link
+  ## magnetLinkString: text containing the magnet link
+  ##
+  ## returns: a Result containing a magnet link object or a failure
+  parseMagnetLink(magnetLinkString)

codex/bittorrent/manifest.nim

@@ -0,0 +1,5 @@
+import ./manifest/manifest
+import ./manifest/encoding
+import ./manifest/decoding
+
+export manifest, encoding, decoding

codex/bittorrent/manifest/decoding.nim

@@ -0,0 +1,90 @@
+## Nim-Codex
+## Copyright (c) 2021 Status Research & Development GmbH
+## Licensed under either of
+##  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+##  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+## at your option.
+## This file may not be copied, modified, or distributed except according to
+## those terms.
+
+{.push raises: [].}
+
+import pkg/libp2p/cid
+import pkg/libp2p/multihash
+import pkg/libp2p/protobuf/minprotobuf
+
+import pkg/questionable/results
+
+import ../../blocktype
+import ./manifest
+
+func decode*(_: type BitTorrentManifest, data: openArray[byte]): ?!BitTorrentManifest =
+  # ```protobuf
+  #   Message BitTorrentManifest {
+  #     Message Piece {
+  #       bytes data = 1;
+  #     }
+  #   
+  #     Message BitTorrentInfo {
+  #       uint32 length = 1;
+  #       uint32 pieceLength = 2;
+  #       repeated Piece pieces = 3;
+  #       optional string name = 4;
+  #     }
+  #
+  #     BitTorrentInfo info = 1;
+  #     bytes codexManifestCid = 2;
+  # ```
+
+  var
+    pbNode = initProtoBuffer(data)
+    pbInfo: ProtoBuffer
+    length: uint64
+    pieceLength: uint32
+    pieces: seq[MultiHash]
+    piecesBytes: seq[seq[byte]]
+    name: string
+    cidBuf = newSeq[byte]()
+    codexManifestCid: Cid
+
+  if pbNode.getField(1, pbInfo).isErr:
+    return failure("Unable to decode `info` from BitTorrentManifest")
+
+  if pbInfo.getField(1, length).isErr:
+    return failure("Unable to decode `length` from BitTorrentInfo")
+
+  if pbInfo.getField(2, pieceLength).isErr:
+    return failure("Unable to decode `pieceLength` from BitTorrentInfo")
+
+  if ?pbInfo.getRepeatedField(3, piecesBytes).mapFailure:
+    for piece in piecesBytes:
+      var pbPiece = initProtoBuffer(piece)
+      var dataBuf = newSeq[byte]()
+      if pbPiece.getField(1, dataBuf).isErr:
+        return failure("Unable to decode piece `data` to MultiHash")
+      without mhash =? MultiHash.init(dataBuf).mapFailure, err:
+        return failure(err.msg)
+      pieces.add(mhash)
+  discard ?pbInfo.getField(4, name).mapFailure
+
+  if ?pbNode.getField(2, cidBuf).mapFailure:
+    without cid =? Cid.init(cidBuf).mapFailure, err:
+      return failure(err.msg)
+    codexManifestCid = cid
+
+  let info = BitTorrentInfo(
+    length: length,
+    pieceLength: pieceLength,
+    pieces: pieces,
+    name: if name.len > 0: name.some else: string.none,
+  )
+  BitTorrentManifest(info: info, codexManifestCid: codexManifestCid).success
+
+func decode*(_: type BitTorrentManifest, blk: Block): ?!BitTorrentManifest =
+  ## Decode a manifest using `decoder`
+  ##
+
+  if not ?blk.cid.isTorrentInfoHash:
+    return failure "Cid not a torrent info hash codec"
+
+  BitTorrentManifest.decode(blk.data)

codex/bittorrent/manifest/encoding.nim

@@ -0,0 +1,59 @@
+## Nim-Codex
+## Copyright (c) 2021 Status Research & Development GmbH
+## Licensed under either of
+##  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
+##  * MIT license ([LICENSE-MIT](LICENSE-MIT))
+## at your option.
+## This file may not be copied, modified, or distributed except according to
+## those terms.
+
+{.push raises: [].}
+
+import pkg/libp2p/cid
+import pkg/libp2p/multihash
+import pkg/libp2p/protobuf/minprotobuf
+
+import pkg/questionable/results
+
+import ./manifest
+
+proc write(pb: var ProtoBuffer, field: int, value: MultiHash) =
+  var ipb = initProtoBuffer()
+  ipb.write(1, value.data.buffer)
+  ipb.finish()
+  pb.write(field, ipb)
+
+proc write(pb: var ProtoBuffer, field: int, value: BitTorrentInfo) =
+  var ipb = initProtoBuffer()
+  ipb.write(1, value.length)
+  ipb.write(2, value.pieceLength)
+  for piece in value.pieces:
+    ipb.write(3, piece)
+  if name =? value.name:
+    ipb.write(4, name)
+  ipb.finish()
+  pb.write(field, ipb)
+
+proc encode*(manifest: BitTorrentManifest): seq[byte] =
+  # ```protobuf
+  #   Message BitTorrentManifest {
+  #     Message Piece {
+  #       bytes data = 1;
+  #     }
+  #   
+  #     Message BitTorrentInfo {
+  #       uint32 length = 1;
+  #       uint32 pieceLength = 2;
+  #       repeated Piece pieces = 3;
+  #       optional string name = 4;
+  #     }
+  #
+  #     BitTorrentInfo info = 1;
+  #     bytes codexManifestCid = 2;
+  # ```
+
+  var ipb = initProtoBuffer()
+  ipb.write(1, manifest.info)
+  ipb.write(2, manifest.codexManifestCid.data.buffer)
+  ipb.finish()
+  ipb.buffer