essential-eth 0.4.6 → 0.4.9-beta.0

package/src/shared/tiny-big/helpers.test.ts

@@ -0,0 +1,30 @@
+import { scientificStrToDecimalStr } from './helpers';
+
+describe('scientificStrToDecimalStr', () => {
+  it('not even scientific', () => {
+    expect(scientificStrToDecimalStr('010')).toBe('10');
+    expect(scientificStrToDecimalStr('-010')).toBe('-10');
+  });
+  it('zero power', () => {
+    expect(scientificStrToDecimalStr('10e0')).toBe('10');
+    expect(scientificStrToDecimalStr('1.0e0')).toBe('1');
+    expect(scientificStrToDecimalStr('-10e-0')).toBe('-10');
+    expect(scientificStrToDecimalStr('-1.0e-0')).toBe('-1');
+    expect(scientificStrToDecimalStr('-1.10e-0')).toBe('-1.1');
+    expect(scientificStrToDecimalStr('-1.e-0')).toBe('-1');
+    expect(scientificStrToDecimalStr('.10e-0')).toBe('0.1');
+    expect(scientificStrToDecimalStr('00.0010e-0')).toBe('0.001');
+  });
+  it('negative power', () => {
+    expect(scientificStrToDecimalStr('0100e-2')).toBe('1');
+    expect(scientificStrToDecimalStr('0100e-4')).toBe('0.01');
+    expect(scientificStrToDecimalStr('010.1e-3')).toBe('0.0101');
+    expect(scientificStrToDecimalStr('-010.1e-3')).toBe('-0.0101');
+    expect(scientificStrToDecimalStr('09.1e-51')).toBe(`0.${'0'.repeat(50)}91`);
+  });
+  it('positive power', () => {
+    expect(scientificStrToDecimalStr('01e2')).toBe('100');
+    expect(scientificStrToDecimalStr('-01e2')).toBe('-100');
+    expect(scientificStrToDecimalStr('09.1e51')).toBe(`91${'0'.repeat(50)}`);
+  });
+});

package/src/shared/tiny-big/helpers.ts

@@ -0,0 +1,89 @@
+// strips both leading and trailing zeroes
+function stripTrailingZeroes(numberString: string) {
+  const isNegative = numberString.startsWith('-');
+  numberString = numberString.replace('-', '');
+
+  numberString = numberString.replace(
+    /\.0*$/g,
+    '' /* for numbers like "1.0" -> "1" */,
+  );
+  numberString = numberString.replace(/^0+/, '');
+  // for numbers like "1.10" -> "1.1"
+  if (numberString.includes('.')) {
+    numberString = numberString.replace(/0+$/, '');
+  }
+  if (numberString.startsWith('.')) {
+    // so that ".1" returns as "0.1"
+    numberString = `0${numberString}`;
+  }
+  return `${isNegative ? '-' : ''}${numberString}`;
+}
+
+export function scientificStrToDecimalStr(scientificString: string): string {
+  // Does not contain "e" nor "E"
+  if (!scientificString.match(/e/i /* lowercase and uppercase E */)) {
+    return stripTrailingZeroes(scientificString);
+  }
+
+  // eslint-disable-next-line prefer-const
+  let [base, power] = scientificString.split(
+    /e/i /* lowercase and uppercase E */,
+  );
+
+  // remove the leading "-" if negative
+  const isNegative = Number(base) < 0;
+  base = base.replace('-', '');
+
+  base = stripTrailingZeroes(base);
+  const [wholeNumber, fraction /* move decimal this many places */ = ''] =
+    base.split('.');
+  if (Number(power) === 0) {
+    return `${isNegative ? '-' : ''}${stripTrailingZeroes(base)}`;
+  } else {
+    const includesDecimal = base.includes('.');
+    if (!includesDecimal) {
+      base = `${base}.`;
+    }
+    base = base.replace('.', '');
+    const baseLength = base.length;
+    let splitPaddedNumber;
+    if (Number(power) < 0) {
+      // move decimal left
+      if (wholeNumber.length < Math.abs(Number(power))) {
+        base = base.padStart(
+          baseLength + Math.abs(Number(power)) - wholeNumber.length,
+          '0',
+        );
+      }
+      splitPaddedNumber = base.split('');
+      if (wholeNumber.length < Math.abs(Number(power))) {
+        // starts with zeroes
+        splitPaddedNumber = ['.', ...splitPaddedNumber];
+      } else {
+        splitPaddedNumber.splice(
+          splitPaddedNumber.length - Math.abs(Number(power)),
+          0,
+          '.',
+        );
+      }
+    } else {
+      // move decimal right
+      if (fraction.length < Math.abs(Number(power))) {
+        base = base.padEnd(
+          baseLength + Math.abs(Number(power)) - fraction.length,
+          '0',
+        );
+      }
+      splitPaddedNumber = base.split('');
+      if (fraction.length > Math.abs(Number(power))) {
+        splitPaddedNumber.splice(
+          splitPaddedNumber.length - Math.abs(Number(power)),
+          0,
+          '.',
+        );
+      }
+    }
+    const toReturn = stripTrailingZeroes(splitPaddedNumber.join(''));
+    return `${isNegative ? '-' : ''}${toReturn}`;
+  }
+}

package/src/shared/tiny-big/tiny-big.test.ts

@@ -0,0 +1,10 @@
+import { tinyBig } from './tiny-big';
+
+describe('tiny-big', () => {
+  it('performs toHexString properly', () => {
+    expect(tinyBig(0).toHexString()).toBe('0x0');
+    expect(tinyBig(1).toHexString()).toBe('0x1');
+    expect(tinyBig(15).toHexString()).toBe('0xf');
+    expect(tinyBig(16).toHexString()).toBe('0x10');
+  });
+});

package/src/shared/tiny-big/tiny-big.ts

@@ -0,0 +1,36 @@
+import Big from 'big.js';
+import { scientificStrToDecimalStr } from './helpers';
+
+/**
+ * A wrapper around big.js which expands scientific notation and creates a "toHexString" function.
+ * This is the return type of every operation on ether, wei, etc.
+ */
+export class TinyBig extends Big {
+  constructor(value: string | number | TinyBig | Big) {
+    super(value);
+  }
+  /**
+   * Used anytime you're passing in "value" to ethers or web3
+   * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
+   */
+  toHexString(): string {
+    return `0x${BigInt(this.toString()).toString(16)}`;
+  }
+  toNumber(): number {
+    return Number(scientificStrToDecimalStr(super.toString()));
+  }
+
+  toString(): string {
+    if (this.toNumber() === 0) {
+      return '0';
+    }
+    return scientificStrToDecimalStr(super.toString());
+  }
+}
+
+/**
+ * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ */
+export function tinyBig(value: string | number | TinyBig | Big): TinyBig {
+  return new TinyBig(value);
+}

package/src/shared/validate-type.ts

@@ -0,0 +1,20 @@
+type JSPrimitiveTypes =
+  | 'string'
+  | 'number'
+  | 'bigint'
+  | 'boolean'
+  | 'symbol'
+  | 'undefined'
+  | 'object'
+  | 'function';
+
+export const validateType = (
+  value: unknown,
+  allowedTypes: JSPrimitiveTypes[],
+) => {
+  if (!allowedTypes.includes(typeof value)) {
+    throw new Error(
+      `${allowedTypes.join(' or ')} required. Received ${typeof value}`,
+    );
+  }
+};

package/src/types/Block.types.ts

@@ -0,0 +1,50 @@
+import { RPCTransaction, Transaction } from './Transaction.types';
+
+export interface Block {
+  baseFeePerGas: string;
+  difficulty: number;
+  extraData: string;
+  gasLimit: number;
+  gasUsed: number;
+  hash: string;
+  logsBloom: string;
+  miner: string;
+  mixHash: string;
+  nonce: string;
+  number: number;
+  parentHash: string;
+  receiptsRoot: string;
+  sha3Uncles: string;
+  size: number;
+  stateRoot: string;
+  timestamp: number;
+  totalDifficulty: number;
+  transactions: string[] | Transaction[];
+  transactionsRoot: string;
+  uncles: unknown[];
+}
+export interface RPCBlock {
+  baseFeePerGas: string;
+  difficulty: string;
+  extraData: string;
+  gasLimit: string;
+  gasUsed: string;
+  hash: string;
+  logsBloom: string;
+  miner: string;
+  mixHash: string;
+  nonce: string;
+  number: string;
+  parentHash: string;
+  receiptsRoot: string;
+  sha3Uncles: string;
+  size: string;
+  stateRoot: string;
+  timestamp: string;
+  totalDifficulty: string;
+  transactions:
+    | Array<string>
+    | Array<RPCTransaction> /* if second arg is true */;
+  transactionsRoot: string;
+  uncles: unknown[];
+}

package/src/types/Contract.types.ts

@@ -0,0 +1,67 @@
+export type ContractTypes =
+  | 'bool'
+  | 'bytes1'
+  | 'bytes2'
+  | 'bytes3'
+  | 'bytes4'
+  | 'bytes5'
+  | 'bytes6'
+  | 'bytes7'
+  | 'bytes8'
+  | 'bytes9'
+  | 'bytes10'
+  | 'bytes11'
+  | 'bytes12'
+  | 'bytes13'
+  | 'bytes14'
+  | 'bytes15'
+  | 'bytes16'
+  | 'bytes17'
+  | 'bytes18'
+  | 'bytes19'
+  | 'bytes20'
+  | 'bytes21'
+  | 'bytes22'
+  | 'bytes23'
+  | 'bytes24'
+  | 'bytes25'
+  | 'bytes26'
+  | 'bytes27'
+  | 'bytes28'
+  | 'bytes29'
+  | 'bytes30'
+  | 'bytes31'
+  | 'bytes32'
+  | 'bytes32[]'
+  | 'address'
+  | 'address payable'
+  | 'address[4]'
+  | 'address[100]'
+  | 'uint256'
+  | 'uint256[100]'
+  | 'uint8'
+  | 'uint32'
+  | string;
+export type ContractInterface = JSONABI;
+export type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
+export interface JSONABIArgument {
+  anonymous?: false;
+  inputs: {
+    internalType?: ContractTypes | string;
+    name: string;
+    type: ContractTypes;
+    indexed?: boolean;
+  }[];
+  name?: string;
+  outputs?: {
+    internalType?: ContractTypes | string;
+    name: string;
+    type: ContractTypes;
+  }[];
+  stateMutability?: 'view' | 'nonpayable' | string;
+  type: 'function' | 'event' | 'constructor' | 'error' | 'fallback';
+  gas?: number;
+  constant?: boolean;
+  payable?: boolean;
+}
+export type JSONABI = JSONABIArgument[];

package/src/types/Network.types.ts

@@ -0,0 +1,8 @@
+/**
+ * A trimmed version of https://chainid.network/chains.json
+ */
+export interface Network {
+  chainId: number;
+  ensAddress: string | null; // ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e';
+  name: string;
+}

package/src/types/Transaction.types.ts

@@ -0,0 +1,35 @@
+export interface Transaction {
+  blockHash: string;
+  blockNumber: number;
+  from: string;
+  gas: number;
+  gasPrice: string;
+  hash: string;
+  input: string;
+  nonce: number;
+  r: string;
+  s: string;
+  to: string;
+  transactionIndex: number;
+  type: number;
+  v: string;
+  value: string;
+}
+
+export interface RPCTransaction {
+  blockHash: string;
+  blockNumber: string;
+  from: string;
+  gas: string;
+  gasPrice: string;
+  hash: string;
+  input: string;
+  nonce: string;
+  r: string;
+  s: string;
+  to: string;
+  transactionIndex: string;
+  type: string;
+  v: string;
+  value: string;
+}

package/{lib/cjs/utils/ether-to-wei.d.ts → src/utils/ether-to-wei.ts}

@@ -1,5 +1,7 @@
 import Big from 'big.js';
-import { TinyBig } from '../shared/tiny-big/tiny-big';
+import { TinyBig, tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+
 /**
  * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
  *
@@ -21,4 +23,10 @@ import { TinyBig } from '../shared/tiny-big/tiny-big';
  * // 1000000000000000000000
  * ```
  */
-export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+export function etherToWei(
+  etherQuantity: string | number | TinyBig | Big,
+): TinyBig {
+  validateType(etherQuantity, ['string', 'number', 'object']);
+  const result = tinyBig(etherQuantity).times('1000000000000000000');
+  return tinyBig(result);
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+import { etherToWei } from './ether-to-wei';
+import { isAddress } from './is-address';
+import { toChecksumAddress } from './to-checksum-address';
+import { weiToEther } from './wei-to-ether';
+
+export { etherToWei, isAddress, toChecksumAddress, weiToEther };

package/src/utils/is-address.ts

@@ -0,0 +1,16 @@
+import { toChecksumAddress } from '..';
+import { validateType } from '../shared/validate-type';
+
+/**
+ * Returns a boolean as to whether the input is a valid address.
+ * Does NOT support ICAP addresses
+ */
+export function isAddress(address: string) {
+  validateType(address, ['string']);
+  try {
+    toChecksumAddress(address);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}

package/src/utils/tests/ether-to-wei.test.ts

@@ -0,0 +1,65 @@
+import Big from 'big.js';
+import * as ethers from 'ethers';
+import web3 from 'web3';
+import { etherToWei, tinyBig } from '../../index';
+import { scientificStrToDecimalStr } from '../../shared/tiny-big/helpers';
+
+describe('ether-to-wei', () => {
+  it('happy path', () => {
+    expect(etherToWei('100').toString()).toBe('100000000000000000000');
+    expect(etherToWei(100).toString()).toBe('100000000000000000000');
+    expect(etherToWei('1000.0').toString()).toBe('1000000000000000000000');
+    expect(etherToWei(1000).toString()).toBe('1000000000000000000000');
+    expect(etherToWei('1000.0').toNumber()).toBe(1000000000000000000000);
+    expect(etherToWei(tinyBig(1000)).toString()).toBe('1000000000000000000000');
+    expect(etherToWei(tinyBig('1000.0')).toNumber()).toBe(
+      1000000000000000000000,
+    );
+    expect(etherToWei(Big(1000)).toString()).toBe('1000000000000000000000');
+    expect(etherToWei(Big('1000.0')).toNumber()).toBe(1000000000000000000000);
+  });
+
+  it('matches ethers and web3 toString', () => {
+    expect(etherToWei('-09999.0').toString()).toStrictEqual(
+      ethers.utils.parseEther('-09999.0').toString(),
+    );
+    expect(etherToWei('-09999.0').toString()).toStrictEqual(
+      web3.utils.toWei('-09999.0', 'ether'),
+    );
+  });
+
+  it('matches ethers and web3 toNumber', () => {
+    /* easy */
+    expect(etherToWei('9').toNumber()).toStrictEqual(
+      Number(ethers.utils.parseEther('9')),
+    );
+    // web3 responds with scientific notation
+    expect(etherToWei('9').toNumber()).toStrictEqual(
+      Number(web3.utils.toWei('9', 'ether')),
+    );
+
+    /* harder */
+    expect(etherToWei('-0999999.90').toNumber()).toStrictEqual(
+      Number(
+        ethers.utils.parseEther('-0999999.90'),
+      ) /* overflow error if you use the ".toNumber()", */,
+    );
+    // web3 responds with scientific notation
+    expect(etherToWei('-0999999.9').toNumber()).toStrictEqual(
+      Number(
+        scientificStrToDecimalStr(web3.utils.toWei('-0999999.9', 'ether')),
+      ),
+    );
+  });
+
+  it('should throw for wrong types', () => {
+    expect(() => {
+      // @ts-expect-error should not accept boolean
+      etherToWei(false);
+    }).toThrow();
+    expect(() => {
+      // @ts-expect-error should not accept array
+      etherToWei([1, 2, 3]);
+    }).toThrow();
+  });
+});

package/src/utils/tests/is-address.test.ts

@@ -0,0 +1,52 @@
+import { utils } from 'ethers';
+import web3 from 'web3';
+import { isAddress } from '../../index';
+
+describe('is-address', () => {
+  it('should validate real addresses', () => {
+    const addresses = [
+      '0x52908400098527886E0F7030069857D2E4169EE7',
+      '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+      '0xde709f2102306220921060314715629080e2fb77',
+      '0x27b1fdb04752bbc536007a920d24acb045561c26',
+      '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+      '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+      '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+      '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+      '27b1fdb04752bbc536007a920d24acb045561c26' /* leading "0x" is not required */,
+    ];
+    addresses.forEach((address) => {
+      expect(isAddress(address)).toStrictEqual(utils.isAddress(address));
+      expect(isAddress(address)).toStrictEqual(web3.utils.isAddress(address));
+    });
+  });
+  it('should return false on invalid addresses', () => {
+    const addresses = [
+      '0x5290840009852',
+      '0x8617E340b3D01FA5F11F306F4090FD50E238070D',
+      '0x8617e340b3d01FA5F11F306F4090FD50E238070D' /* invalid checksum */,
+      ' 0xde709f2102306220921060314715629080e2fb77',
+      'dawsbot.eth' /* ens invalid */,
+      '',
+      'xyz',
+      '0x123',
+    ];
+    addresses.forEach((address) => {
+      const essentialEthIsAddress = isAddress(address);
+      const ethersIsAddress = utils.isAddress(address);
+      const web3IsAddress = web3.utils.isAddress(address);
+      expect(essentialEthIsAddress).toStrictEqual(ethersIsAddress);
+      expect(essentialEthIsAddress).toStrictEqual(web3IsAddress);
+    });
+  });
+  it('invalid type inputs', () => {
+    expect(() => {
+      // @ts-expect-error should not accept boolean
+      isAddress(false);
+    }).toThrow('string required. Received boolean');
+    expect(() => {
+      // @ts-expect-error should not accept array
+      isAddress([1, 2, 3]);
+    }).toThrow('string required. Received object');
+  });
+});

package/src/utils/tests/to-checksum-address.test.ts

@@ -0,0 +1,43 @@
+import { utils } from 'ethers';
+import web3 from 'web3';
+import { toChecksumAddress } from '../../index';
+
+describe('ether-to-wei', () => {
+  it('happy path', () => {
+    const addresses = [
+      '0x52908400098527886E0F7030069857D2E4169EE7',
+      '0x8617E340B3D01FA5F11F306F4090FD50E238070D',
+      '0xde709f2102306220921060314715629080e2fb77',
+      '0x27b1fdb04752bbc536007a920d24acb045561c26',
+      '0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed',
+      '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359',
+      '0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB',
+      '0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb',
+    ];
+    addresses.forEach((address) => {
+      expect(toChecksumAddress(address)).toStrictEqual(
+        utils.getAddress(address),
+      );
+      expect(toChecksumAddress(address)).toStrictEqual(
+        web3.utils.toChecksumAddress(address),
+      );
+    });
+  });
+  it('invalid inputs', () => {
+    const invalidChecksumAddress = '0x8617E340b3D01FA5F11F306F4090FD50E238070D';
+    expect(() => {
+      toChecksumAddress(invalidChecksumAddress);
+    }).toThrow(`Invalid Checksum address for "${invalidChecksumAddress}"`);
+    expect(() => {
+      // @ts-expect-error should not accept boolean
+      toChecksumAddress(false);
+    }).toThrow('string required. Received boolean');
+    expect(() => {
+      // @ts-expect-error should not accept array
+      toChecksumAddress([1, 2, 3]);
+    }).toThrow('string required. Received object');
+    expect(() => {
+      toChecksumAddress('0x1');
+    }).toThrow('Invalid Ethereum address "0x1"');
+  });
+});

package/src/utils/tests/wei-to-ether.test.ts

@@ -0,0 +1,72 @@
+import Big from 'big.js';
+import * as ethers from 'ethers';
+import web3 from 'web3';
+import { tinyBig, weiToEther } from '../../index';
+
+describe('wei-to-ether', () => {
+  it('happy path', () => {
+    expect(weiToEther('100000000000000000000.0').toString()).toBe('100');
+    expect(weiToEther(100000000000000000000.0).toString()).toBe('100');
+    expect(weiToEther('1000000000000000000000.0').toNumber()).toBe(1000);
+    expect(weiToEther(1000000000000000000000.0).toNumber()).toBe(1000);
+
+    expect(weiToEther(tinyBig('1000000000000000000000.0')).toNumber()).toBe(
+      1000,
+    );
+    expect(weiToEther(tinyBig(1000000000000000000000.0)).toNumber()).toBe(1000);
+    expect(weiToEther(Big('1000000000000000000000.0')).toNumber()).toBe(1000);
+    expect(weiToEther(Big(1000000000000000000000.0)).toNumber()).toBe(1000);
+  });
+
+  describe('matches ethers and web3 toString', () => {
+    it('toString', () => {
+      expect(weiToEther('10').toString()).toStrictEqual(
+        ethers.utils.formatEther('10'),
+      );
+      expect(weiToEther('1000000000000000000000').toString()).toBe(
+        '1000',
+        /* returns "1000.0" ethers.utils.formatEther("1000000000000000000000"), */
+      );
+      expect(weiToEther('10').toString()).toStrictEqual(
+        web3.utils.fromWei('10', 'ether'),
+      );
+      expect(weiToEther('1000000000000000000000').toString()).toStrictEqual(
+        web3.utils.fromWei('1000000000000000000000', 'ether'),
+      );
+    });
+
+    it('toNumber', () => {
+      /* easy */
+      expect(weiToEther('9').toNumber()).toStrictEqual(
+        Number(ethers.utils.formatEther('9')),
+      );
+      // expect(weiToEther("9").toNumber()).toStrictEqual(
+      //   Number(ethers.utils.formatEther("9")),
+      // );
+      expect(weiToEther('9').toNumber()).toStrictEqual(
+        Number(web3.utils.fromWei('9', 'ether')),
+      );
+
+      /* hard because they respond with scientific notation or overflowing */
+      expect(weiToEther('999999').toNumber()).toStrictEqual(
+        Number(
+          ethers.utils.formatEther('999999'),
+        ) /* overflow error if you use the ".toNumber()", */,
+      );
+      expect(weiToEther('999999').toNumber()).toStrictEqual(
+        Number(web3.utils.fromWei('999999', 'ether')),
+      );
+    });
+  });
+
+  it('wrong types', () => {
+    expect(() => {
+      // @ts-expect-error should not accept boolean
+      weiToEther(false);
+    }).toThrow();
+    expect(() => {
+      // @ts-expect-error should not accept array
+      weiToEther([1, 2, 3]);
+    }).toThrow();
+  });
+});