bun-torrent 0.0.1-beta

package/src/peer/types.ts

@@ -0,0 +1,6 @@
+export type PeerHandshake = {
+    protocol: string;
+    reserved: Uint8Array;
+    infoHash: Uint8Array;
+    peerId: Uint8Array;
+};

package/src/torrent/bencode/__tests__/decoder.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, test } from 'bun:test';
+
+import { decodeBencode } from '@torrent/bencode';
+import { BunTorrentError } from '@utils/errors';
+import { BencodeDecodeError, BencodeDecodeErrorCode } from '../decoder.error';
+
+const bytes = (value: string): Uint8Array => new TextEncoder().encode(value);
+
+const expectDecodeError = (value: string, code: BencodeDecodeErrorCode, offset?: number): void => {
+    try {
+        decodeBencode(bytes(value));
+        throw new Error('Expected decodeBencode to throw');
+    } catch (error) {
+        expect(error).toBeInstanceOf(BencodeDecodeError);
+        expect(error).toBeInstanceOf(BunTorrentError);
+        expect((error as BencodeDecodeError).code).toBe(code);
+
+        if (offset !== undefined) {
+            expect((error as BencodeDecodeError).offset).toBe(offset);
+        }
+    }
+};
+
+const expectDecodedBytes = (value: string, expected: string): void => {
+    const decoded = decodeBencode(bytes(value));
+
+    expect(decoded).toBeInstanceOf(Uint8Array);
+    expect([...Uint8Array.from(decoded as Uint8Array)]).toEqual([...bytes(expected)]);
+};
+
+const expectBytesValue = (value: unknown, expected: string): void => {
+    expect(value).toBeInstanceOf(Uint8Array);
+    expect([...Uint8Array.from(value as Uint8Array)]).toEqual([...bytes(expected)]);
+};
+
+describe('decodeBencode integer', () => {
+    test('decodes zero', () => {
+        expect(decodeBencode(bytes('i0e'))).toBe(0);
+    });
+
+    test('decodes positive integers', () => {
+        expect(decodeBencode(bytes('i1e'))).toBe(1);
+        expect(decodeBencode(bytes('i42e'))).toBe(42);
+        expect(decodeBencode(bytes('i123456789e'))).toBe(123456789);
+    });
+
+    test('decodes negative integers', () => {
+        expect(decodeBencode(bytes('i-1e'))).toBe(-1);
+        expect(decodeBencode(bytes('i-42e'))).toBe(-42);
+    });
+
+    test('rejects missing integer digits', () => {
+        expectDecodeError('ie', BencodeDecodeErrorCode.MISSING_INTEGER_DIGITS, 1);
+        expectDecodeError('i-e', BencodeDecodeErrorCode.MISSING_INTEGER_DIGITS, 2);
+    });
+
+    test('rejects negative zero', () => {
+        expectDecodeError('i-0e', BencodeDecodeErrorCode.NEGATIVE_ZERO, 4);
+    });
+
+    test('rejects leading zeroes', () => {
+        expectDecodeError('i03e', BencodeDecodeErrorCode.LEADING_ZERO, 1);
+        expectDecodeError('i042e', BencodeDecodeErrorCode.LEADING_ZERO, 1);
+    });
+
+    test('rejects unterminated integers', () => {
+        expectDecodeError('i42', BencodeDecodeErrorCode.UNTERMINATED_INTEGER, 3);
+        expectDecodeError('i-42', BencodeDecodeErrorCode.UNTERMINATED_INTEGER, 4);
+        expectDecodeError('i0', BencodeDecodeErrorCode.UNTERMINATED_INTEGER, 2);
+        expectDecodeError('i-0', BencodeDecodeErrorCode.UNTERMINATED_INTEGER, 3);
+    });
+
+    test('rejects integers outside the JavaScript safe integer range', () => {
+        expectDecodeError('i9007199254740992e', BencodeDecodeErrorCode.UNSAFE_INTEGER, 18);
+        expectDecodeError('i-9007199254740992e', BencodeDecodeErrorCode.UNSAFE_INTEGER, 19);
+    });
+
+    test('rejects trailing data after a root integer', () => {
+        expectDecodeError('i42ee', BencodeDecodeErrorCode.TRAILING_DATA, 4);
+        expectDecodeError('i42e0:', BencodeDecodeErrorCode.TRAILING_DATA, 4);
+    });
+
+    test('rejects unsupported root values with a bencode decode error', () => {
+        expectDecodeError('x', BencodeDecodeErrorCode.BAD_FORMAT, 0);
+    });
+});
+
+describe('decodeBencode bytes', () => {
+    test('decodes empty bytes', () => {
+        const decoded = decodeBencode(bytes('0:'));
+
+        expect(decoded).toBeInstanceOf(Uint8Array);
+        expect((decoded as Uint8Array).byteLength).toBe(0);
+    });
+
+    test('decodes byte strings', () => {
+        expectDecodedBytes('4:spam', 'spam');
+        expectDecodedBytes('11:hello world', 'hello world');
+    });
+
+    test('preserves raw binary bytes', () => {
+        const input = new Uint8Array([0x34, 0x3a, 0x00, 0xff, 0x69, 0x65]);
+        const decoded = decodeBencode(input);
+
+        expect(decoded).toBeInstanceOf(Uint8Array);
+        expect([...Uint8Array.from(decoded as Uint8Array)]).toEqual([0x00, 0xff, 0x69, 0x65]);
+    });
+
+    test('rejects leading zeroes in byte string length', () => {
+        expectDecodeError('04:spam', BencodeDecodeErrorCode.LEADING_ZERO, 0);
+        expectDecodeError('00:', BencodeDecodeErrorCode.LEADING_ZERO, 0);
+    });
+
+    test('rejects byte strings without a delimiter', () => {
+        expectDecodeError('4spam', BencodeDecodeErrorCode.EXPECTED_DELIM, 1);
+        expectDecodeError('4', BencodeDecodeErrorCode.EXPECTED_DELIM, 1);
+    });
+
+    test('rejects truncated byte strings', () => {
+        expectDecodeError('4:spa', BencodeDecodeErrorCode.BUFFER_OVERFLOW, 2);
+        expectDecodeError('1:', BencodeDecodeErrorCode.BUFFER_OVERFLOW, 2);
+    });
+
+    test('rejects trailing data after root bytes', () => {
+        expectDecodeError('4:spame', BencodeDecodeErrorCode.TRAILING_DATA, 6);
+    });
+});
+
+describe('decodeBencode list', () => {
+    test('decodes empty lists', () => {
+        expect(decodeBencode(bytes('le'))).toEqual([]);
+    });
+
+    test('decodes lists with mixed values', () => {
+        const decoded = decodeBencode(bytes('l4:spami42ee'));
+
+        expect(Array.isArray(decoded)).toBe(true);
+
+        const list = decoded as unknown[];
+        expectBytesValue(list[0], 'spam');
+        expect(list[1]).toBe(42);
+    });
+
+    test('decodes nested lists', () => {
+        const decoded = decodeBencode(bytes('lli1ei2ee3:fooe'));
+
+        expect(Array.isArray(decoded)).toBe(true);
+
+        const list = decoded as unknown[];
+        expect(list[0]).toEqual([1, 2]);
+        expectBytesValue(list[1], 'foo');
+    });
+
+    test('rejects unterminated lists', () => {
+        expectDecodeError('l4:spam', BencodeDecodeErrorCode.UNTERMINATED_LIST, 7);
+        expectDecodeError('li1e', BencodeDecodeErrorCode.UNTERMINATED_LIST, 4);
+    });
+
+    test('rejects trailing data after root lists', () => {
+        expectDecodeError('lee', BencodeDecodeErrorCode.TRAILING_DATA, 2);
+    });
+});
+
+describe('decodeBencode dictionary', () => {
+    test('decodes empty dictionaries', () => {
+        const decoded = decodeBencode(bytes('de'));
+
+        expect(decoded).toBeInstanceOf(Map);
+        expect((decoded as Map<string, unknown>).size).toBe(0);
+    });
+
+    test('decodes dictionaries with mixed values', () => {
+        const decoded = decodeBencode(bytes('d3:foo3:bar3:numi42ee'));
+
+        expect(decoded).toBeInstanceOf(Map);
+
+        const dict = decoded as Map<string, unknown>;
+        expectBytesValue(dict.get('foo'), 'bar');
+        expect(dict.get('num')).toBe(42);
+    });
+
+    test('decodes nested dictionaries and lists', () => {
+        const decoded = decodeBencode(bytes('d4:dictd3:key5:valuee4:listli1e3:twoee'));
+
+        expect(decoded).toBeInstanceOf(Map);
+
+        const dict = decoded as Map<string, unknown>;
+        const nested = dict.get('dict') as Map<string, unknown>;
+        const list = dict.get('list') as unknown[];
+
+        expect(nested).toBeInstanceOf(Map);
+        expectBytesValue(nested.get('key'), 'value');
+        expect(list[0]).toBe(1);
+        expectBytesValue(list[1], 'two');
+    });
+
+    test('rejects duplicate keys', () => {
+        expectDecodeError('d3:fooi1e3:fooi2ee', BencodeDecodeErrorCode.DUPLICATE_KEY, 14);
+    });
+
+    test('rejects non-byte dictionary keys', () => {
+        expectDecodeError('di1e3:bare', BencodeDecodeErrorCode.EXPECTED_DIGIT, 1);
+    });
+
+    test('rejects unterminated dictionaries', () => {
+        expectDecodeError('d3:foo3:bar', BencodeDecodeErrorCode.UNTERMINATED_DICT, 11);
+    });
+
+    test('rejects trailing data after root dictionaries', () => {
+        expectDecodeError('dee', BencodeDecodeErrorCode.TRAILING_DATA, 2);
+    });
+});

package/src/torrent/bencode/__tests__/encoder.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from 'bun:test';
+
+import { encodeBencode } from '@torrent/bencode';
+import { BunTorrentError } from '@utils/errors';
+import { BencodeEncodeError, BencodeEncodeErrorCode } from '../encoder.error';
+import type { BValue } from '../types';
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+const bytes = (value: string): Uint8Array => textEncoder.encode(value);
+const text = (value: Uint8Array): string => textDecoder.decode(value);
+
+const expectEncoded = (value: Parameters<typeof encodeBencode>[0], expected: string): void => {
+    expect(text(encodeBencode(value))).toBe(expected);
+};
+
+const expectEncodeError = (value: unknown, code: BencodeEncodeErrorCode): void => {
+    try {
+        encodeBencode(value as BValue);
+        throw new Error('Expected encodeBencode to throw');
+    } catch (error) {
+        expect(error).toBeInstanceOf(BencodeEncodeError);
+        expect(error).toBeInstanceOf(BunTorrentError);
+        expect((error as BencodeEncodeError).code).toBe(code);
+    }
+};
+
+describe('encodeBencode integer', () => {
+    test('encodes zero', () => {
+        expectEncoded(0, 'i0e');
+    });
+
+    test('encodes positive integers', () => {
+        expectEncoded(1, 'i1e');
+        expectEncoded(42, 'i42e');
+        expectEncoded(123456789, 'i123456789e');
+    });
+
+    test('encodes negative integers', () => {
+        expectEncoded(-1, 'i-1e');
+        expectEncoded(-42, 'i-42e');
+    });
+
+    test('rejects negative zero', () => {
+        expectEncodeError(-0, BencodeEncodeErrorCode.NEGATIVE_ZERO);
+    });
+
+    test('rejects unsafe integers', () => {
+        expectEncodeError(Number.MAX_SAFE_INTEGER + 1, BencodeEncodeErrorCode.UNSAFE_INTEGER);
+        expectEncodeError(Number.MIN_SAFE_INTEGER - 1, BencodeEncodeErrorCode.UNSAFE_INTEGER);
+    });
+
+    test('rejects invalid integer numbers', () => {
+        expectEncodeError(1.5, BencodeEncodeErrorCode.INVALID_INTEGER);
+        expectEncodeError(Number.NaN, BencodeEncodeErrorCode.INVALID_INTEGER);
+        expectEncodeError(Number.POSITIVE_INFINITY, BencodeEncodeErrorCode.INVALID_INTEGER);
+        expectEncodeError(Number.NEGATIVE_INFINITY, BencodeEncodeErrorCode.INVALID_INTEGER);
+    });
+});
+
+describe('encodeBencode bytes', () => {
+    test('encodes empty bytes', () => {
+        expectEncoded(new Uint8Array(), '0:');
+    });
+
+    test('encodes byte strings', () => {
+        expectEncoded(bytes('spam'), '4:spam');
+        expectEncoded(bytes('hello world'), '11:hello world');
+    });
+
+    test('preserves raw binary bytes', () => {
+        const encoded = encodeBencode(new Uint8Array([0x00, 0xff, 0x69, 0x65]));
+
+        expect([...encoded]).toEqual([0x34, 0x3a, 0x00, 0xff, 0x69, 0x65]);
+    });
+});
+
+describe('encodeBencode unsupported values', () => {
+    test('rejects unsupported runtime values', () => {
+        expectEncodeError('spam', BencodeEncodeErrorCode.UNSUPPORTED_VALUE);
+        expectEncodeError(null, BencodeEncodeErrorCode.UNSUPPORTED_VALUE);
+        expectEncodeError(undefined, BencodeEncodeErrorCode.UNSUPPORTED_VALUE);
+        expectEncodeError({ value: 1 }, BencodeEncodeErrorCode.UNSUPPORTED_VALUE);
+        expectEncodeError(true, BencodeEncodeErrorCode.UNSUPPORTED_VALUE);
+    });
+});
+
+describe('encodeBencode list', () => {
+    test('encodes empty lists', () => {
+        expectEncoded([], 'le');
+    });
+
+    test('encodes lists with mixed values', () => {
+        expectEncoded([bytes('spam'), 42], 'l4:spami42ee');
+    });
+
+    test('encodes nested lists', () => {
+        expectEncoded([[1, 2], bytes('foo')], 'lli1ei2ee3:fooe');
+    });
+});
+
+describe('encodeBencode dictionary', () => {
+    test('encodes empty dictionaries', () => {
+        expectEncoded(new Map(), 'de');
+    });
+
+    test('encodes dictionaries with mixed values', () => {
+        expectEncoded(
+            new Map<string, BValue>([
+                ['foo', bytes('bar')],
+                ['num', 42],
+            ]),
+            'd3:foo3:bar3:numi42ee',
+        );
+    });
+
+    test('sorts dictionary keys by byte order', () => {
+        expectEncoded(
+            new Map<string, BValue>([
+                ['spam', bytes('eggs')],
+                ['bar', bytes('baz')],
+                ['foo', 42],
+            ]),
+            'd3:bar3:baz3:fooi42e4:spam4:eggse',
+        );
+    });
+
+    test('encodes nested dictionaries and lists', () => {
+        expectEncoded(
+            new Map<string, BValue>([
+                ['dict', new Map<string, BValue>([['key', bytes('value')]])],
+                ['list', [1, bytes('two')]],
+            ]),
+            'd4:dictd3:key5:valuee4:listli1e3:twoee',
+        );
+    });
+});

package/src/torrent/bencode/__tests__/encoder.unit.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'bun:test';
+
+import { encodeBencode, toBValue } from '@torrent/bencode';
+
+const textDecoder = new TextDecoder();
+
+const text = (value: Uint8Array): string => textDecoder.decode(value);
+
+describe('encodeBencode happy path', () => {
+    test('encodes a torrent-shaped metadata dictionary from convenience input', () => {
+        const value = toBValue({
+            announce: 'https://tracker.test/announce',
+            info: {
+                length: 12345,
+                name: 'file.bin',
+                'piece length': 16384,
+            },
+        });
+
+        expect(text(encodeBencode(value))).toBe(
+            'd8:announce29:https://tracker.test/announce4:infod6:lengthi12345e4:name8:file.bin12:piece lengthi16384eee',
+        );
+    });
+});

package/src/torrent/bencode/__tests__/integration.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test';
+
+import { decodeBencode, encodeBencode, toBValue } from '@torrent/bencode';
+
+const textDecoder = new TextDecoder();
+
+const expectBytesText = (value: unknown, expected: string): void => {
+    expect(value).toBeInstanceOf(Uint8Array);
+    expect(textDecoder.decode(value as Uint8Array)).toBe(expected);
+};
+
+describe('bencode integration', () => {
+    test('round trips empty containers', () => {
+        const decoded = decodeBencode(encodeBencode(toBValue({ emptyDict: {}, emptyList: [] })));
+
+        expect(decoded).toBeInstanceOf(Map);
+
+        const root = decoded as Map<string, unknown>;
+        expect(root.get('emptyDict')).toBeInstanceOf(Map);
+        expect((root.get('emptyDict') as Map<string, unknown>).size).toBe(0);
+        expect(root.get('emptyList')).toEqual([]);
+    });
+
+    test('round trips a torrent-shaped value with every bencode type', () => {
+        const pieces = new Uint8Array(40);
+        for (let i = 0; i < pieces.byteLength; i++) {
+            pieces[i] = i;
+        }
+
+        const value = toBValue({
+            announce: 'https://tracker.test/announce',
+            'announce-list': [
+                ['https://tracker-a.test/announce'],
+                ['https://tracker-b.test/announce'],
+            ],
+            info: {
+                length: 12345,
+                name: 'file.bin',
+                'piece length': 16384,
+                pieces,
+            },
+        });
+
+        const decoded = decodeBencode(encodeBencode(value));
+
+        expect(decoded).toBeInstanceOf(Map);
+
+        const root = decoded as Map<string, unknown>;
+        expectBytesText(root.get('announce'), 'https://tracker.test/announce');
+
+        const announceList = root.get('announce-list') as unknown[];
+        expect(Array.isArray(announceList)).toBe(true);
+        expectBytesText((announceList[0] as unknown[])[0], 'https://tracker-a.test/announce');
+        expectBytesText((announceList[1] as unknown[])[0], 'https://tracker-b.test/announce');
+
+        const info = root.get('info') as Map<string, unknown>;
+        expect(info).toBeInstanceOf(Map);
+        expect(info.get('length')).toBe(12345);
+        expectBytesText(info.get('name'), 'file.bin');
+        expect(info.get('piece length')).toBe(16384);
+        expect(info.get('pieces')).toBeInstanceOf(Uint8Array);
+        expect([...Uint8Array.from(info.get('pieces') as Uint8Array)]).toEqual([...pieces]);
+    });
+});

package/src/torrent/bencode/decoder.error.ts

@@ -0,0 +1,36 @@
+import { BunTorrentError } from '@utils/errors';
+
+export enum BencodeDecodeErrorCode {
+    // Global
+    BAD_FORMAT = 'BENCODE_BAD_FORMAT',
+    BUFFER_OVERFLOW = 'BENCODE_BUFFER_OVERFLOW',
+    EXPECTED_DELIM = 'BENCODE_EXPECTED_DELIM',
+    TRAILING_DATA = 'BENCODE_TRAILING_DATA',
+    UNSAFE_INTEGER = 'BENCODE_UNSAFE_INTEGER',
+    // Integer
+    EXPECTED_INTEGER = 'BENCODE_EXPECTED_INTEGER',
+    MISSING_INTEGER_DIGITS = 'BENCODE_MISSING_INTEGER_DIGITS',
+    LEADING_ZERO = 'BENCODE_LEADING_ZERO',
+    NEGATIVE_ZERO = 'BENCODE_NEGATIVE_ZERO',
+    UNTERMINATED_INTEGER = 'BENCODE_UNTERMINATED_INTEGER',
+    // Bytes
+    EXPECTED_DIGIT = 'BENCODE_EXPECTED_DIGIT',
+    MAX_SIZE_EXCEEDED = 'BENCODE_MAX_SIZE_EXCEEDED',
+    // List
+    EXPECTED_LIST_FLAG = 'BENCODE_EXPECTED_LIST_FLAG',
+    UNTERMINATED_LIST = 'BENCODE_UNTERMINATED_LIST',
+    // Dict
+    EXPECTED_DICT_FLAG = 'BENCODE_EXPECTED_DICT_FLAG',
+    DUPLICATE_KEY = 'BENCODE_DUPLICATE_DICT_KEY',
+    UNTERMINATED_DICT = 'BENCODE_UNTERMINATED_DICT',
+}
+
+export class BencodeDecodeError extends BunTorrentError {
+    constructor(
+        code: BencodeDecodeErrorCode,
+        message: string,
+        public readonly offset: number,
+    ) {
+        super(message, code);
+    }
+}

package/src/torrent/bencode/decoder.ts

@@ -0,0 +1,180 @@
+import { BencodeDecodeError, BencodeDecodeErrorCode } from './decoder.error';
+import { FLAG, type BDict, type BInteger, type BValue } from './types';
+
+export const decodeBencode = (input: Uint8Array): BValue => {
+    const decoder = createDecoder({ input });
+    return decoder.decode();
+};
+
+const createDecoder = ({
+    input,
+    strict = true,
+    maxBytesLength = 1024 * 1024,
+}: {
+    input: Uint8Array;
+    strict?: boolean;
+    maxBytesLength?: number;
+}) => {
+    const textDecoder = new TextDecoder('utf-8', { fatal: strict });
+    const buffer = input;
+    let offset = 0;
+
+    const hasRemainingData = (): boolean => offset < buffer.length;
+    const hasNextChar = (): boolean => offset + 1 < buffer.length;
+
+    const char = (): number => {
+        if (!hasRemainingData()) fail(BencodeDecodeErrorCode.BUFFER_OVERFLOW, 'Buffer overflow');
+        return buffer[offset]!;
+    };
+
+    const nextChar = (): number => {
+        if (!hasNextChar()) fail(BencodeDecodeErrorCode.BUFFER_OVERFLOW, 'Buffer overflow');
+        return buffer[offset + 1]!;
+    };
+
+    const readNumber = (): number => {
+        if (char() === 0x30 && hasNextChar() && isDigit(nextChar()))
+            fail(BencodeDecodeErrorCode.LEADING_ZERO, 'Leading zeroes not allowed');
+
+        let integer = 0;
+        while (hasRemainingData() && isDigit(char())) {
+            const digit = char() - 0x30;
+            integer = integer * 10 + digit;
+            offset++;
+        }
+
+        return integer;
+    };
+
+    const checkNumber = (integer: number): void | never => {
+        if (Number.isSafeInteger(integer)) return;
+        return fail(BencodeDecodeErrorCode.UNSAFE_INTEGER, 'Decoded Integer is not safe');
+    };
+
+    const readInteger = (): BInteger => {
+        if (char() !== FLAG.INTEGER)
+            fail(BencodeDecodeErrorCode.EXPECTED_INTEGER, 'Not bencode Integer');
+        offset++;
+
+        const sign = char() === FLAG.MINUS ? -1 : 1;
+        if (sign === -1) offset++;
+
+        if (!isDigit(char()))
+            fail(BencodeDecodeErrorCode.MISSING_INTEGER_DIGITS, 'Missing Integer digits');
+
+        const integer = readNumber();
+
+        if (!hasRemainingData() || char() !== FLAG.END)
+            fail(
+                BencodeDecodeErrorCode.UNTERMINATED_INTEGER,
+                "Bencode Integer did not end with 'e'",
+            );
+        offset++;
+
+        if (sign === -1 && integer === 0)
+            fail(BencodeDecodeErrorCode.NEGATIVE_ZERO, 'Bencode Integer cannot be -0');
+
+        const result = integer * sign;
+        checkNumber(result);
+
+        return result;
+    };
+
+    const readBytes = (): Uint8Array => {
+        if (!isDigit(char()))
+            fail(BencodeDecodeErrorCode.EXPECTED_DIGIT, 'Not digit, failed to read length');
+
+        const length = readNumber();
+        checkNumber(length);
+
+        if (length > maxBytesLength)
+            fail(
+                BencodeDecodeErrorCode.MAX_SIZE_EXCEEDED,
+                `Bytes max size exceeded (${length}:${maxBytesLength})`,
+            );
+
+        if (!hasRemainingData() || char() !== FLAG.STR_DELIMITER)
+            fail(BencodeDecodeErrorCode.EXPECTED_DELIM, 'Bytes failed, expected delimiter');
+        offset++;
+
+        const start = offset,
+            end = offset + length;
+        if (end > buffer.length) fail(BencodeDecodeErrorCode.BUFFER_OVERFLOW, 'Buffer overflow');
+
+        offset = end;
+        return buffer.subarray(start, end);
+    };
+
+    const readList = (): Array<BValue> => {
+        if (char() !== FLAG.LIST)
+            fail(BencodeDecodeErrorCode.EXPECTED_LIST_FLAG, 'Not bencode list flag');
+        offset++;
+
+        const list: BValue[] = [];
+        while (hasRemainingData()) {
+            if (char() === FLAG.END) {
+                offset++;
+                return list;
+            }
+            list.push(readValue());
+        }
+
+        return fail(BencodeDecodeErrorCode.UNTERMINATED_LIST, "Bencode list did not end with 'e'");
+    };
+
+    const readDictionary = (): BDict => {
+        if (char() !== FLAG.DICTIONARY)
+            fail(BencodeDecodeErrorCode.EXPECTED_DICT_FLAG, 'Not bencode dictionary flag');
+        offset++;
+
+        const dict: BDict = new Map<string, BValue>();
+
+        while (hasRemainingData()) {
+            if (char() === FLAG.END) {
+                offset++;
+                return dict;
+            }
+            const key = textDecoder.decode(readBytes());
+            if (dict.has(key))
+                fail(BencodeDecodeErrorCode.DUPLICATE_KEY, 'Duplicate bencode dictionary key');
+
+            const value = readValue();
+            dict.set(key, value);
+        }
+
+        return fail(
+            BencodeDecodeErrorCode.UNTERMINATED_DICT,
+            "Bencode dictionary did not end with 'e'",
+        );
+    };
+
+    const readValue = (): BValue => {
+        const current = char();
+
+        if (current === FLAG.INTEGER) return readInteger();
+        if (isDigit(current)) return readBytes();
+        if (current === FLAG.LIST) return readList();
+        if (current === FLAG.DICTIONARY) return readDictionary();
+
+        return fail(BencodeDecodeErrorCode.BAD_FORMAT, 'Bad bencode format, failed to decode');
+    };
+
+    const decode = (): BValue => {
+        const value = readValue();
+
+        if (hasRemainingData())
+            return fail(BencodeDecodeErrorCode.TRAILING_DATA, 'There is excess trailing data');
+
+        return value;
+    };
+
+    const fail = (code: BencodeDecodeErrorCode, message: string): never => {
+        throw new BencodeDecodeError(code, message, offset);
+    };
+
+    return {
+        decode,
+    };
+};
+
+const isDigit = (char: number) => char >= 0x30 && char <= 0x39;

package/src/torrent/bencode/encoder.error.ts

@@ -0,0 +1,14 @@
+import { BunTorrentError } from '@utils/errors';
+
+export enum BencodeEncodeErrorCode {
+    INVALID_INTEGER = 'BENCODE_ENCODE_INVALID_INTEGER',
+    NEGATIVE_ZERO = 'BENCODE_ENCODE_NEGATIVE_ZERO',
+    UNSAFE_INTEGER = 'BENCODE_ENCODE_UNSAFE_INTEGER',
+    UNSUPPORTED_VALUE = 'BENCODE_ENCODE_UNSUPPORTED_VALUE',
+}
+
+export class BencodeEncodeError extends BunTorrentError {
+    constructor(code: BencodeEncodeErrorCode, message: string) {
+        super(message, code);
+    }
+}