A convention that convert Rust types to NodeJS types. 

A convention that convert Rust types to NodeJS types

tphanson

soprox-abi

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var F = new BN(Buffer.from('ffffffffffffffff', 'hex'), 16, 'le');

var FMAX = new BN(Buffer.from('ffffffffffffff7f', 'hex'), 16, 'le');

var FF = new BN(Buffer.from('ffffffffffffffffffffffffffffffff', 'hex'), 16, 'le');

var FFMAX = new BN(Buffer.from('ffffffffffffffffffffffffffffff7f', 'hex'), 16, 'le');

Buffer.prototype.writeBigInt64LE = Buffer.prototype.writeBigInt64LE || function (jsBigInt) {

  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

  var bigInt = new BN(jsBigInt.toString());

  if (bigInt.gt(FMAX) || bigInt.lt(FMIN)) throw new Error('BigInt is too big');

  var transformedBigInt = bigInt.gte(ZERO) ? bigInt : F.add(bigInt).add(ONE);

  var arrayBuf = transformedBigInt.toArray('le', this.length);

  for (var i = 0; i < this.length; i++) {

Buffer.prototype.readBigInt64LE = Buffer.prototype.readBigInt64LE || function () {

  var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;

  if (bigInt.gt(F)) throw new Error('BigInt is too big');

  if (bigInt.gt(FMAX)) bigInt = NEONE.sub(F.sub(bigInt)); // Using global.BigInt instead of BigInt due to browser understanding

  return global.BigInt(bigInt.toString());

Buffer.prototype.writeBigInt128LE = Buffer.prototype.writeBigInt128LE || function (jsBigInt) {

  if (bigInt.gt(FFMAX) || bigInt.lt(FFMIN)) throw new Error('BigInt is too big');

  var transformedBigInt = bigInt.gte(ZERO) ? bigInt : FF.add(bigInt).add(ONE);

Buffer.prototype.readBigInt128LE = Buffer.prototype.readBigInt128LE || function () {

  if (bigInt.gt(FF)) throw new Error('BigInt is too big');

  if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt));

  console.log(bigInt.toString()); // Using global.BigInt instead of BigInt due to browser understanding

  if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt)); // Using global.BigInt instead of BigInt due to browser understanding

var type2Write = function type2Write(type) {

var type2Read = function type2Read(type) {

var isize = function isize(value, type, byteLength) {

  _defineProperty(this, "toBuffer", function () {

    var buf = Buffer.allocUnsafe(_this.space);

    buf[type2Write(_this.type)](_this.value, 0);

  _defineProperty(this, "fromBuffer", function (buf) {

    if (!Buffer.isBuffer(buf)) throw new Error('Invalid buffer');

    _this.value = buf[type2Read(_this.type)](0);

var i8 = /*#__PURE__*/function (_isize) {

    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;

    return _super.call(this, value, 'i8', 1);

var i16 = /*#__PURE__*/function (_isize2) {

  "description": "A convention that convert Rust types to NodeJS types",

    "release": "npm run build && npm publish",

    "build": "npm run clean && babel src -d dist",

    "url": "git+https://github.com/DescartesNetwork/soprox-abi.git"

    "url": "https://github.com/DescartesNetwork/soprox-abi/issues"

  "homepage": "https://github.com/DescartesNetwork/soprox-abi#readme",

    "@babel/plugin-proposal-class-properties": "^7.12.1",

    "@babel/plugin-transform-arrow-functions": "^7.12.1",

const F = new BN(Buffer.from('ffffffffffffffff', 'hex'), 16, 'le')

const FMAX = new BN(Buffer.from('ffffffffffffff7f', 'hex'), 16, 'le')

  Buffer.from('ffffffffffffffffffffffffffffffff', 'hex'),

  Buffer.from('ffffffffffffffffffffffffffffff7f', 'hex'),

const FFMIN = FFMAX.mul(NEONE).add(NEONE)

    const bigInt = new BN(jsBigInt.toString())

    if (bigInt.gt(FMAX) || bigInt.lt(FMIN)) throw new Error('BigInt is too big')

    const transformedBigInt = bigInt.gte(ZERO) ? bigInt : F.add(bigInt).add(ONE)

    const arrayBuf = transformedBigInt.toArray('le', this.length)

    for (let i = 0; i < this.length; i++) this[i] = arrayBuf[i]

    if (bigInt.gt(F)) throw new Error('BigInt is too big')

    if (bigInt.gt(FMAX)) bigInt = NEONE.sub(F.sub(bigInt))

    // Using global.BigInt instead of BigInt due to browser understanding

    return global.BigInt(bigInt.toString())

    if (bigInt.gt(FFMAX) || bigInt.lt(FFMIN))

      throw new Error('BigInt is too big')

    const transformedBigInt = bigInt.gte(ZERO)

    if (bigInt.gt(FF)) throw new Error('BigInt is too big')

    if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt))

    const buf = Buffer.allocUnsafe(this.space)

    buf[type2Write(this.type)](this.value, 0)

    if (!Buffer.isBuffer(buf)) throw new Error('Invalid buffer')

    this.value = buf[type2Read(this.type)](0)

module.exports = { i8, i16, i32, i64, i128 }

		{
		"name": "soprox-abi",
		"version": "0.0.17",
		"version": "0.0.18",
		"description": "A convention that convert Rust types to NodeJS types",
		@@ -5,0 +5,0 @@ "main": "dist/index.js",

		@@ -80,4 +80,3 @@ "use strict";
		if (bigInt.gt(FF)) throw new Error('BigInt is too big');
		if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt));
		console.log(bigInt.toString()); // Using global.BigInt instead of BigInt due to browser understanding
		if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt)); // Using global.BigInt instead of BigInt due to browser understanding

		@@ -84,0 +83,0 @@ return global.BigInt(bigInt.toString());

		@@ -61,3 +61,2 @@ const BN = require('bn.js')
		if (bigInt.gt(FFMAX)) bigInt = NEONE.sub(FF.sub(bigInt))
		console.log(bigInt.toString())
		// Using global.BigInt instead of BigInt due to browser understanding
		@@ -64,0 +63,0 @@ return global.BigInt(bigInt.toString())

Worsened metrics