@openclawcash/bigint-buffer 1.1.6-security.0 → 1.1.6-security.1

package/dist/browser.js

@@ -1,23 +1,19 @@
 'use strict';
 
 Object.defineProperty(exports, "__esModule", { value: true });
-let converter;
 /**
  * Convert a little-endian buffer into a BigInt.
  * @param buf The little-endian buffer to convert
  * @returns A BigInt with the little-endian representation of buf.
  */
 function toBigIntLE(buf) {
-    {
-        const reversed = Buffer.from(buf);
-        reversed.reverse();
-        const hex = reversed.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
+    const reversed = Buffer.from(buf);
+    reversed.reverse();
+    const hex = reversed.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
     }
-    return converter.toBigInt(buf, false);
+    return BigInt(`0x${hex}`);
 }
 exports.toBigIntLE = toBigIntLE;
 /**
@@ -26,14 +22,11 @@ exports.toBigIntLE = toBigIntLE;
  * @returns A BigInt with the big-endian representation of buf.
  */
 function toBigIntBE(buf) {
-    {
-        const hex = buf.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
+    const hex = buf.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
     }
-    return converter.toBigInt(buf, true);
+    return BigInt(`0x${hex}`);
 }
 exports.toBigIntBE = toBigIntBE;
 /**
@@ -43,14 +36,10 @@ exports.toBigIntBE = toBigIntBE;
  * @returns A little-endian buffer representation of num.
  */
 function toBufferLE(num, width) {
-    {
-        const hex = num.toString(16);
-        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-        buffer.reverse();
-        return buffer;
-    }
-    // Allocation is done here, since it is slower using napi in C
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    buffer.reverse();
+    return buffer;
 }
 exports.toBufferLE = toBufferLE;
 /**
@@ -60,10 +49,7 @@ exports.toBufferLE = toBufferLE;
  * @returns A big-endian buffer representation of num.
  */
 function toBufferBE(num, width) {
-    {
-        const hex = num.toString(16);
-        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    }
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+    const hex = num.toString(16);
+    return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
 }
 exports.toBufferBE = toBufferBE;

package/dist/node.js

@@ -1,32 +1,19 @@
 'use strict';
 
 Object.defineProperty(exports, "__esModule", { value: true });
-let converter;
-const nativeBindingsEnabled = process.env && process.env.BIGINT_BUFFER_NATIVE === '1';
-if (nativeBindingsEnabled) {
-    try {
-        converter = require('bindings')('bigint_buffer');
-    }
-    catch (e) {
-        console.warn('bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
-    }
-}
 /**
  * Convert a little-endian buffer into a BigInt.
  * @param buf The little-endian buffer to convert
  * @returns A BigInt with the little-endian representation of buf.
  */
 function toBigIntLE(buf) {
-    if (converter === undefined) {
-        const reversed = Buffer.from(buf);
-        reversed.reverse();
-        const hex = reversed.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
+    const reversed = Buffer.from(buf);
+    reversed.reverse();
+    const hex = reversed.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
     }
-    return converter.toBigInt(buf, false);
+    return BigInt(`0x${hex}`);
 }
 exports.toBigIntLE = toBigIntLE;
 /**
@@ -35,14 +22,11 @@ exports.toBigIntLE = toBigIntLE;
  * @returns A BigInt with the big-endian representation of buf.
  */
 function toBigIntBE(buf) {
-    if (converter === undefined) {
-        const hex = buf.toString('hex');
-        if (hex.length === 0) {
-            return BigInt(0);
-        }
-        return BigInt(`0x${hex}`);
+    const hex = buf.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
     }
-    return converter.toBigInt(buf, true);
+    return BigInt(`0x${hex}`);
 }
 exports.toBigIntBE = toBigIntBE;
 /**
@@ -52,14 +36,10 @@ exports.toBigIntBE = toBigIntBE;
  * @returns A little-endian buffer representation of num.
  */
 function toBufferLE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-        buffer.reverse();
-        return buffer;
-    }
-    // Allocation is done here, since it is slower using napi in C
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
+    const hex = num.toString(16);
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    buffer.reverse();
+    return buffer;
 }
 exports.toBufferLE = toBufferLE;
 /**
@@ -69,10 +49,7 @@ exports.toBufferLE = toBufferLE;
  * @returns A big-endian buffer representation of num.
  */
 function toBufferBE(num, width) {
-    if (converter === undefined) {
-        const hex = num.toString(16);
-        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    }
-    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
+    const hex = num.toString(16);
+    return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
 }
 exports.toBufferBE = toBufferBE;

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "@openclawcash/bigint-buffer",
-  "version": "1.1.6-security.0",
-  "description": "bigint to buffer conversion with native support (native bindings disabled by default for security)",
+  "version": "1.1.6-security.1",
+  "description": "bigint to buffer conversion (pure JS, native addon removed for security)",
   "main": "dist/node.js",
   "browser": {
     "./dist/node.js": "./dist/browser.js"
   },
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/**",
+    "helper/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
   "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.\"",
     "prepare": "npm run compile",
     "prepublishOnly": "rm -rf build/Release; rm -f build/Makefile build/gyp-* build/*.mk build/*.Makefile *.tgz",
     "test:browser": "cross-env NODE_OPTIONS=--openssl-legacy-provider 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": "mkdirp dist && tsc -p . && rollup -c > dist/node.js && cross-env BROWSER=true rollup -c > dist/browser.js && cpx \"build/src/*.d.ts\" dist",
@@ -41,9 +45,7 @@
     "napi"
   ],
   "license": "Apache-2.0",
-  "dependencies": {
-    "bindings": "^1.3.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/benchmark": "^1.0.31",
     "@types/bn.js": "^4.11.2",

package/.travis.yml

@@ -1,51 +0,0 @@
-language: node_js
-node_js:
-- node
-- '10'
-sudo : false
-env:
-  global:
-  - DISPLAY=:99.0
-  - secure: SQDlqZZTkrbRW/wYLPgEwFQpkSrs65MiF0JgO+cwSCAG1m0c7EuBTzvttAXzKK+coZXjd2+QJcAOBi6YUP84OdSf31PojIy4/SLuZxuFQa0sGey+8oSDqgMntpSthO9nom0s6u2vB61IVfcRVIUNv5L3J5i5ZIGlKGgC2MIBzsnhx0L//eyh/bLszR27ajCT7RG+pnqpk010eaDtRabOJTtO0C2kbBQoW2SvJIisDsRj5zqVyl03pZJQQAJeseiNlLokucrgitDWENE+tEJ2w1x1yl+901tgU+BIi4iLQTezcSAxnF149U/Nof7LpCba+1Y+PPh1SRpO4100CT6O46qW0O1keVfTmZL/R3ghBM6H0AtV1s48k/XCpHV9CGwxjBHoCN1kKvSO9B1BJuAdlmgobOEdze+X81nilSBhBmYMI1XPLbXqTo2ImfaFeDzveuPJH6+HMCc+8sDlhgLcrOiteAsY8RsI0ngBkutsWWv7QcRq29e4VX2eBy0j1VJZNf0FPAcKpWF8eIaPw7Z0CuWMs2hM0v0ns58jDcOL+1k4kKyJ10OOmANqNX+NZYRJJ05dd/VMrlh37teARI64PFSG6eIoCniW0GtrUcpX4KhqpaRSUDpsKvncXNdNydumMyMQjeQqyHqahvIE2ONVXXELD2T/EV6TpazDR5KSSo0=
-  - secure: ZwKAlaNZ8liLknkAfFN+TztrILi8Q06AknHUj0Zd+9PjzD5n6tpzp5g1nE0MEvF9bqkGkwf6vwWJVKcSXWM9J4a2pfoLe9wsVcjq+AkmWnZG0zV26ie3UPoa8d/PezRtxz+4vErvQcOqnESVPJAqeWCt0fH1WvnEcjaY3BYyyDbWwAPamWr/v9c4ZLKxJqJmgtczMCrRahd6Dz+HGGJ9BehhOXtse+rT5qFI6w2SMXaisDzk2twMu0fK1I66G2IsesIKErPigCeEPahsP2yu831+S18YvxJtao7tXpluMBf+RNhD9eI1evUu6IxpF419ANDJ7BpJ8uGfRVzIz9kQIAmcy/1s7g3otT633XngUfNYDisUeLJ39plclOHw+sVeLL49Xa9k+/U0CzlOThNlCj0hY2uJW3Ot9NjvKDjdR/UkgEBCl6nIDAnRQk9xSJ4ws1f9Yp5CgEXcXvu7077i6O8vG7+k08qHDSkxEEwQjB2PwjhcPfg9ieAwafblM3szYwzblL4UpROp/L/XmmzjR/cOVrS93RIpeLqDr2CCMKGd0GoOFtDse7u43SJMIAZ+O5DNtNpqIQ22V13p4P3L2C1RV3cjE55luEYVR1JZ7AzaxD+hZu2zcU2301MuSgFLTKMEu43HV1tPJ6QtCcSf+kH/LK/TPfTLveW23xkkZM0=
-  matrix:
-  - TEST_SUITE=test:node
-addons:
-  chrome: stable
-services:
-  - xvfb
-cache:
-  directories:
-   - $HOME/.npm
-matrix:
-  fast_finish: true
-  include:
-  - os: linux
-    node_js: '10'
-    env: TEST_SUITE=test:browser
-  - os: windows
-    node_js: '10'
-    env: TEST_SUITE=test:node
-script: npm run $TEST_SUITE
-before_deploy:
-- npm pack
-deploy:
-- provider: releases
-  api_key: "$GITHUB_TOKEN"
-  file_glob: true
-  file: bigint-buffer-*.tgz
-  skip_cleanup: true
-  on:
-    branch: master
-    node: '10'
-    condition: "$TEST_SUITE = test:node"
-    tags: true
-- provider: npm
-  api_key: "$NPM_TOKEN"
-  skip_cleanup: true
-  email: mwei@cs.ucsd.edu
-  on:
-    branch: master
-    node: '10'
-    condition: "$TEST_SUITE = test:node"
-    tags: true

package/binding.gyp

@@ -1,8 +0,0 @@
-{
-  "targets": [{
-    "target_name": "bigint_buffer",
-    "sources": [
-      "src/bigint-buffer.c"
-    ]
-  }]
-}

package/karma.conf.js

@@ -1,62 +0,0 @@
-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/rollup.config.js

@@ -1,13 +0,0 @@
-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

@@ -1,203 +0,0 @@
-
-#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

@@ -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,288 +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/browser') :
-                              require(path.join(__dirname, '../dist/node'));
-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 should = chai.should();
-
-const assertEquals = (n0: BigInt, n1: BigInt) => {
-  n0.toString(16).should.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
-        ]));
-  });
-});

package/src/index.ts

@@ -1,86 +0,0 @@
-
-interface ConverterInterface {
-  toBigInt(buf: Buffer, bigEndian?: boolean): bigint;
-  fromBigInt(num: BigInt, buf: Buffer, bigEndian?: boolean): Buffer;
-}
-
-declare var process: {browser: boolean; env?: {[key: string]: string | undefined}};
-
-let converter: ConverterInterface;
-const nativeBindingsEnabled =
-  !process.browser && process.env && process.env.BIGINT_BUFFER_NATIVE === '1';
-
-if (nativeBindingsEnabled) {
-  try {
-    converter = require('bindings')('bigint_buffer');
-  } catch (e) {
-    console.warn(
-        'bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)');
-  }
-}
-
-/**
- * Convert a little-endian buffer into a BigInt.
- * @param buf The little-endian buffer to convert
- * @returns A BigInt with the little-endian representation of buf.
- */
-export function toBigIntLE(buf: Buffer): bigint {
-  if (process.browser || converter === undefined) {
-    const reversed = Buffer.from(buf);
-    reversed.reverse();
-    const hex = reversed.toString('hex');
-    if (hex.length === 0) {
-      return BigInt(0);
-    }
-    return BigInt(`0x${hex}`);
-  }
-  return converter.toBigInt(buf, false);
-}
-
-/**
- * Convert a big-endian buffer into a BigInt
- * @param buf The big-endian buffer to convert.
- * @returns A BigInt with the big-endian representation of buf.
- */
-export function toBigIntBE(buf: Buffer): bigint {
-  if (process.browser || converter === undefined) {
-    const hex = buf.toString('hex');
-    if (hex.length === 0) {
-      return BigInt(0);
-    }
-    return BigInt(`0x${hex}`);
-  }
-  return converter.toBigInt(buf, true);
-}
-
-/**
- * Convert a BigInt to a little-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A little-endian buffer representation of num.
- */
-export function toBufferLE(num: bigint, width: number): Buffer {
-  if (process.browser || converter === undefined) {
-    const hex = num.toString(16);
-    const buffer =
-        Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-    buffer.reverse();
-    return buffer;
-  }
-  // Allocation is done here, since it is slower using napi in C
-  return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);
-}
-
-/**
- * Convert a BigInt to a big-endian buffer.
- * @param num   The BigInt to convert.
- * @param width The number of bytes that the resulting buffer should be.
- * @returns A big-endian buffer representation of num.
- */
-export function toBufferBE(num: bigint, width: number): Buffer {
-  if (process.browser || converter === undefined) {
-    const hex = num.toString(16);
-    return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
-  }
-  return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "extends": "./node_modules/gts/tsconfig-google.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "build",
-    "target" : "esnext",
-    "lib" : [ "esnext" ],
-    "sourceMap": true
-  },
-  "include": [
-    "src/*.ts",
-    "src/**/*.ts",
-    "test/*.ts",
-    "test/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}