@gsknnft/bigint-buffer 1.2.0

package/karma.conf.js

@@ -0,0 +1,62 @@
+const webpack = require('webpack')
+module.exports = function (config) {
+   const configuration = {
+    browserNoActivityTimeout: 120000,
+    frameworks: ['mocha'],
+    files: [
+      './build/src/*.spec.js'
+    ],
+    preprocessors: {
+      './build/src//*.spec.js': ['webpack', 'env']
+    },
+    webpack : {
+      mode: "production",
+      devtool: 'inline-source-map',
+      module: {
+          // Suppress warning from mocha: "Critical dependency: the request of a dependency is an expression"
+          // @see https://webpack.js.org/configuration/module/#module-contexts
+          exprContextCritical: false
+      },
+      // Suppress fatal error: Cannot resolve module 'fs'
+      // @relative https://github.com/pugjs/pug-loader/issues/8
+      // @see https://github.com/webpack/docs/wiki/Configuration#node
+      node: {
+        fs: 'empty',
+        bindings: 'empty'
+      }, 
+      resolve: {
+        extensions: ['.ts', '.js', '.json']
+      }, plugins: [ new webpack.NormalModuleReplacementPlugin(
+          /\.\/index/,
+          './build/src/bromwser.js'
+        ),
+      ],
+    },
+    singleRun: true,
+    reporters: ['mocha'],
+    plugins: [
+      'karma-chrome-launcher',
+      'karma-env-preprocessor',
+      'karma-webpack',
+      'karma-mocha',
+      'karma-mocha-reporter'
+    ],
+    mime: {
+      'text/x-typescript': ['ts','tsx']
+    },
+    browsers: ['Chrome'],
+    customLaunchers: {
+      Chrome_travis_ci: {
+        base: 'Chrome',
+        flags: ['--no-sandbox']
+      }
+    }
+   };
+
+    if(process.env.TRAVIS) {
+      configuration.browsers = ['Chrome_travis_ci'];
+    }
+
+    config.set(configuration);
+}
+

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@gsknnft/bigint-buffer",
+  "version": "1.2.0",
+  "description": "bigint to buffer conversion with native support",
+  "main": "dist/index.js",
+  "type": "module",
+  "browser": {
+    "./dist/node.js": "./dist/browser.js"
+  },
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gsknnft/bigint-buffer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gsknnft/bigint-buffer/issues"
+  },
+  "homepage": "https://github.com/gsknnft/bigintbuffer",
+  "keywords": [
+    "bigint",
+    "bignum",
+    "tc39-bigint",
+    "napi"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bindings": "^1.5.0"
+  },
+  "devDependencies": {
+    "@types/benchmark": "^2.1.5",
+    "@types/bn.js": "^5.2.0",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.9.1",
+    "benchmark": "^2.1.4",
+    "bn.js": "^5.2.2",
+    "chai": "^4.1.2",
+    "coveralls": "^3.1.1",
+    "cpy-cli": "^6.0.0",
+    "cross-env": "^6.0.3",
+    "gts": "^0.8.0",
+    "istanbul": "^0.4.1",
+    "karma": "^3.0.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-env-preprocessor": "^0.1.1",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-webpack": "^3.0.0",
+    "microtime": "^3.0.0",
+    "mkdirp": "^0.5.1",
+    "mocha": "^5.2.0",
+    "pre-commit": "^1.2.2",
+    "rollup": "^4.52.5",
+    "rollup-plugin-replace": "^2.2.0",
+    "ts-loader": "^9.5.4",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.14",
+    "typescript": "5.9.3",
+    "webpack": "5.102.1",
+    "webpack-cli": "6.0.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    "Gordon Skinner <gsknnft@gmail.com> (https://github.com/gsknnft)",
+    "Michael Wei <mwei@vmware.com> (https://github.com/no2chem)"
+  ],
+  "scripts": {
+    "test": "npm run test:node && npm run test:browser",
+    "coverage": "istanbul cover ./test/index.js",
+    "coveralls": "npm run coverage && coveralls <coverage/lcov.info",
+    "lint": "gts check",
+    "install": "npm run rebuild || echo \"Couldn't build bindings. Non-native version used.\"",
+    "test:browser": "karma start karma.conf.js",
+    "test:node": "mocha -r ts-node/register src/**/*.spec.ts --timeout 40000",
+    "benchmark": "node -r ts-node/register src/index.bench.ts",
+    "typedoc": "typedoc --out docs $(pwd)/src $(pwd)/helper --target es6 --mode file --tsconfig ./tsconfig.json --excludePrivate --excludeProtected --excludeNotExported --exclude '**/*+(spec|bench).ts'",
+    "rebuild": "node-gyp rebuild",
+    "check": "gts check",
+    "clean": "gts clean",
+    "compile": "tsc -p . && rollup -c > dist/node.js && cross-env BROWSER=true rollup -c > dist/browser.js && cpy build/src/*.d.ts dist",
+    "compileOG": "mkdirp dist && tsc -p . && rollup -c > dist/node.js && cross-env BROWSER=true rollup -c > dist/browser.js && cpx \"build/src/*.d.ts\" dist",
+    "fix": "gts fix",
+    "pretest": "npm run compile",
+    "posttest": "npm run check"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,13 @@
+import replace from 'rollup-plugin-replace';
+
+export default {
+    input: 'build/src/index.js',
+    output: {
+        format: 'cjs'
+    },
+    plugins: [
+        replace({
+            'process.browser': process.env.BROWSER === "true"
+        })
+    ]
+};

package/src/bigint-buffer.c

@@ -0,0 +1,203 @@
+
+#define NAPI_EXPERIMENTAL
+#include <node_api.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <limits.h> 
+
+#define BIT_MASK(n) (~( ((~0ull) << ((n)-1)) << 1 ))
+
+// The maximum size we'll store on the stack. If we need a larger temporary
+// buffer malloc will be called.
+#define BUFFER_STACK_SIZE 32
+
+#if defined(_WIN16) || defined(_WIN32) || defined(_WIN64)
+#define bswap64(x) _byteswap_uint64(x)
+#else
+#define bswap64(x) __builtin_bswap64(x)
+#endif
+
+/**
+ * Converts a Buffer to bigint.
+ * node param 0: buffer
+ * node param 1: big_endian (optional boolean)
+ * 
+ * returns bigint
+ */
+napi_value toBigInt (napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  napi_status status;
+  size_t argc = 2;
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  if (argc < 1) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  bool big_endian;
+  status = napi_get_value_bool(env, argv[1], &big_endian);
+  if (status == napi_boolean_expected) { big_endian = false; }
+
+  uint8_t* buffer;
+  size_t len;
+  status = napi_get_buffer_info(env, argv[0], (void**) &buffer, &len);
+  assert(status == napi_ok);
+
+  // If len is not divisible by 8 bytes, we'll need to copy
+  bool not_64_aligned = (len & 7) != 0;
+  size_t overflow_len = not_64_aligned ? 8 - (len & 0x7) : 0;
+  // Buffer is managed by VM, so copy it out (TODO: perhaps we can increase refcount?)
+  size_t aligned_len = len + overflow_len;
+  size_t len_in_words = not_64_aligned ? (len >> 3) + 1 : (len >> 3);
+  bool fits_in_stack = aligned_len <= BUFFER_STACK_SIZE;
+
+  uint8_t copy[BUFFER_STACK_SIZE];
+  uint8_t* bufTemp = fits_in_stack ? copy : malloc(aligned_len);
+  if (overflow_len > 0) {
+    memset(bufTemp + len, 0, overflow_len);
+  }
+  memcpy(bufTemp, buffer, len);
+  uint64_t* as_64_aligned = (uint64_t*) bufTemp;
+  size_t overflow_in_bits = overflow_len << 3; // == overflow_len * 8
+
+  napi_value out;
+  // swap
+  if (big_endian) {
+    if (len_in_words == 1) {
+        as_64_aligned[0] = not_64_aligned ? bswap64(as_64_aligned[0]) >> overflow_in_bits :  bswap64(as_64_aligned[0]);
+    } else {
+        uint64_t temp;
+        size_t last_word = len_in_words - 1;
+        size_t end_ptr = last_word;
+        int32_t offset;
+        for (offset = 0; offset < (int32_t)(len_in_words / 2); offset++) {
+            temp = as_64_aligned[offset];
+            as_64_aligned[offset] = as_64_aligned[end_ptr];
+            as_64_aligned[end_ptr] = temp;
+            end_ptr--;
+        } 
+        uint64_t prev_overflow = 0;
+        for (offset = last_word; offset >= 0; offset--) {
+            uint64_t as_little_endian = bswap64(as_64_aligned[offset]);
+            uint64_t overflow = as_little_endian & BIT_MASK(overflow_in_bits);
+            as_64_aligned[offset] = not_64_aligned ? (as_little_endian >> overflow_in_bits) | prev_overflow : as_little_endian;
+            prev_overflow = overflow << (64 - overflow_in_bits);
+        }
+    }
+  }
+
+  status = napi_create_bigint_words(env, 0, len_in_words, as_64_aligned , &out);
+  assert(status == napi_ok);
+
+  if (!fits_in_stack) {
+      free(bufTemp);
+  }
+
+  return out;
+}
+
+/**
+ * Converts a BigInt to a Buffer
+ * node param 0: BigInt
+ * node param 1: buffer
+ * node param 2: big_endian (optional boolean)
+ * 
+ * returns bigint
+ */
+napi_value fromBigInt (napi_env env, napi_callback_info info) {
+  napi_value argv[3];
+  napi_status status;
+  size_t argc = 3;
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  if (argc < 1) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  size_t byte_width;
+  bool big_endian;
+  status = napi_get_value_bool(env, argv[2], &big_endian);
+  if (status == napi_boolean_expected) { big_endian = false; }
+
+  size_t word_count;
+  status = napi_get_value_bigint_words(env, argv[0], NULL, &word_count, NULL);
+  assert(status == napi_ok);
+
+  uint8_t* raw_buffer;
+  status = napi_get_buffer_info(env, argv[1], (void**) &raw_buffer, &byte_width);
+  assert(status == napi_ok);
+
+  if (word_count == 0) {
+      memset(raw_buffer, 0, byte_width);
+      return argv[1];
+  }
+
+  int sign_bit = 0;
+  
+  bool not_64_aligned = (byte_width & 7) != 0;
+  size_t overflow_len = not_64_aligned ? 8 - (byte_width & 0x7) : 0;
+  size_t word_width = (byte_width >> 3) + (not_64_aligned ? 1 : 0);
+  size_t original_word_width = word_width;
+  if (word_count > word_width) {
+      word_count = word_width;
+  }
+  size_t word_width_bytes = (word_count << 3);
+  bool fits_in_stack = word_width_bytes <= BUFFER_STACK_SIZE;
+
+  uint64_t* conv_buffer = (uint64_t*) raw_buffer;
+  uint64_t stack_buffer[BUFFER_STACK_SIZE];
+  if (not_64_aligned) {
+      conv_buffer = fits_in_stack ? stack_buffer : malloc(byte_width + overflow_len);
+  }
+  
+  memset(conv_buffer, 0, byte_width + overflow_len);
+  status = napi_get_value_bigint_words(env, argv[0], &sign_bit, &word_count, conv_buffer);
+  assert(status == napi_ok);
+
+  if (big_endian) {
+        uint64_t temp;
+        size_t conv_words = original_word_width;
+        size_t last_word = conv_words - 1;
+        size_t end_ptr = last_word;
+        int32_t offset;
+        for (offset = 0; offset < (int32_t)(conv_words / 2); offset++) {
+            temp = bswap64(conv_buffer[offset]);
+            conv_buffer[offset] = bswap64(conv_buffer[end_ptr]);
+            conv_buffer[end_ptr] = temp;
+            end_ptr--;
+        } 
+        if (conv_words & 1) {
+            conv_buffer[conv_words / 2] = bswap64(conv_buffer[conv_words / 2]);;
+        }
+  }
+  if (not_64_aligned) {
+      memcpy(raw_buffer, big_endian ? (uint64_t*)(((uint8_t*)conv_buffer) + (8-(byte_width & 7))) : conv_buffer, byte_width);
+      if (!fits_in_stack) {
+          free(conv_buffer);
+      }
+  }
+  return argv[1];
+}
+
+napi_value init_all (napi_env env, napi_value exports) {
+  napi_value bigint_fn;
+  napi_value frombigint_fn;
+
+  napi_create_function(env, NULL, 0, toBigInt, NULL, &bigint_fn);
+  napi_create_function(env, NULL, 0, fromBigInt, NULL, &frombigint_fn);
+
+  napi_set_named_property(env, exports, "toBigInt", bigint_fn);
+  napi_set_named_property(env, exports, "fromBigInt", frombigint_fn);
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init_all);

package/src/index.bench.ts

@@ -0,0 +1,207 @@
+
+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();