@gsknnft/bigint-buffer 1.3.2 → 1.4.1

package/src/index.bench.ts

@@ -1,207 +0,0 @@
-
-import * as benchmark from 'benchmark';
-
-import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
-
-const BN = require('bn.js');
-
-
-// This file contains the benchmark test suite. It includes the benchmark and
-// some lightweight boilerplate code for running benchmark.js. To
-// run the benchmarks, execute `npm run benchmark` from the package directory.
-const suite = new benchmark.Suite();
-
-interface BenchmarkRun {
-  name: string;
-  hz: number;
-  stats: benchmark.Stats;
-}
-
-// Tests the performance of a no-op.
-suite.add('no-op', () => {});
-
-// Test small strings (unaligned)
-const smallHex = 'deadbeef';
-const smallString = `0x${smallHex}`;
-const smallBuf: Buffer = Buffer.from(smallHex, 'hex');
-suite.add('bigint from hex string (small)', () => {
-  return BigInt(smallString);
-});
-suite.add('bigint from hex string from buffer (small)', () => {
-  return BigInt(`0x${smallBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (small)', () => {
-  return new BN(smallBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntLE(smallBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (small)', () => {
-  return toBigIntBE(smallBuf);
-});
-
-// Test mid strings (aligned)
-const midHex = 'badc0ffee0ddf00d';
-const midString = `0x${midHex}`;
-const midBuf: Buffer = Buffer.from(midHex, 'hex');
-suite.add('bigint from hex string (mid, aligned)', () => {
-  return BigInt(midString);
-});
-suite.add('bigint from hex string from buffer (mid, aligned)', () => {
-  return BigInt(`0x${midBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (mid, aligned)', () => {
-  return new BN(midBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntLE(midBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (mid, aligned)', () => {
-  return toBigIntBE(midBuf);
-});
-
-// Test huge strings
-const hugeHex =
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d';
-const hugeString = `0x${hugeHex}`;
-const hugeBuf: Buffer = Buffer.from(hugeHex, 'hex');
-suite.add('bigint from hex string (huge)', () => {
-  return BigInt(hugeString);
-});
-suite.add('bigint from hex string from buffer (huge)', () => {
-  return BigInt(`0x${hugeBuf.toString('hex')}`);
-});
-suite.add('BN from hex string from buffer (huge)', () => {
-  return new BN(hugeBuf.toString('hex'), 16);
-});
-suite.add('LE bigint-buffer ToBigInt (huge)', () => {
-  return toBigIntLE(hugeBuf);
-});
-suite.add('BE bigint-buffer ToBigInt (huge)', () => {
-  return toBigIntBE(hugeBuf);
-});
-
-const bigIntToBufferWithStringBE = (int: bigint, width: number): Buffer => {
-  const hex = int.toString(16);
-  return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-};
-
-const bigIntToBufferWithStringLE = (int: bigint, width: number): Buffer => {
-  const hex = int.toString(16);
-  const buffer =
-      Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-  buffer.reverse();
-  return buffer;
-};
-
-// Test small toBuffer
-const smallValue = 12345678n;
-suite.add('LE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringLE(smallValue, 8);
-});
-
-suite.add('BE bigint to hex string to buffer (small)', () => {
-  return bigIntToBufferWithStringBE(smallValue, 8);
-});
-
-const bnSmallValue = new BN('12345678', 10);
-suite.add('BN to buffer (small)', () => {
-  return bnSmallValue.toBuffer(8);
-});
-
-suite.add('LE bigint-buffer to buffer (small)', () => {
-  return toBufferLE(smallValue, 8);
-});
-
-suite.add('BE bigint-buffer to buffer (small)', () => {
-  return toBufferBE(smallValue, 8);
-});
-
-
-// Test large toBuffer
-const largeValue =
-    0xbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dn;
-suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 24);
-});
-
-suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 24);
-});
-
-const bnLargeValue = new BN(
-    'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d',
-    16);
-suite.add('BN to buffer (large)', () => {
-  return bnLargeValue.toBuffer(24);
-});
-
-suite.add('LE bigint-buffer to buffer (large)', () => {
-  return toBufferLE(largeValue, 24);
-});
-
-suite.add('BE bigint-buffer to buffer (large)', () => {
-  return toBufferBE(largeValue, 24);
-});
-
-suite.add('LE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringLE(largeValue, 8);
-});
-
-suite.add('BE bigint to hex string to buffer (large)', () => {
-  return bigIntToBufferWithStringBE(largeValue, 8);
-});
-
-suite.add('LE bigint-buffer to buffer (large, truncated)', () => {
-  return toBufferLE(largeValue, 8);
-});
-
-suite.add('BE bigint-buffer to buffer (large, truncated)', () => {
-  return toBufferBE(largeValue, 8);
-});
-
-const b1 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const b2 = Buffer.from('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const bn1 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const bn2 = new BN('0123456789ABCDEF0123456789ABCDEF', 'hex');
-const n1 = 0x0123456789ABCDEF0123456789ABCDEFn;
-const n2 = 0x0123456789ABCDEF0123456789ABCDEFn;
-suite.add('Buffer equality comparison', () => {
-  return b1.compare(b2) === 0;
-});
-
-suite.add('BN equality comparison', () => {
-  return bn1.eq(bn2);
-});
-
-suite.add('bigint equality comparison', () => {
-  return n1 === n2;
-});
-
-suite.add('BN multiply', () => {
-  return bn1.mul(bn2);
-});
-
-suite.add('bigint multiply', () => {
-  return n1 * n2;
-});
-
-//#endregion
-
-
-// Reporter for each benchmark
-suite.on('cycle', (event: benchmark.Event) => {
-  const benchmarkRun: BenchmarkRun = event.target as BenchmarkRun;
-  const stats = benchmarkRun.stats as benchmark.Stats;
-  const meanInNanos = (stats.mean * 1000000000).toFixed(2);
-  const stdDevInNanos = (stats.deviation * 1000000000).toFixed(3);
-  const runs = stats.sample.length;
-  const ops = benchmarkRun.hz.toFixed(benchmarkRun.hz < 100 ? 2 : 0);
-  const err = stats.rme.toFixed(2);
-
-  console.log(`${benchmarkRun.name}: ${ops}±${err}% ops/s ${meanInNanos}±${
-      stdDevInNanos} ns/op (${runs} run${runs === 0 ? '' : 's'})`);
-});
-
-// Runs the test suite
-suite.run();

package/src/index.spec.ts

@@ -1,444 +0,0 @@
-import 'mocha';
-declare var process: {browser: boolean;};
-
-import * as chai from 'chai';
-import * as path from 'path';
-
-const lib = process.browser ?
-    require('../../dist/index.js') :
-    require(path.join(__dirname, '../../dist/index.cjs'));
-const toBigIntBE = lib.toBigIntBE;
-const toBigIntLE = lib.toBigIntLE;
-const toBufferBE = lib.toBufferBE;
-const toBufferLE = lib.toBufferLE;
-
-// Needed for should.not.be.undefined.
-/* tslint:disable:no-unused-expression */
-
-chai.should();
-
-const assertEquals = (n0: bigint, n1: bigint) => {
-  chai.expect(n0.toString(16)).to.equal(n1.toString(16));
-};
-
-describe('Try buffer conversion (little endian)', () => {
-  it('0 should equal 0n', () => {
-    assertEquals(toBigIntLE(Buffer.from([0])), BigInt('0'));
-  });
-
-  it('1 should equal 1n', async () => {
-    assertEquals(toBigIntLE(Buffer.from([1])), BigInt('1'));
-  });
-
-  it('0xdead should equal 0xdeadn', async () => {
-    assertEquals(toBigIntLE(Buffer.from([0xad, 0xde])), BigInt(`0xdead`));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeefn', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xef, 0xbe, 0xad, 0xde])),
-        BigInt(`0xdeadbeef`));
-  });
-
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0`));
-  });
-
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0dd`));
-  });
-
-  it('0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n', async () => {
-    assertEquals(
-        toBigIntLE(Buffer.from([0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0ddf0`));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn', async () => {
-    assertEquals(
-        toBigIntLE(
-            Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0ddf00d`));
-  });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(Buffer.from([
-             0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
-             0xba
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeef`));
-     });
-  it('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(Buffer.from([
-             0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0,
-             0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
-             0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`));
-     });
-  it('0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeefn',
-     async () => {
-       assertEquals(
-           toBigIntLE(Buffer.from([
-             0xef, 0xbe, 0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd,
-             0xe0, 0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
-             0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbeef`));
-     });
-});
-
-describe('Try buffer conversion (big endian)', () => {
-  it('0 should equal 0n', () => {
-    assertEquals(toBigIntBE(Buffer.from([0])), BigInt(`0`));
-  });
-
-  it('1 should equal 1n', async () => {
-    assertEquals(toBigIntBE(Buffer.from([1])), BigInt(`1`));
-  });
-
-  it('0xdead should equal 0xdeadn', async () => {
-    assertEquals(toBigIntBE(Buffer.from([0xde, 0xad])), BigInt(`0xdead`));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeefn', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xde, 0xad, 0xbe, 0xef])),
-        BigInt(`0xdeadbeef`));
-  });
-
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0])),
-        BigInt(`0xbadc0ffee0`));
-  });
-
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd])),
-        BigInt(`0xbadc0ffee0dd`));
-  });
-
-  it('0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0])),
-        BigInt(`0xbadc0ffee0ddf0`));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn', async () => {
-    assertEquals(
-        toBigIntBE(
-            Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])),
-        BigInt(`0xbadc0ffee0ddf00d`));
-  });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       assertEquals(
-           toBigIntBE(Buffer.from([
-             0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe,
-             0xef
-           ])),
-           BigInt(`0xbadc0ffee0ddf00ddeadbeef`));
-     });
-
-  it('long value should equal long val', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from(
-            'badc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef',
-            'hex')),
-        BigInt(
-            `0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`));
-  });
-
-  it('other long value should equal long val', async () => {
-    assertEquals(
-        toBigIntBE(Buffer.from(
-            'd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544',
-            'hex')),
-        BigInt(
-            `0xd7f8974fb5ac78d9ac099b9ad5018bedc2ce0a72dad1827a1709da30580f0544`));
-  });
-});
-
-describe('Try bigint conversion (little endian)', () => {
-  it('0 should equal 0n', () => {
-    toBufferLE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 0
-    ]));
-  });
-
-  it('1 should equal 1n', async () => {
-    toBufferLE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
-      1, 0, 0, 0, 0, 0, 0, 0
-    ]));
-  });
-
-
-  it('1 should equal 1n (32 byte)', async () => {
-    toBufferLE(BigInt(`1`), 32)
-        .should.deep.equal(Buffer.from(
-            '0100000000000000000000000000000000000000000000000000000000000000',
-            'hex'));
-  });
-
-  it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    toBufferLE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
-      0xad, 0xde, 0, 0, 0, 0
-    ]));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    toBufferLE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
-      0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0
-    ]));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)',
-     async () => {
-       toBufferLE(BigInt(`0xbadc0ffee0ddf00d`), 8)
-           .should.deep.equal(
-               Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba]));
-     });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       toBufferLE(BigInt(`0xbadc0ffee0ddf00ddeadbeef`), 12)
-           .should.deep.equal(Buffer.from([
-             0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
-             0xba
-           ]));
-     });
-
-  it('long value should equal long val', async () => {
-    toBufferLE(BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`), 24)
-        .should.deep.equal(Buffer.from([
-          0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0,
-          0xfe, 0x0f, 0xdc, 0xba, 0xef, 0xbe, 0xad, 0xde,
-          0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba
-        ]));
-  });
-});
-
-
-describe('Try bigint conversion (big endian)', () => {
-  it('0 should equal 0n', () => {
-    toBufferBE(BigInt(`0`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 0
-    ]));
-  });
-
-  it('1 should equal 1n', async () => {
-    toBufferBE(BigInt(`1`), 8).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0, 0, 1
-    ]));
-  });
-
-  it('1 should equal 1n (32 byte)', async () => {
-    toBufferBE(BigInt(`1`), 32)
-        .should.deep.equal(Buffer.from(
-            '0000000000000000000000000000000000000000000000000000000000000001',
-            'hex'));
-  });
-
-  it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    toBufferBE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0xde, 0xad
-    ]));
-  });
-
-  it('0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)', async () => {
-    toBufferBE(BigInt(`0xdeadbeef`), 9).should.deep.equal(Buffer.from([
-      0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef
-    ]));
-  });
-
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)',
-     async () => {
-       toBufferBE(BigInt(`0xbadc0ffee0ddf00d`), 8)
-           .should.deep.equal(
-               Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d]));
-     });
-
-  it('0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn',
-     async () => {
-       toBufferBE(BigInt(`0xbadc0ffee0ddf00ddeadbeef`), 12)
-           .should.deep.equal(Buffer.from([
-             0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe,
-             0xef
-           ]));
-     });
-
-  it('long value should equal long val', async () => {
-    toBufferBE(BigInt(`0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef`), 24)
-        .should.deep.equal(Buffer.from([
-          0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d,
-          0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe,
-          0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef
-        ]));
-  });
-});
-
-describe('Conversion Utilities - bigintToBuf and bufToBigint', () => {
-  const bigintToBuf = lib.bigintToBuf;
-  const bufToBigint = lib.bufToBigint;
-
-  it('should convert 0 to buffer', () => {
-    const buf = bigintToBuf(BigInt(0));
-    buf.should.deep.equal(Buffer.from([0]));
-  });
-
-  it('should convert small number to buffer', () => {
-    const buf = bigintToBuf(BigInt(123456789));
-    assertEquals(bufToBigint(buf), BigInt(123456789));
-  });
-
-  it('should round-trip convert medium numbers', () => {
-    const original = BigInt('0xdeadbeef');
-    const buf = bigintToBuf(original);
-    const result = bufToBigint(buf);
-    assertEquals(result, original);
-  });
-
-  it('should round-trip convert large numbers', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const buf = bigintToBuf(original);
-    const result = bufToBigint(buf);
-    assertEquals(result, original);
-  });
-
-  it('should throw error for negative bigint', () => {
-    chai.expect(() => bigintToBuf(BigInt(-1))).to.throw('negative bigint');
-  });
-});
-
-describe('Conversion Utilities - bigintToHex and hexToBigint', () => {
-  const bigintToHex = lib.bigintToHex;
-  const hexToBigint = lib.hexToBigint;
-
-  it('should convert 0 to hex', () => {
-    bigintToHex(BigInt(0)).should.equal('00');
-  });
-
-  it('should convert small number to hex', () => {
-    bigintToHex(BigInt(255)).should.equal('ff');
-  });
-
-  it('should convert number to even-length hex', () => {
-    bigintToHex(BigInt(15)).should.equal('0f');
-  });
-
-  it('should convert hex string to bigint', () => {
-    assertEquals(hexToBigint('deadbeef'), BigInt('0xdeadbeef'));
-  });
-
-  it('should handle hex string with 0x prefix', () => {
-    assertEquals(hexToBigint('0xdeadbeef'), BigInt('0xdeadbeef'));
-  });
-
-  it('should round-trip convert', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const hex = bigintToHex(original);
-    const result = hexToBigint(hex);
-    assertEquals(result, original);
-  });
-
-  it('should handle empty string', () => {
-    assertEquals(hexToBigint(''), BigInt(0));
-  });
-
-  it('should throw error for negative bigint', () => {
-    chai.expect(() => bigintToHex(BigInt(-1))).to.throw('negative bigint');
-  });
-});
-
-describe('Conversion Utilities - bigintToText and textToBigint', () => {
-  const bigintToText = lib.bigintToText;
-  const textToBigint = lib.textToBigint;
-
-  it('should convert 0 to text', () => {
-    bigintToText(BigInt(0)).should.equal('0');
-  });
-
-  it('should convert positive number to text', () => {
-    bigintToText(BigInt(123456789)).should.equal('123456789');
-  });
-
-  it('should convert large number to text', () => {
-    bigintToText(BigInt('0xdeadbeef')).should.equal('3735928559');
-  });
-
-  it('should convert text to bigint', () => {
-    assertEquals(textToBigint('123456789'), BigInt(123456789));
-  });
-
-  it('should round-trip convert', () => {
-    const original = BigInt('9876543210123456789');
-    const text = bigintToText(original);
-    const result = textToBigint(text);
-    assertEquals(result, original);
-  });
-
-  it('should throw error for empty string', () => {
-    chai.expect(() => textToBigint('')).to.throw('cannot be empty');
-  });
-
-  it('should throw error for invalid decimal string', () => {
-    chai.expect(() => textToBigint('abc')).to.throw('invalid decimal');
-  });
-});
-
-describe('Conversion Utilities - bigintToBase64 and base64ToBigint', () => {
-  const bigintToBase64 = lib.bigintToBase64;
-  const base64ToBigint = lib.base64ToBigint;
-
-  it('should convert 0 to base64', () => {
-    const b64 = bigintToBase64(BigInt(0));
-    b64.should.be.a('string');
-    assertEquals(base64ToBigint(b64), BigInt(0));
-  });
-
-  it('should convert small number to base64', () => {
-    const original = BigInt(123456789);
-    const b64 = bigintToBase64(original);
-    b64.should.equal('B1vNFQ==');
-  });
-
-  it('should convert base64 to bigint', () => {
-    assertEquals(base64ToBigint('B1vNFQ=='), BigInt(123456789));
-  });
-
-  it('should round-trip convert medium numbers', () => {
-    const original = BigInt('0xdeadbeef');
-    const b64 = bigintToBase64(original);
-    const result = base64ToBigint(b64);
-    assertEquals(result, original);
-  });
-
-  it('should round-trip convert large numbers', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const b64 = bigintToBase64(original);
-    const result = base64ToBigint(b64);
-    assertEquals(result, original);
-  });
-
-  it('should throw error for negative bigint', () => {
-    chai.expect(() => bigintToBase64(BigInt(-1))).to.throw('negative bigint');
-  });
-
-  it('should throw error for empty base64 string', () => {
-    chai.expect(() => base64ToBigint('')).to.throw('cannot be empty');
-  });
-
-  it('should throw error for invalid base64 string', () => {
-    chai.expect(() => base64ToBigint('invalid!@#')).to.throw('invalid base64');
-  });
-});