Provide a more declarative BigNumber constructor that accepts scientific notation

[PaulRBerg]

I find myself frequently redeclaring the following function in my Ethereum-related projects:

import { BigNumber } from "@ethersproject/bignumber";
import fromExponential from "from-exponential";

export function bn(x: string): BigNumber {
  let xs: string = x;
  if (x.includes("e")) {
    xs = fromExponential(x);
  }
  return BigNumber.from(xs);
}

Getting this out-of-the-box with the @ethersproject/bignumber package would be great. It would be especially useful for making tests more declarative:

import { bn } from "@ethersproject/bignumber";

it("...", async function() {
  const balance = await this.contracts.foo.balanceOf(...);
  expect(balance).to.equal(bn("1e21"));
}

[ricmoo]

This is a good place to start on the history of exponents support. :)

The above code is not safe, as it would break BigNumber.from("0xe") which should return the big number equivalent to 14.

It isn’t an easy task, as the parsing is actually quite non-trivial and EIP-681 wasn’t well defined at the time for some cases. I can look into it again though.

It won’t go on BigNumber though, it would likely be part of FixedNumber, since it has an implied fixed format and fractional component. Maybe there can be some shortcut for the purposes of BigNumber though. I would have to think what the API should look like.

Currently the above could be done using pasreUnits("1", 21) or better yet parseUnits("1000", 18) which better demonstrates your test case is expecting 1000 units of an 18 decimal quantity. The 18 is optional as parseUnits is by default 18, you could also use the string "ether" or the parseEther Function directly. Just a suggestion though.

[ricmoo]

You could also go the other direction, formatEther(balance) == "1000.0" which feels more obvious what the test case is expecting. Or however that works with dot notation syntax of your test framework. :)

[PaulRBerg]

Oh, I've actually already rolled my own solution for the problem "how to declaratively work with fixed-point numbers that should be multiplied by 1e18". See evm-fp (it uses parseFixed under the hood, and it returns a BigNumber after the parsing!).

The reason I opened this discussion was precisely that I needed a function that doesn't multiply by any number of units - just that it accepts a string that could be a base 10 number (in exponential notation or not) and it returns an instance of BigNumber.

Some food for thought: maybe there is room for a new class ExponentialNumber that inherits from BigNumber? Or another method called fromExp on the BigNumber class? This way, you would be specific about the scope. Users would intuit that the constructor would throw an error if the input is not in base 10 exponential notation.