@gsknnft/bigint-buffer 1.3.2 → 1.4.2

package/src/index.spec.ts

@@ -1,444 +1,318 @@
-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();
+import { beforeAll, describe, expect, it } from "vitest";
+
+let lib: Awaited<typeof import("./index.js")>;
+let toBigIntBE: Awaited<typeof import("./index.js")>["toBigIntBE"];
+let toBigIntLE: Awaited<typeof import("./index.js")>["toBigIntLE"];
+let toBufferBE: Awaited<typeof import("./index.js")>["toBufferBE"];
+let toBufferLE: Awaited<typeof import("./index.js")>["toBufferLE"];
+// Removed unused variable assignments to fix lint errors
+
+beforeAll(async () => {
+  lib = await import("./index.js");
+  toBigIntBE = lib.toBigIntBE;
+  toBigIntLE = lib.toBigIntLE;
+  toBufferBE = lib.toBufferBE;
+  toBufferLE = lib.toBufferLE;
+  // Removed assignments to undeclared variables
+});
 
 const assertEquals = (n0: bigint, n1: bigint) => {
-  chai.expect(n0.toString(16)).to.equal(n1.toString(16));
+  expect(n0.toString(16)).toBe(n1.toString(16));
 };
 
-describe('Try buffer conversion (little endian)', () => {
-  it('0 should equal 0n', () => {
-    assertEquals(toBigIntLE(Buffer.from([0])), BigInt('0'));
+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("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("0xdead should equal 0xdeadn", async () => {
+    assertEquals(toBigIntLE(Buffer.from([0xad, 0xde])), BigInt("0xdead"));
   });
 
-  it('0xdeadbeef should equal 0xdeadbeefn', async () => {
+  it("0xdeadbeef should equal 0xdeadbeefn", async () => {
     assertEquals(
-        toBigIntLE(Buffer.from([0xef, 0xbe, 0xad, 0xde])),
-        BigInt(`0xdeadbeef`));
+      toBigIntLE(Buffer.from([0xef, 0xbe, 0xad, 0xde])),
+      BigInt("0xdeadbeef")
+    );
   });
 
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
+  it("0xbadc0ffee0 should equal 0xbadc0ffee0n", async () => {
     assertEquals(
-        toBigIntLE(Buffer.from([0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0`));
+      toBigIntLE(Buffer.from([0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0")
+    );
   });
 
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
+  it("0xbadc0ffee0dd should equal 0xbadc0ffee0ddn", async () => {
     assertEquals(
-        toBigIntLE(Buffer.from([0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0dd`));
+      toBigIntLE(Buffer.from([0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0dd")
+    );
   });
 
-  it('0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n', async () => {
+  it("0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n", async () => {
     assertEquals(
-        toBigIntLE(Buffer.from([0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
-        BigInt(`0xbadc0ffee0ddf0`));
+      toBigIntLE(Buffer.from([0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0ddf0")
+    );
   });
 
-  it('0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn', async () => {
+  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`));
+      toBigIntLE(Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])),
+      BigInt("0xbadc0ffee0ddf00d")
+    );
   });
 
-  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 () => {
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
     assertEquals(
-        toBigIntBE(Buffer.from([0xde, 0xad, 0xbe, 0xef])),
-        BigInt(`0xdeadbeef`));
+      toBigIntLE(
+        Buffer.from([
+          0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc,
+          0xba,
+        ])
+      ),
+      BigInt("0xbadc0ffee0ddf00ddeadbeef")
+    );
   });
 
-  it('0xbadc0ffee0 should equal 0xbadc0ffee0n', async () => {
+  it("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeefn", async () => {
     assertEquals(
-        toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0])),
-        BigInt(`0xbadc0ffee0`));
-  });
-
-  it('0xbadc0ffee0dd should equal 0xbadc0ffee0ddn', async () => {
+      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(
-        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`));
+      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 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'));
+describe("Try buffer conversion (big endian)", () => {
+  it("0 should equal 0n", () => {
+    assertEquals(toBigIntBE(Buffer.from([0])), BigInt("0"));
   });
 
-  it('0xdead should equal 0xdeadn (6 byte)', async () => {
-    toBufferLE(BigInt(`0xdead`), 6).should.deep.equal(Buffer.from([
-      0xad, 0xde, 0, 0, 0, 0
-    ]));
+  it("1 should equal 1n", async () => {
+    assertEquals(toBigIntBE(Buffer.from([1])), BigInt("1"));
   });
 
-  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("0xdead should equal 0xdeadn", async () => {
+    assertEquals(toBigIntBE(Buffer.from([0xde, 0xad])), BigInt("0xdead"));
   });
 
-  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("0xdeadbeef should equal 0xdeadbeefn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xde, 0xad, 0xbe, 0xef])),
+      BigInt("0xdeadbeef")
+    );
   });
 
-  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
-        ]));
+  it("0xbadc0ffee0 should equal 0xbadc0ffee0n", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0])),
+      BigInt("0xbadc0ffee0")
+    );
   });
-});
-
-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("0xbadc0ffee0dd should equal 0xbadc0ffee0ddn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd])),
+      BigInt("0xbadc0ffee0dd")
+    );
   });
 
-  it('should convert small number to buffer', () => {
-    const buf = bigintToBuf(BigInt(123456789));
-    assertEquals(bufToBigint(buf), BigInt(123456789));
+  it("0xbadc0ffee0ddf0 should equal 0xbadc0ffee0ddf0n", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0])),
+      BigInt("0xbadc0ffee0ddf0")
+    );
   });
 
-  it('should round-trip convert medium numbers', () => {
-    const original = BigInt('0xdeadbeef');
-    const buf = bigintToBuf(original);
-    const result = bufToBigint(buf);
-    assertEquals(result, original);
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])),
+      BigInt("0xbadc0ffee0ddf00d")
+    );
   });
 
-  it('should round-trip convert large numbers', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const buf = bigintToBuf(original);
-    const result = bufToBigint(buf);
-    assertEquals(result, original);
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    assertEquals(
+      toBigIntBE(Buffer.from("badc0ffee0ddf00ddeadbeef", "hex")),
+      BigInt("0xbadc0ffee0ddf00ddeadbeef")
+    );
   });
 
-  it('should throw error for negative bigint', () => {
-    chai.expect(() => bigintToBuf(BigInt(-1))).to.throw('negative bigint');
+  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('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');
+describe("Try bigint conversion (little endian)", () => {
+  it("0 should equal 0n", () => {
+    expect(toBufferLE(BigInt("0"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])
+    );
   });
 
-  it('should convert small number to hex', () => {
-    bigintToHex(BigInt(255)).should.equal('ff');
+  it("1 should equal 1n", async () => {
+    expect(toBufferLE(BigInt("1"), 8)).toEqual(
+      Buffer.from([1, 0, 0, 0, 0, 0, 0, 0])
+    );
   });
 
-  it('should convert number to even-length hex', () => {
-    bigintToHex(BigInt(15)).should.equal('0f');
+  it("1 should equal 1n (32 byte)", async () => {
+    expect(toBufferLE(BigInt("1"), 32)).toEqual(
+      Buffer.from(
+        "0100000000000000000000000000000000000000000000000000000000000000",
+        "hex"
+      )
+    );
   });
 
-  it('should convert hex string to bigint', () => {
-    assertEquals(hexToBigint('deadbeef'), BigInt('0xdeadbeef'));
+  it("0xdead should equal 0xdeadn (6 byte)", async () => {
+    expect(toBufferLE(BigInt("0xdead"), 6)).toEqual(
+      Buffer.from([0xad, 0xde, 0, 0, 0, 0])
+    );
   });
 
-  it('should handle hex string with 0x prefix', () => {
-    assertEquals(hexToBigint('0xdeadbeef'), BigInt('0xdeadbeef'));
+  it("0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)", async () => {
+    expect(toBufferLE(BigInt("0xdeadbeef"), 9)).toEqual(
+      Buffer.from([0xef, 0xbe, 0xad, 0xde, 0, 0, 0, 0, 0])
+    );
   });
 
-  it('should round-trip convert', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const hex = bigintToHex(original);
-    const result = hexToBigint(hex);
-    assertEquals(result, original);
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)", async () => {
+    expect(toBufferLE(BigInt("0xbadc0ffee0ddf00d"), 8)).toEqual(
+      Buffer.from([0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba])
+    );
   });
 
-  it('should handle empty string', () => {
-    assertEquals(hexToBigint(''), BigInt(0));
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    expect(toBufferLE(BigInt("0xbadc0ffee0ddf00ddeadbeef"), 12)).toEqual(
+      Buffer.from([
+        0xef, 0xbe, 0xad, 0xde, 0x0d, 0xf0, 0xdd, 0xe0, 0xfe, 0x0f, 0xdc, 0xba,
+      ])
+    );
   });
 
-  it('should throw error for negative bigint', () => {
-    chai.expect(() => bigintToHex(BigInt(-1))).to.throw('negative bigint');
+  it("long value should equal long val", async () => {
+    expect(
+      toBufferLE(
+        BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef"),
+        24
+      )
+    ).toEqual(
+      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('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);
+describe("Try bigint conversion (big endian)", () => {
+  it("0 should equal 0n", () => {
+    expect(toBufferBE(BigInt("0"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])
+    );
   });
 
-  it('should throw error for empty string', () => {
-    chai.expect(() => textToBigint('')).to.throw('cannot be empty');
+  it("1 should equal 1n", async () => {
+    expect(toBufferBE(BigInt("1"), 8)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0, 0, 1])
+    );
   });
 
-  it('should throw error for invalid decimal string', () => {
-    chai.expect(() => textToBigint('abc')).to.throw('invalid decimal');
+  it("1 should equal 1n (32 byte)", async () => {
+    expect(toBufferBE(BigInt("1"), 32)).toEqual(
+      Buffer.from(
+        "0000000000000000000000000000000000000000000000000000000000000001",
+        "hex"
+      )
+    );
   });
-});
-
-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("0xdead should equal 0xdeadn (6 byte)", async () => {
+    expect(toBufferBE(BigInt("0xdead"), 6)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0xde, 0xad])
+    );
   });
 
-  it('should convert small number to base64', () => {
-    const original = BigInt(123456789);
-    const b64 = bigintToBase64(original);
-    b64.should.equal('B1vNFQ==');
+  it("0xdeadbeef should equal 0xdeadbeef0000000000n (9 byte)", async () => {
+    expect(toBufferBE(BigInt("0xdeadbeef"), 9)).toEqual(
+      Buffer.from([0, 0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef])
+    );
   });
 
-  it('should convert base64 to bigint', () => {
-    assertEquals(base64ToBigint('B1vNFQ=='), BigInt(123456789));
+  it("0xbadc0ffee0ddf00d should equal 0xbadc0ffee0ddf00dn (8 byte)", async () => {
+    expect(toBufferBE(BigInt("0xbadc0ffee0ddf00d"), 8)).toEqual(
+      Buffer.from([0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d])
+    );
   });
 
-  it('should round-trip convert medium numbers', () => {
-    const original = BigInt('0xdeadbeef');
-    const b64 = bigintToBase64(original);
-    const result = base64ToBigint(b64);
-    assertEquals(result, original);
+  it("0xbadc0ffee0ddf00ddeadbeef should equal 0xbadc0ffee0ddf00ddeadbeefn", async () => {
+    expect(toBufferBE(BigInt("0xbadc0ffee0ddf00ddeadbeef"), 12)).toEqual(
+      Buffer.from([
+        0xba, 0xdc, 0x0f, 0xfe, 0xe0, 0xdd, 0xf0, 0x0d, 0xde, 0xad, 0xbe, 0xef,
+      ])
+    );
   });
 
-  it('should round-trip convert large numbers', () => {
-    const original = BigInt('0xbadc0ffee0ddf00ddeadbeef');
-    const b64 = bigintToBase64(original);
-    const result = base64ToBigint(b64);
-    assertEquals(result, original);
+  it("long value should equal long val", async () => {
+    expect(
+      toBufferBE(
+        BigInt("0xbadc0ffee0ddf00ddeadbeefbadc0ffee0ddf00ddeadbeef"),
+        24
+      )
+    ).toEqual(
+      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,
+      ])
+    );
   });
-
-  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');
-  });
-});
+});