@exodus/bigint 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# @exodus/bigint
+
+Immutable API wrapper for big integers, using BigInt if available in the JS environment and falling back to bn.js if it isn't
+
+## Usage
+
+```js
+import BigIntWrapper from '@exodus/bigint'
+
+const three = BigIntWrapper.wrap(3)
+const five = BigIntWrapper.wrap(5)
+
+// perform arithmetic
+// see full API: ./src/native-bigint.js and ./src/__tests__/index.test.js
+three.add(five).mul(three).div(five).pow(three).sub(five)
+```

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@exodus/bigint",
+  "version": "1.0.0",
+  "description": "bigint wrappers for native BigUnt, bn.js and others",
+  "main": "src/index.js",
+  "author": "Exodus Movement, Inc.",
+  "license": "UNLICENSED",
+  "homepage": "https://github.com/ExodusMovement/exodus-core/tree/master/packages/bigint#readme",
+  "files": [
+    "src",
+    "!**/__tests__",
+    "README.md"
+  ],
+  "dependencies": {
+    "bn.js": "^4.11.0",
+    "lodash": "^4.17.11",
+    "minimalistic-assert": "^1.0.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.43.0",
+    "jest": "^29.3.1"
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint . --ignore-path ../../.gitignore",
+    "lint:fix": "yarn lint --fix"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/exodus-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/exodus-core/issues?q=is%3Aissue+is%3Aopen+label%3Abigint"
+  }
+}

package/src/bn.js

@@ -0,0 +1,160 @@
+import assert from 'minimalistic-assert'
+import BN from 'bn.js'
+
+// TODO: calculator delegator should wrap/unwrap all BN instances
+// so that callers never gett a raw BN instance back
+
+const FACTORY_SYMBOL = Symbol('bn-wrapper')
+
+const unwrap = (value) => (value instanceof Wrapper ? value.unwrap() : value)
+
+export default class Wrapper {
+  static name = 'bn.js'
+  static isUnderlyingInstance(a) {
+    return BN.isBN(a)
+  }
+  static wrap(value, base) {
+    return new Wrapper(FACTORY_SYMBOL, value, base)
+  }
+  static get ZERO() {
+    return ZERO
+  }
+  static get TEN() {
+    return TEN
+  }
+
+  __value__
+
+  constructor(factorySymbol, value, base = 10) {
+    if (factorySymbol !== FACTORY_SYMBOL) throw new Error('use wrap() instead')
+
+    if (BN.isBN(value)) {
+      this.__value__ = value
+    } else {
+      if (typeof value !== 'string' && typeof value !== 'number') {
+        throw new TypeError(`Unsupported type: ${typeof value}`)
+      }
+
+      if (base !== 10 && base !== 16) throw new TypeError(`Unsupported base: ${base}`)
+
+      this.__value__ = new BN(value, base)
+    }
+  }
+
+  unwrap() {
+    return this.__value__
+  }
+
+  add(value) {
+    return Wrapper.wrap(this.__value__.add(unwrap(value)))
+  }
+
+  mutateAdd(value) {
+    this.__value__.iadd(unwrap(value))
+    return this
+  }
+
+  sub(value) {
+    return Wrapper.wrap(this.__value__.sub(unwrap(value)))
+  }
+
+  mutateSub(value) {
+    this.__value__.isub(unwrap(value))
+    return this
+  }
+
+  mul(value) {
+    return Wrapper.wrap(this.__value__.mul(unwrap(value)))
+  }
+
+  mutateMul(value) {
+    this.__value__.imul(unwrap(value))
+    return this
+  }
+
+  div(value) {
+    return Wrapper.wrap(this.__value__.div(unwrap(value)))
+  }
+
+  mutateDiv(value) {
+    this.__value__.idivn(unwrap(value))
+    return this
+  }
+
+  mod(value) {
+    return Wrapper.wrap(this.__value__.mod(unwrap(value)))
+  }
+
+  pow(value) {
+    return Wrapper.wrap(this.__value__.pow(unwrap(value)))
+  }
+
+  negate() {
+    return Wrapper.wrap(this.__value__.neg())
+  }
+
+  mutateNegate() {
+    return Wrapper.wrap(this.__value__.ineg())
+  }
+
+  abs() {
+    return this.isNegative() ? Wrapper.wrap(this.__value__.abs()) : this
+  }
+
+  mutateAbs() {
+    this.__value__.iabs()
+    return this
+  }
+
+  gte(value) {
+    return this.__value__.gte(unwrap(value))
+  }
+
+  gt(value) {
+    return this.__value__.gt(unwrap(value))
+  }
+
+  lte(value) {
+    return this.__value__.lte(unwrap(value))
+  }
+
+  lt(value) {
+    return this.__value__.lt(unwrap(value))
+  }
+
+  eq(value) {
+    return this.__value__.eq(unwrap(value))
+  }
+
+  isZero() {
+    return this.__value__.isZero()
+  }
+
+  isNegative() {
+    return this.__value__.isNeg()
+  }
+
+  isPositive() {
+    return this.__value__.gt(ZERO.unwrap())
+  }
+
+  toNumber() {
+    return this.__value__.toNumber()
+  }
+
+  toString(base) {
+    assert(typeof base === 'number', 'expected number "base"')
+    return this.__value__.toString(base)
+  }
+
+  toBaseBufferLE(length) {
+    return this.__value__.toBuffer('le', length)
+  }
+
+  toBaseBufferBE(length) {
+    return this.__value__.toBuffer('be', length)
+  }
+}
+
+const ZERO = new Wrapper(FACTORY_SYMBOL, 0)
+const TEN = new Wrapper(FACTORY_SYMBOL, 10)

package/src/index.js

@@ -0,0 +1,4 @@
+const Wrapper =
+  typeof BigInt === 'function' ? require('./native-bigint').default : require('./bn').default
+
+export default Wrapper

package/src/native-bigint.js

@@ -0,0 +1,173 @@
+// TODO: calculator delegator should wrap/unwrap all BigInt instances
+// so that callers never gett a raw BigInt instance back
+
+import { memoize } from 'lodash'
+import assert from 'minimalistic-assert'
+
+const FACTORY_SYMBOL = Symbol('bigint-wrapper')
+
+const unwrap = (value) => (value instanceof Wrapper ? value.unwrap() : value)
+
+const memoizedWrap = memoize((value) => Wrapper.wrap(value))
+
+export default class Wrapper {
+  static name = 'native-bigint'
+
+  static wrap(numberLike, base = 10) {
+    if (typeof numberLike === 'bigint') return new Wrapper(FACTORY_SYMBOL, numberLike)
+    if (typeof numberLike === 'number') return new Wrapper(FACTORY_SYMBOL, BigInt(numberLike))
+    if (typeof numberLike !== 'string') throw new Error(`Unsupported type: ${typeof numberLike}`)
+
+    switch (base) {
+      case 10:
+        return new Wrapper(FACTORY_SYMBOL, BigInt(numberLike))
+      case 16:
+        return new Wrapper(FACTORY_SYMBOL, BigInt('0x' + numberLike))
+      default:
+        throw new Error(`Unsupported base: ${base}`)
+    }
+  }
+
+  static isUnderlyingInstance(value) {
+    return typeof value === 'bigint'
+  }
+
+  static get ZERO() {
+    return memoizedWrap(0n)
+  }
+
+  static get TEN() {
+    return memoizedWrap(10n)
+  }
+
+  __value__
+
+  constructor(factorySymbol, value) {
+    if (factorySymbol !== FACTORY_SYMBOL) throw new Error('use wrap() instead')
+    this.__value__ = value
+  }
+
+  unwrap() {
+    return this.__value__
+  }
+
+  add(value) {
+    return Wrapper.wrap(this.__value__ + unwrap(value))
+  }
+
+  mutateAdd(value) {
+    this.__value__ += unwrap(value)
+    return this
+  }
+
+  sub(value) {
+    return Wrapper.wrap(this.__value__ - unwrap(value))
+  }
+
+  mutateSub(value) {
+    this.__value__ -= unwrap(value)
+    return this
+  }
+
+  mul(value) {
+    return Wrapper.wrap(this.__value__ * unwrap(value))
+  }
+
+  mutateMul(value) {
+    this.__value__ *= unwrap(value)
+    return this
+  }
+
+  div(value) {
+    return Wrapper.wrap(this.__value__ / unwrap(value))
+  }
+
+  mutateDiv(value) {
+    this.__value__ /= unwrap(value)
+    return this
+  }
+
+  mod(value) {
+    return Wrapper.wrap(this.__value__ % unwrap(value))
+  }
+
+  pow(value) {
+    return Wrapper.wrap(this.__value__ ** unwrap(value))
+  }
+
+  negate() {
+    return Wrapper.wrap(-this.__value__)
+  }
+
+  mutateNegate() {
+    this.__value__ = -this.__value__
+    return this
+  }
+
+  abs() {
+    return this.__value__ < 0n ? Wrapper.wrap(-this.__value__) : this
+  }
+
+  mutateAbs() {
+    if (this.__value__ < 0n) this.__value__ = -this.__value__
+    return this
+  }
+
+  gte(value) {
+    return this.__value__ >= unwrap(value)
+  }
+
+  gt(value) {
+    return this.__value__ > unwrap(value)
+  }
+
+  lte(value) {
+    return this.__value__ <= unwrap(value)
+  }
+
+  lt(value) {
+    return this.__value__ < unwrap(value)
+  }
+
+  eq(value) {
+    return this.__value__ === unwrap(value)
+  }
+
+  isZero() {
+    return this.__value__ === 0n
+  }
+
+  isNegative() {
+    return this.__value__ < 0n
+  }
+
+  isPositive() {
+    return this.__value__ > 0n
+  }
+
+  toString(base) {
+    assert(typeof base === 'number', 'expected number "base"')
+    return this.__value__.toString(base)
+  }
+
+  toNumber() {
+    return Number(this.__value__)
+  }
+
+  #getWidth() {
+    const bitLength = this.__value__.toString(2).length
+    return Math.ceil(bitLength / 8)
+  }
+
+  toBaseBufferLE(width = this.#getWidth()) {
+    const hex = this.__value__.toString(16)
+    const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex')
+    buffer.reverse()
+    return buffer
+  }
+
+  toBaseBufferBE(width = this.#getWidth()) {
+    const hex = this.__value__.toString(16)
+    return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex')
+  }
+}