essential-eth 0.4.9-beta.0 → 0.4.9-beta.3

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

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

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

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

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

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

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

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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-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/src/utils/is-address.ts

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

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

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

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

@@ -1,72 +0,0 @@
-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();
-  });
-});

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

@@ -1,47 +0,0 @@
-import { Keccak } from 'sha3';
-import { validateType } from '../shared/validate-type';
-
-/**
- * Returns an Ethereum address in proper mixed-case checksum.
- * Does NOT support ICAP
- *
- * @param address - An Ethereum address. Mixed, lower, and uppercase are all valid
- *
- * @example
- * ```javascript
- * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');
- * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
- * ```
- *
- * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v4/api-utils.html#utils-getaddress)
- *
- * Similar to ["toChecksumAddress" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#tochecksumaddress)
- */
-export function toChecksumAddress(address: string) {
-  validateType(address, ['string']);
-  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-    throw new Error(`Invalid Ethereum address "${address}"`);
-  }
-
-  const _address = address.toLowerCase().replace(/^0x/i, '');
-  const keccak = new Keccak(256);
-  const addressHash = keccak.update(_address).digest('hex').replace(/^0x/i, '');
-  let checksumAddress = '0x';
-
-  for (let i = 0; i < _address.length; i++) {
-    // If ith character is 8 to f then make it uppercase
-    if (parseInt(addressHash[i], 16) > 7) {
-      checksumAddress += _address[i].toUpperCase();
-    } else {
-      checksumAddress += _address[i];
-    }
-  }
-
-  if (
-    address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) &&
-    checksumAddress !== address
-  ) {
-    throw new Error(`Invalid Checksum address for "${address}"`);
-  }
-  return checksumAddress;
-}

package/test/global-setup.js

@@ -1,8 +0,0 @@
-const { setup } = require('jest-dev-server');
-
-module.exports = async function globalSetup() {
-  await setup({
-    command: `node test/server`,
-    launchTimeout: 10000,
-  });
-};

package/test/global-teardown.js

@@ -1,5 +0,0 @@
-const { teardown } = require('jest-dev-server');
-
-module.exports = async function globalTeardown() {
-  await teardown();
-};

package/test/jest.setup-after-env.js

@@ -1 +0,0 @@
-jest.setTimeout(10000);