trac-msb 0.2.17 → 0.2.19

package/tests/unit/state/utils/roles.test.js

@@ -1,44 +0,0 @@
-import test from 'brittle';
-import roles from '../../../../src/core/state/utils/roles.js';
-
-const { NodeRole, WHITELISTED_MASK, WRITER_MASK, INDEXER_MASK, calculateNodeRole, isNodeRoleValid } = roles;
-
-test('NodeRole enum values', t => {
-    t.is(NodeRole.READER, 0x0);
-    t.is(NodeRole.WHITELISTED, 0x1);
-    t.is(NodeRole.WRITER, 0x3);
-    t.is(NodeRole.INDEXER, 0x7);
-});
-
-test('Bitmask constants', t => {
-    t.is(WHITELISTED_MASK, 0x1);
-    t.is(WRITER_MASK, 0x2);
-    t.is(INDEXER_MASK, 0x4);
-});
-
-test('calculateNodeRole returns correct results', t => {
-    t.is(calculateNodeRole({}), NodeRole.READER);
-    t.is(calculateNodeRole({ isWhitelisted: true }), NodeRole.WHITELISTED);
-    t.is(calculateNodeRole({ isWhitelisted: true, isWriter: true }), NodeRole.WRITER);
-    t.is(calculateNodeRole({ isWhitelisted: true, isWriter: true, isIndexer: true }), NodeRole.INDEXER);
-});
-
-test('calculateNodeRole returns correct bitmask for partial roles', t => {
-    t.is(calculateNodeRole({ isWriter: true }), NodeRole.READER | WRITER_MASK);
-    t.is(calculateNodeRole({ isIndexer: true }), NodeRole.READER | INDEXER_MASK);
-});
-
-test('isNodeRoleValid returns true for valid roles', t => {
-    t.ok(isNodeRoleValid(NodeRole.READER));
-    t.ok(isNodeRoleValid(NodeRole.WHITELISTED));
-    t.ok(isNodeRoleValid(NodeRole.WRITER));
-    t.ok(isNodeRoleValid(NodeRole.INDEXER));
-});
-
-test('isNodeRoleValid returns false for invalid roles', t => {
-    t.not(isNodeRoleValid(0x2));
-    t.not(isNodeRoleValid(0x4));
-    t.not(isNodeRoleValid(0x5));
-    t.not(isNodeRoleValid(-1));
-    t.not(isNodeRoleValid(999));
-});

package/tests/unit/unit.test.js

@@ -1,14 +0,0 @@
-// This runner is auto-generated by Brittle
-
-import { default as test } from 'brittle';
-
-async function runTests() {
-	test.pause();
-	await import('./network/networkModule.test.js')
-	await import('./state/stateModule.test.js');
-	await import('./utils/utils.test.js');
-	await import('./messages/messages.test.js');
-	test.resume();
-}
-
-await runTests();

package/tests/unit/utils/amountSerialization/amountSerialization.test.js

@@ -1,237 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import { decimalStringToBigInt, bigIntTo16ByteBuffer, bufferToBigInt, bigIntToDecimalString, licenseBufferToBigInt } from '../../../../src/utils/amountSerialization.js';
-import { errorMessageIncludes } from "../../../helpers/regexHelper.js";
-import lengthEntryUtils from '../../../../src/core/state/utils/lengthEntry.js';
-
-test('decimalStringToBigInt', async t => {
-    // Zero cases - all valid
-    t.is(decimalStringToBigInt('0'), 0n, 'Simple zero');
-    t.is(decimalStringToBigInt('0.0'), 0n, 'Zero with decimal point');
-    t.is(decimalStringToBigInt('00.00'), 0n, 'Zero with leading and trailing zeros');
-
-    // Valid cases
-    t.is(decimalStringToBigInt('123'), 123000000000000000000n, 'Simple integer');
-    t.is(decimalStringToBigInt('123.456'), 123456000000000000000n, 'Decimal number');
-    t.is(decimalStringToBigInt('0.1'), 100000000000000000n, 'Decimal less than 1');
-    t.is(decimalStringToBigInt('0.000000000000000001'), 1n, 'Smallest possible decimal');
-    t.is(decimalStringToBigInt('1000000.000000000000000000'), 1000000000000000000000000n, 'Large number');
-    t.is(decimalStringToBigInt('340282366920938463463.374607431768211455'), (2n ** 128n - 1n), 'Maximum allowed value');
-
-    // Invalid cases
-    await Promise.all([
-        t.exception.all(() => decimalStringToBigInt(123),
-            errorMessageIncludes('Input must be a string')),
-        t.exception(() => decimalStringToBigInt('-1'),
-            errorMessageIncludes('Negative amounts are not allowed')),
-        t.exception(() => decimalStringToBigInt('-0.1'),
-            errorMessageIncludes('Negative amounts are not allowed')),
-        t.exception(() => decimalStringToBigInt('-123.456'),
-            errorMessageIncludes('Negative amounts are not allowed')),
-        t.exception(() => decimalStringToBigInt('-0'),
-            errorMessageIncludes('Negative amounts are not allowed')),
-        t.exception(() => decimalStringToBigInt('abc'),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt('123.456.789'),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt('123.1234567890123456789'),
-            errorMessageIncludes('Too many decimal places. Maximum allowed: 18')),
-        t.exception(() => decimalStringToBigInt(''),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt(' '),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt('12..34'),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt('.123'),
-            errorMessageIncludes('Invalid decimal format. Use format: 123.456')),
-        t.exception(() => decimalStringToBigInt('340282366920938463463.374607431768211456'),
-            errorMessageIncludes('Amount exceeds maximum allowed value (2^128 - 1)')),
-        t.exception(() => decimalStringToBigInt('999999999999999999999999999999999999999'),
-            errorMessageIncludes('Amount exceeds maximum allowed value (2^128 - 1)'))
-    ]);
-});
-
-test('bigIntTo16ByteBuffer', async t => {
-    // Basic conversion tests
-    const zeroResult = bigIntTo16ByteBuffer(0n);
-    t.is(zeroResult.toString('hex'), '00000000000000000000000000000000', 'Should convert 0 to a buffer of all zeros');
-
-    const oneResult = bigIntTo16ByteBuffer(1n);
-    t.is(oneResult.toString('hex'), '00000000000000000000000000000001', 'Should convert 1 to a buffer of zeros with 1 at the end');
-
-    const number256Result = bigIntTo16ByteBuffer(256n);
-    t.is(number256Result.toString('hex'), '00000000000000000000000000000100', 'Should convert 256 to zeros with "0100" at the end (256 in hex)');
-
-    const maxValueResult = bigIntTo16ByteBuffer(2n ** 128n - 1n);
-    t.is(maxValueResult.toString('hex'), 'ffffffffffffffffffffffffffffffff', 'Should convert max value to all f\'s');
-
-    const specificNumberResult = bigIntTo16ByteBuffer(123456789n);
-    t.is(specificNumberResult.toString('hex'), '000000000000000000000000075bcd15', 'Should convert 123456789 to its proper hex representation');
-
-    const overflowResult = bigIntTo16ByteBuffer(2n ** 128n + 5n);
-    t.is(overflowResult.toString('hex'), '00000000000000000000000000000005', 'Number larger than 2^128 should wrap around to modulo');
-
-    // Error cases tests
-    await Promise.all([
-        t.exception.all(() => bigIntTo16ByteBuffer(123),
-            errorMessageIncludes('Input must be a BigInt')),
-        t.exception.all(() => bigIntTo16ByteBuffer('123'),
-            errorMessageIncludes('Input must be a BigInt')),
-        t.exception.all(() => bigIntTo16ByteBuffer(null),
-            errorMessageIncludes('Input must be a BigInt')),
-        t.exception.all(() => bigIntTo16ByteBuffer(undefined),
-            errorMessageIncludes('Input must be a BigInt'))
-    ]);
-});
-
-test('bufferToBigInt', async t => {
-    // Basic conversion tests
-    const zeroBuffer = b4a.from('00000000000000000000000000000000', 'hex');
-    t.is(bufferToBigInt(zeroBuffer), 0n, 'Should convert buffer of zeros to 0');
-
-    const oneBuffer = b4a.from('00000000000000000000000000000001', 'hex');
-    t.is(bufferToBigInt(oneBuffer), 1n, 'Should convert buffer with 1 at the end to 1');
-
-    const number256Buffer = b4a.from('00000000000000000000000000000100', 'hex');
-    t.is(bufferToBigInt(number256Buffer), 256n, 'Should convert buffer representing 256 (hex: 0100)');
-
-    const maxValueBuffer = b4a.from('ffffffffffffffffffffffffffffffff', 'hex');
-    t.is(bufferToBigInt(maxValueBuffer), (2n ** 128n - 1n), 'Should convert buffer of all f\'s to max value');
-
-    const specificNumberBuffer = b4a.from('000000000000000000000000075bcd15', 'hex');
-    t.is(bufferToBigInt(specificNumberBuffer), 123456789n, 'Should convert buffer to specific number (123456789)');
-
-    // Roundtrip test - verify that conversion works both ways
-    const originalValue = 987654321n;
-    const buffer = bigIntTo16ByteBuffer(originalValue);
-    const roundtripped = bufferToBigInt(buffer);
-    t.is(roundtripped, originalValue, 'Should preserve value through buffer conversion roundtrip');
-
-    // Error cases tests
-    await Promise.all([
-        t.exception.all(() => bufferToBigInt(b4a.alloc(15)),
-            errorMessageIncludes('Input must be a 16-byte Buffer')),
-        t.exception.all(() => bufferToBigInt(b4a.alloc(17)),
-            errorMessageIncludes('Input must be a 16-byte Buffer')),
-        t.exception.all(() => bufferToBigInt(null),
-            errorMessageIncludes('Input must be a 16-byte Buffer')),
-        t.exception.all(() => bufferToBigInt(undefined),
-            errorMessageIncludes('Input must be a 16-byte Buffer')),
-        t.exception.all(() => bufferToBigInt('not a buffer'),
-            errorMessageIncludes('Input must be a 16-byte Buffer')),
-        t.exception.all(() => bufferToBigInt([1, 2, 3, 4]),
-            errorMessageIncludes('Input must be a 16-byte Buffer'))
-    ]);
-});
-
-test('licenseBufferToBigInt', async t => {
-    // Basic conversion tests
-    const zeroBuffer = b4a.from('00000000', 'hex'); 
-    t.is(licenseBufferToBigInt(zeroBuffer), 0n, 'Should convert buffer of zeros to 0');
-
-    const oneBuffer = b4a.from('00000001', 'hex'); 
-    t.is(licenseBufferToBigInt(oneBuffer), 1n, 'Should convert BE buffer with 1 at end to 1');
-
-    const number256Buffer = b4a.from('00000100', 'hex'); 
-    t.is(licenseBufferToBigInt(number256Buffer), 256n, 'Should convert BE buffer representing 256');
-
-    const maxValueBuffer = b4a.from('ffffffff', 'hex'); 
-    t.is(licenseBufferToBigInt(maxValueBuffer), (2n ** 32n - 1n), 'Should convert buffer of all f\'s to max 32-bit value');
-
-    const specificNumberBuffer = b4a.from('075bcd15', 'hex');
-    t.is(licenseBufferToBigInt(specificNumberBuffer), 123456789n, 'Should convert BE buffer to specific number (123456789)');
-
-    // Roundtrip test
-    const originalValue = 987654321n;
-    const buffer = lengthEntryUtils.encodeBE(Number(originalValue));
-    const roundtripped = licenseBufferToBigInt(buffer);
-    t.is(roundtripped, originalValue, 'Should preserve value through buffer conversion roundtrip');
-
-    // Error cases tests
-    await Promise.all([
-        t.exception.all(() => licenseBufferToBigInt(b4a.alloc(15)),
-            errorMessageIncludes('Input must be a 4-byte Buffer')),
-        t.exception.all(() => licenseBufferToBigInt(b4a.alloc(17)),
-            errorMessageIncludes('Input must be a 4-byte Buffer')),
-        t.exception.all(() => licenseBufferToBigInt(null),
-            errorMessageIncludes('Input must be a 4-byte Buffer')),
-        t.exception.all(() => licenseBufferToBigInt(undefined),
-            errorMessageIncludes('Input must be a 4-byte Buffer')),
-        t.exception.all(() => licenseBufferToBigInt('not a buffer'),
-            errorMessageIncludes('Input must be a 4-byte Buffer')),
-        t.exception.all(() => licenseBufferToBigInt([1, 2, 3, 4]),
-            errorMessageIncludes('Input must be a 4-byte Buffer'))
-    ]);
-})
-
-test('Integration: amount serialization roundtrip', async t => {
-    // Test regular integer value
-    const regularInt = '1';
-    const regularIntBigInt = decimalStringToBigInt(regularInt);
-    const regularIntBuffer = bigIntTo16ByteBuffer(regularIntBigInt);
-    const regularIntRoundtrip = bufferToBigInt(regularIntBuffer);
-    t.is(regularIntRoundtrip, regularIntBigInt, 'Should preserve regular integer through conversion');
-
-    // Test decimal value
-    const decimalValue = '123.456';
-    const decimalBigInt = decimalStringToBigInt(decimalValue);
-    const decimalBuffer = bigIntTo16ByteBuffer(decimalBigInt);
-    const decimalRoundtrip = bufferToBigInt(decimalBuffer);
-    t.is(decimalRoundtrip, decimalBigInt, 'Should preserve decimal value through conversion');
-
-    // Test small decimal value
-    const smallDecimal = '0.1';
-    const smallDecimalBigInt = decimalStringToBigInt(smallDecimal);
-    const smallDecimalBuffer = bigIntTo16ByteBuffer(smallDecimalBigInt);
-    const smallDecimalRoundtrip = bufferToBigInt(smallDecimalBuffer);
-    t.is(smallDecimalRoundtrip, smallDecimalBigInt, 'Should preserve small decimal through conversion');
-
-    // Test large value with many decimal places
-    const largeValue = '9999999.999999999999999999';
-    const largeValueBigInt = decimalStringToBigInt(largeValue);
-    const largeValueBuffer = bigIntTo16ByteBuffer(largeValueBigInt);
-    const largeValueRoundtrip = bufferToBigInt(largeValueBuffer);
-    t.is(largeValueRoundtrip, largeValueBigInt, 'Should preserve large value with many decimals through conversion');
-
-    // Test smallest possible decimal
-    const smallestValue = '0.000000000000000001';
-    const smallestValueBigInt = decimalStringToBigInt(smallestValue);
-    const smallestValueBuffer = bigIntTo16ByteBuffer(smallestValueBigInt);
-    const smallestValueRoundtrip = bufferToBigInt(smallestValueBuffer);
-    t.is(smallestValueRoundtrip, smallestValueBigInt, 'Should preserve smallest possible decimal through conversion');
-
-    // Test maximum allowed value
-    const maxValue = '340282366920938463463.374607431768211455';
-    const maxValueBigInt = decimalStringToBigInt(maxValue);
-    const maxValueBuffer = bigIntTo16ByteBuffer(maxValueBigInt);
-    const maxValueRoundtrip = bufferToBigInt(maxValueBuffer);
-    t.is(maxValueRoundtrip, maxValueBigInt, 'Should preserve maximum allowed value through conversion');
-
-    // Verify that zero is handled correctly
-    const zeroBigInt = decimalStringToBigInt('0');
-    const zeroBuffer = bigIntTo16ByteBuffer(zeroBigInt);
-    const zeroRoundtrip = bufferToBigInt(zeroBuffer);
-    t.is(zeroRoundtrip, 0n, 'Should preserve zero through conversion');
-});
-
-test('bigIntToDecimalString', async t => {
-    t.is(bigIntToDecimalString(1234567890000000000000000000n), '1234567890');
-    t.is(bigIntToDecimalString(123456789012345678901234567890n), '123456789012.34567890123456789');
-    t.is(bigIntToDecimalString(1n), '0.000000000000000001');
-    t.is(bigIntToDecimalString(0n), '0');
-    t.is(bigIntToDecimalString(1000000000000000000n), '1');
-    t.is(bigIntToDecimalString(1000000000000000001n), '1.000000000000000001');
-
-    await Promise.all([
-        t.exception.all(() => bigIntToDecimalString(-1n),
-            errorMessageIncludes('Negative amounts are not allowed')),
-        t.exception.all(() => bigIntToDecimalString(2n ** 128n),
-            errorMessageIncludes('Amount exceeds maximum allowed value')),
-        t.exception.all(() => bigIntToDecimalString(1n, -1),
-            errorMessageIncludes('Decimals must be a non-negative integer')),
-        t.exception.all(() => bigIntToDecimalString(1n, 18.5),
-            errorMessageIncludes('Decimals must be a non-negative integer')),
-        t.exception.all(() => bigIntToDecimalString('123n'),
-            errorMessageIncludes('Input must be a BigInt'))
-    ]);
-});

package/tests/unit/utils/buffer/buffer.test.js

@@ -1,251 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import { createMessage, isBufferValid, safeWriteUInt32BE, deepCopyBuffer, encodeCapabilities, timestampToBuffer, idToBuffer } from '../../../../src/utils/buffer.js';
-import { errorMessageIncludes } from "../../../helpers/regexHelper.js";
-
-const invalidDataTypes = [
-    null,
-    undefined,
-    true,
-    false,
-    0,
-    NaN,
-    Infinity,
-    -1,
-    '',
-    'string',
-    Symbol('sym'),
-    BigInt(10),
-    [],
-    {},
-    () => { },
-    new Date(),
-    { foo: 'bar' },
-    { type: '1', key: b4a.from('01', 'hex') },
-    { type: 1, key: null },
-    { type: 1 },
-    { key: b4a.from('01', 'hex') },
-    { type: 5, key: [] },
-    { type: 1, key: b4a.from('01', 'hex'), bko: null },
-    { type: 1, key: b4a.from('01', 'hex'), bko: 123 },
-    { type: 1, key: b4a.from('01', 'hex'), bko: b4a.from('01', 'hex'), data: 'string' },
-    { type: 1, key: b4a.from('01', 'hex'), bko: b4a.from('01', 'hex'), data: null },
-    { type: 1, key: b4a.from('01', 'hex'), memo: 123 },
-    { type: 1, key: 'string' },
-    { type: 1, key: {}, bko: {} },
-    { type: 'foo', key: [], bko: 'bar' },
-    (() => { const a = {}; a.self = a; return a; })(),
-    Object.create(null),
-    new Map(),
-    new Set(),
-    new Float64Array([1.1, 2.2]),
-    new Int16Array([1, 2, 3]),
-    { type: 9999, key: b4a.from('01', 'hex') },
-    { type: 1, key: 'not-a-buffer' },
-    Number.MAX_SAFE_INTEGER + 1,
-    -Number.MAX_SAFE_INTEGER - 1,
-    { type: 1, key: b4a.from('01', 'hex'), callback: () => { } },
-];
-
-test('createMessage', async (t) => {
-    const expected = b4a.alloc(32);
-    for (let i = 0; i < 32; i++) expected[i] = i;
-
-    const buf1 = expected.subarray(0, 8);
-    const buf2 = expected.subarray(8, 16);
-    const buf3 = expected.subarray(16, 24);
-    const buf4 = expected.subarray(24, 32);
-
-    t.test('createMessage returns concatenated buffer for multiple buffers', async k => {
-        const result = createMessage(buf1, buf2, buf3, buf4);
-        k.is(result.length, expected.length, 'length matches');
-        k.ok(b4a.equals(result, expected), 'contents match');
-    });
-
-    t.test('createMessage encodes multiple numbers as BE UInt32 buffers', async k => {
-        const nums = Array.from({ length: 8 }, (_, i) => i + 1);
-        const part1 = nums.slice(0, 2);  // [1,2] - 8 bytes
-        const part2 = nums.slice(2, 4);  // [3,4]
-        const expectedNums = b4a.alloc(16);
-        part1.forEach((n, i) => expectedNums.writeUInt32BE(n, i * 4));
-        part2.forEach((n, i) => expectedNums.writeUInt32BE(n, 8 + i * 4));
-        const result = createMessage(...part1, ...part2);
-        k.is(result.length, 16, '16 bytes for 4 numbers');
-        k.ok(b4a.equals(result.subarray(0, 16), expectedNums), 'BE encoding correct');
-    });
-
-    t.test('createMessage handles mixed buffer and number arguments', async k => {
-        const num = 0x01020304;
-        const result = createMessage(buf1, num, buf2);
-        k.is(result.length, 8 + 4 + 8, 'combined length');
-        k.ok(b4a.equals(result.subarray(0, 8), buf1), 'first segment');
-        k.is(result.readUInt32BE(8), num, 'middle segment number');
-        k.ok(b4a.equals(result.subarray(12, 20), buf2), 'last segment');
-    });
-
-    t.test('createMessage returns empty buffer for no arguments', async k => {
-        const result = createMessage();
-        k.is(result.length, 0, 'zero length');
-        k.ok(b4a.isBuffer(result), 'still a buffer');
-    });
-
-    test('createMessage returns empty buffer for invalid input types', async t => {
-
-        for (const invalidDataType of invalidDataTypes) {
-            const res = createMessage(invalidDataType);
-            t.is(res.length, 0, `empty for ${Object.prototype.toString.call(invalidDataType)}`);
-        }
-    });
-
-    test('createMessage returns buffer unchanged if single buffer is passed', async t => {
-        const buf = b4a.from([1, 2, 3]);
-        const res = createMessage(buf);
-        t.is(res.length, buf.length);
-        t.ok(b4a.equals(res, buf));
-    });
-
-    test('createMessage encodes valid numbers as 4-byte BE buffers', async t => {
-        const valid = [1, 256, 0xFFFFFFFF];
-        for (const n of valid) {
-            const res = createMessage(n);
-            t.is(res.length, 4, `4 bytes for ${n}`);
-            t.is(res.readUInt32BE(0), n);
-        }
-    });
-
-    // TODO: This tests is working on node but not on bare. Investigate and reactivate
-    // t.test('createMessage - function throws an error when invalid arguments are passed', async (k) => {
-    //     try {
-    //         const res = createMessage(1, 2, 3, 4);
-    //         k.fail('Should throw an error for invalid arguments. Returned: ' + res);
-    //     } catch (e) {
-    //         k.pass('Correctly threw an error for invalid arguments');
-    //     }
-    // });
-});
-
-test('isBufferValid - positive cases', t => {
-    const buf = b4a.alloc(8);
-    t.ok(isBufferValid(buf, 8), 'valid buffer and size');
-});
-
-test('isBufferValid - negative case', t => {
-    const buf = b4a.alloc(8);
-    t.not(isBufferValid(buf, 4), 'invalid size');
-    t.not(isBufferValid(b4a.alloc(0), 1), 'empty buffer, size 1');
-    t.not(isBufferValid(b4a.from('abcd', 'utf8'), 10), 'buffer too short');
-    t.not(isBufferValid(b4a.from('abcd', 'utf8'), 2), 'buffer too long');
-});
-
-test('safeWriteUInt32BE - positive case', t => {
-    const buf = safeWriteUInt32BE(0x01020304, 0);
-    t.ok(b4a.isBuffer(buf), 'returns a buffer');
-    t.is(buf.length, 4, 'buffer is 4 bytes');
-    t.is(buf.readUInt32BE(0), 0x01020304, 'encodes value correctly');
-
-    const edge = safeWriteUInt32BE(0x01020304, 4);
-    t.ok(b4a.isBuffer(edge), 'returns a buffer for offset at buffer end');
-    t.is(edge.length, 4, 'buffer is 4 bytes');
-    t.is(edge.readUInt32BE(0), 0, 'buffer is zeroed for out of bounds offset');
-});
-
-test('safeWriteUInt32BE - negative case', t => {
-    const negOffset = safeWriteUInt32BE(0x01020304, -1);
-    t.ok(b4a.isBuffer(negOffset), 'returns buffer for negative offset');
-    t.is(negOffset.length, 4, 'buffer is 4 bytes');
-    t.is(negOffset.readUInt32BE(0), 0, 'buffer is zeroed for negative offset');
-});
-
-test('deepCopyBuffer - returns null for falsy inputs', t => {
-    t.is(deepCopyBuffer(null), null, 'null input returns null');
-    t.is(deepCopyBuffer(undefined), null, 'undefined input returns null');
-});
-
-test('deepCopyBuffer - copies non-empty buffer', t => {
-    const buf = b4a.from([1, 2, 3, 4]);
-    const copy = deepCopyBuffer(buf);
-
-    t.ok(b4a.isBuffer(copy), 'returns a buffer');
-    t.is(copy.length, buf.length, 'same length');
-    t.ok(b4a.equals(copy, buf), 'contents match');
-    t.not(copy, buf, 'is a different buffer object');
-});
-
-test('deepCopyBuffer - copies empty buffer', t => {
-    const buf = b4a.alloc(0);
-    const copy = deepCopyBuffer(buf);
-
-    t.ok(b4a.isBuffer(copy), 'returns a buffer');
-    t.is(copy.length, 0, 'length is zero');
-    t.not(copy, buf, 'is a different buffer object');
-});
-
-test('deepCopyBuffer - modifying copy does not affect original (is not a reference)', t => {
-    const buf = b4a.from([9, 9, 9]);
-    const copy = deepCopyBuffer(buf);
-
-    copy[0] = 1;
-
-    t.is(buf[0], 9, 'original unchanged');
-    t.is(copy[0], 1, 'copy modified independently');
-});
-
-test('encodeCapabilities - deterministic ordering and encoding', t => {
-    const caps = ['cap-b', 'cap-a'];
-    const result = encodeCapabilities(caps);
-
-    const capA = b4a.from('cap-a', 'utf8');
-    const capB = b4a.from('cap-b', 'utf8');
-
-    const expected = b4a.concat([
-        b4a.from([0x00, capA.length]),
-        capA,
-        b4a.from([0x00, capB.length]),
-        capB
-    ]);
-
-    t.is(result.length, expected.length, 'length matches');
-    t.ok(b4a.equals(result, expected), 'ordering is sorted and encoding matches');
-});
-
-test('encodeCapabilities - empty array yields empty buffer', t => {
-    const result = encodeCapabilities([]);
-    t.ok(b4a.isBuffer(result), 'returns a buffer');
-    t.is(result.length, 0, 'empty buffer for no caps');
-});
-
-test('encodeCapabilities - throws on invalid input', t => {
-    t.exception(
-        () => encodeCapabilities('not-array'),
-        errorMessageIncludes('Capabilities must be an array')
-    );
-
-    t.exception(
-        () => encodeCapabilities([1, 2]),
-        errorMessageIncludes('must contain only strings')
-    );
-});
-
-test('timestampToBuffer - encodes uint64 BE', t => {
-    const ts = 2n ** 53n; // beyond uint32
-
-    const tsBuf = timestampToBuffer(ts);
-
-    t.is(tsBuf.length, 8);
-    t.is(tsBuf.readBigUInt64BE(0), ts);
-});
-
-test('idToBuffer - encodes utf8 string', t => {
-    const id = 'test-id';
-    const idBuf = idToBuffer(id);
-    t.ok(b4a.isBuffer(idBuf));
-    t.ok(b4a.equals(idBuf, b4a.from(id, 'utf8')));
-});
-
-test('timestampToBuffer and idToBuffer - reject invalid input', t => {
-    t.exception(() => timestampToBuffer(-1), errorMessageIncludes('timestamp'));
-    t.exception(() => timestampToBuffer(1.5), errorMessageIncludes('timestamp'));
-    t.exception(() => timestampToBuffer('1'), errorMessageIncludes('timestamp'));
-    t.exception.all(() => idToBuffer(1));
-    t.exception.all(() => idToBuffer(null));
-});