@gsknnft/bigint-buffer 1.4.1 → 1.4.2

package/src/conversion/test/hexToBigint.test.ts

@@ -0,0 +1,22 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('hexToBigint', () => {
+  const inputs = [
+    {bi: BigInt(1), hex: '1'}, {bi: BigInt(31), hex: '1F'}, {
+      bi: BigInt('12485413541784539569456874935679853424678352483761'),
+      hex: '88af94e6b1e99f8bf3b01edb619caaa656A5c75b1'
+    }
+  ];
+
+  describe('hexToBigint', () => {
+    for (const input of inputs) {
+      describe(`hexToBigint(${input.hex})`, () => {
+        it(`should return ${input.bi}`, () => {
+          const ret = bc.hexToBigint(input.hex);
+          expect(ret).to.equal(input.bi);
+        });
+      });
+    }
+  });
+});

package/src/conversion/test/hexToBuf.test.ts

@@ -0,0 +1,39 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('hexToBuf', () => {
+  const tests = [
+    {buf: new Uint8Array([9, 255]), hex: '09ff'},
+    {buf: new Uint16Array([5, 256]), hex: '05000001'},
+    {buf: new ArrayBuffer(2), hex: '000'},
+    {buf: new Uint8Array([1, 1]), hex: '0x101'},
+    {buf: new Uint8Array([1, 1, 1]), hex: '10101'}
+  ];
+
+  describe('hexToBuf and bufToHex', () => {
+    for (const test of tests) {
+      describe(`bufToHex([${(new Uint8Array(test.buf)).toString()}])`, () => {
+        const byteLength = test.buf.byteLength;
+        const expected = bc.parseHex(test.hex, false, byteLength);
+        it(`should return ${String(expected)}`, () => {
+          const ret = bc.bufToHex(test.buf);
+          expect(ret).to.equal(expected);
+        });
+      });
+      describe(`bufToHex(hexToBuf(${test.hex}))`, () => {
+        const byteLength = test.buf.byteLength;
+        const expected = bc.parseHex(test.hex, false, byteLength);
+        it(`should return ${String(expected)}`, () => {
+          const buf = bc.hexToBuf(test.hex);
+          const ret = bc.bufToHex(buf);
+          expect(ret).to.equal(expected);
+        });
+      });
+      describe('hexToBuf(\'12412fgt3\')', () => {
+        it('should throw RangeError', () => {
+          expect(() => bc.hexToBuf('12412fgt3')).to.throw(RangeError);
+        });
+      });
+    }
+  });
+});

package/src/conversion/test/parseHex.test.ts

@@ -0,0 +1,35 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('parseHex', () => {
+  const vectors = [
+    {input: '0x234FE678', output: '234FE678'},
+    {input: '234FE687', output: '234FE687'},
+    {input: '0x123546146f23A2', output: '123546146f23A2'}
+  ];
+  for (const vector of vectors) {
+    it(`parseHex('${vector.input}') should return '${vector.output}'`, () => {
+      const ret = bc.parseHex(vector.input);
+      expect(ret).to.equal(vector.output);
+    });
+    it(`parseHex('${vector.input}', true) should return '0x${vector.output}'`,
+       () => {
+         const ret = bc.parseHex(vector.input, true);
+         expect(ret).to.equal('0x' + vector.output);
+       });
+  }
+  it('parseHex(\'adge3\') should throw error', () => {
+    expect(() => {
+      bc.parseHex('adge3');
+    }).to.throw(RangeError);
+  });
+  it('parseHex(\'1287a3\', undefined, 4) should return \'001287a3\'', () => {
+    const ret = bc.parseHex('1287a3', undefined, 4);
+    expect(ret).to.equal('001287a3');
+  });
+  it('parseHex(\'1287542fe21\', true, 4) should throw error', () => {
+    expect(() => {
+      bc.parseHex('1287542fe21', true, 4);
+    }).to.throw(RangeError);
+  });
+});

package/src/conversion/test/setup.test.ts

@@ -0,0 +1,9 @@
+import {describe, expect, it} from 'vitest';
+
+(globalThis as {expect?: typeof expect}).expect = expect;
+
+describe('setup', () => {
+  it('noop', () => {
+    expect(true).to.equal(true);
+  });
+});

package/src/conversion/test/textToBuf.test.ts

@@ -0,0 +1,26 @@
+import * as bc from "#pkg";
+import { describe, expect, it } from "vitest";
+
+describe("textToBuf", () => {
+  const inputs = [
+    "Hello World",
+    "Apañarse por qué?",
+    `Lorem ipsum dolor sit amet, consectetur adipisci tempor incidunt ut labore et dolore magna aliqua veniam, quis nostrud exercitation ullamcorpor s commodo consequat. Duis autem vel eum irrure esse molestiae consequat, vel illum dolore eu fugi et iusto odio dignissim qui blandit praesent luptat exceptur sint occaecat cupiditat non provident, deserunt mollit anim id est laborum et dolor fuga distinct. Nam liber tempor cum soluta nobis elige quod maxim placeat facer possim omnis volupt
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i, dolore eu fugiat nulla pariatur. At vero eos et accusa praesant luptatum delenit aigue duos dolor et mole provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend optio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i dolore eu fugiat nulla pariatur. At vero eos et accus praesant luptatum delenit aigue duos dolor et mol provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend oprio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud`,
+  ];
+
+  let returnArrayBuffer = false;
+
+  for (const input of inputs) {
+    describe(`bufToText(textToBuf(${input.substring(0, 8)}...))`, () => {
+      it(`should return ${input.substring(0, 8)}...`, () => {
+        returnArrayBuffer = returnArrayBuffer ? false : true;
+        const ret = bc.bufToText(bc.textToBuf(input, returnArrayBuffer));
+        expect(ret).to.equal(input);
+      });
+    });
+  }
+});

package/src/conversion/tsconfig.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "rootDir": ".",
+    "target": "ESNext",                       /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', 'ES2023', 'ES2023' or 'ESNEXT'. */
+    "module": "NodeNext",
+    // "lib": [ "es2020" ],                   /* Specify library files to be included in the compilation. */
+    "allowJs": true,                          /* Allow javascript files to be compiled. */
+    "checkJs": true,                          /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'react', 'react-jsx', 'react-jsxdev', 'preserve' or 'react-native'. */
+    "strict": true,   
+    "declaration": true,
+    "removeComments": true,
+    "typeRoots": ["../types", "../../node_modules/@types", "node_modules/@types"],    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,      /* Include 'undefined' in index signature results */
+    "tsBuildInfoFile": "build/main.tsbuildinfo",
+    "lib": [ "esnext", "dom" ],
+    "types": ["node"],
+
+    /* Module Resolution Options */
+    "moduleResolution": "NodeNext",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+     "baseUrl": ".",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDir": ".",
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [ "node_modules/@types", "build/typings" ],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,               /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "resolveJsonModule": true,
+    "paths": {
+      "#pkg": ["./src/ts/index.ts"]
+    }
+  },
+"exclude": [
+  "node_modules",
+  "build",
+  "src/conversion/.dst"
+],
+"include": [
+  "src/**/*.ts",
+  "test/**/*.ts"
+]
+}

package/src/conversion/tsconfig.rollup.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "outDir": "./.rollup-tmp",
+    "composite": false
+  },
+  "include": ["src/ts/**/*"]
+}

package/src/conversion/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "readme": "none",
+  "excludePrivate": true,
+  "plugin": ["typedoc-plugin-markdown"]
+}

package/src/conversion/types/bindings.d.t.s

@@ -0,0 +1,4 @@
+declare module 'bindings' {
+  function bindings(name: string): any;
+  export = bindings;
+}

package/src/conversion/vite.config.ts

@@ -0,0 +1,10 @@
+import path from "path";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "#pkg": path.resolve(__dirname, "src/ts/index.ts"),
+    },
+  },
+});

package/src/conversion/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["src/conversion/test/**/*.test.ts"],
+  },
+  resolve: {
+    alias: {
+      "#pkg": path.resolve(__dirname, "src/ts/index.ts"),
+    },
+  },
+});

package/src/index.bench.ts

@@ -0,0 +1,206 @@
+
+import benchmark from 'benchmark';
+import BN from 'bn.js';
+
+import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
+
+
+// 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.toArrayLike(Buffer, 'be', 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.toArrayLike(Buffer, 'be', 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();