essential-eth 0.2.2 → 0.3.3

package/lib/cjs/classes/test/Contract/uni.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const contracts_1 = require("@ethersproject/contracts");
+const ethers_1 = require("ethers");
+const JsonRpcProvider_1 = require("../../../providers/JsonRpcProvider");
+const Contract_1 = require("../../Contract");
+const uniswap_abi_1 = require("./uniswap-abi");
+// The JSONABI
+const JSONABI = uniswap_abi_1.uniswapABI;
+const rpcURL = 'https://free-eth-node.com/api/eth';
+const ethersProvider = (0, ethers_1.getDefaultProvider)(rpcURL);
+const essentialEthProvider = new JsonRpcProvider_1.JsonRpcProvider(rpcURL);
+// The UNI airdrop merkle address
+// https://etherscan.io/address/0x090D4613473dEE047c3f2706764f49E0821D256e#readContract
+const contractAddress = '0x090D4613473dEE047c3f2706764f49E0821D256e';
+const smartContractIsUniClaimed = (contract, index) => __awaiter(void 0, void 0, void 0, function* () {
+    const isClaimed = (yield contract.isClaimed(index));
+    return isClaimed;
+});
+const smartContractGetUniMerkleRoot = (contract) => __awaiter(void 0, void 0, void 0, function* () {
+    const merkleRoot = (yield contract.merkleRoot());
+    return merkleRoot;
+});
+const smartContractGetUniTokenAddress = (contract) => __awaiter(void 0, void 0, void 0, function* () {
+    const merkleRoot = (yield contract.token());
+    return merkleRoot;
+});
+const ethersContract = new contracts_1.Contract(contractAddress, JSONABI, ethersProvider);
+const essentialEthContract = new Contract_1.Contract(contractAddress, JSONABI, essentialEthProvider);
+describe('UNI contract', () => {
+    it('should fetch "address" data-type', () => __awaiter(void 0, void 0, void 0, function* () {
+        const [ethersResponse, essentialEthResponse] = yield Promise.all([
+            smartContractGetUniTokenAddress(ethersContract),
+            smartContractGetUniTokenAddress(essentialEthContract),
+        ]);
+        /* 0x1f9840a85d5af5bf1d1762f925bdaddc4201f984 */
+        expect(ethersResponse).toStrictEqual(essentialEthResponse);
+    }));
+    it('should fetch "bytes32" merkle root', () => __awaiter(void 0, void 0, void 0, function* () {
+        const [ethersResponse, essentialEthResponse] = yield Promise.all([
+            smartContractGetUniMerkleRoot(ethersContract),
+            smartContractGetUniMerkleRoot(essentialEthContract),
+        ]);
+        /* 0xc8500f8e2fcf3c9a32880e1b973fb28acc88be35787a8abcf9981b2b65dbdeb5 */
+        expect(ethersResponse).toStrictEqual(essentialEthResponse);
+    }));
+    it('should fetch isClaimed "boolean" for random airdrop indexes', () => __awaiter(void 0, void 0, void 0, function* () {
+        /* indexes of addresses in the merkle tree */
+        const randomIndexes = [0, 4, 102, 999, 999999];
+        for (const i of randomIndexes) {
+            const [ethersClaimed, essentialEthClaimed] = yield Promise.all([
+                smartContractIsUniClaimed(ethersContract, i),
+                smartContractIsUniClaimed(essentialEthContract, i),
+            ]);
+            expect(ethersClaimed).toStrictEqual(essentialEthClaimed);
+        }
+    }));
+});

package/lib/cjs/classes/test/Contract/uniswap-abi.d.ts

@@ -0,0 +1,2 @@
+import { JSONABI } from '../../../types/Contract.types';
+export declare const uniswapABI: JSONABI;

package/lib/cjs/classes/test/Contract/uniswap-abi.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniswapABI = void 0;
+exports.uniswapABI = 
+// http://api.etherscan.io/api?module=contract&action=getabi&address=0x090d4613473dee047c3f2706764f49e0821d256e&format=raw
+[
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'token_',
+                type: 'address',
+            },
+            {
+                internalType: 'bytes32',
+                name: 'merkleRoot_',
+                type: 'bytes32',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'constructor',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+            {
+                indexed: false,
+                internalType: 'address',
+                name: 'account',
+                type: 'address',
+            },
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'Claimed',
+        type: 'event',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+            {
+                internalType: 'address',
+                name: 'account',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+            {
+                internalType: 'bytes32[]',
+                name: 'merkleProof',
+                type: 'bytes32[]',
+            },
+        ],
+        name: 'claim',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'index',
+                type: 'uint256',
+            },
+        ],
+        name: 'isClaimed',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'merkleRoot',
+        outputs: [
+            {
+                internalType: 'bytes32',
+                name: '',
+                type: 'bytes32',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'token',
+        outputs: [
+            {
+                internalType: 'address',
+                name: '',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];

package/lib/cjs/classes/utils/encode-decode-transaction.d.ts

@@ -0,0 +1,3 @@
+import { JSONABIArgument } from '../../types/Contract.types';
+export declare function encodeData(jsonABIArgument: JSONABIArgument, args: any[]): string;
+export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../..").TinyBig | (string | number | boolean | import("../..").TinyBig)[];

package/lib/cjs/classes/utils/encode-decode-transaction.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeRPCResponse = exports.encodeData = void 0;
+const sha3_1 = require("sha3");
+const __1 = require("../..");
+const hex_to_decimal_1 = require("./hex-to-decimal");
+const hexTrue = '0000000000000000000000000000000000000000000000000000000000000001';
+const hexFalse = '0000000000000000000000000000000000000000000000000000000000000000';
+function expandType(type) {
+    // https://docs.soliditylang.org/en/v0.8.7/types.html#integers
+    if (type === 'uint[]') {
+        return 'uint256[]';
+    }
+    else if (type === 'int[]') {
+        return 'int256[]';
+    }
+    return type;
+}
+function encodeData(jsonABIArgument, args) {
+    const hash = new sha3_1.Keccak(256);
+    /* first 4 bytes will create the data parameter */
+    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
+    // encoding learnt from https://ethereum.stackexchange.com/questions/3514/how-to-call-a-contract-method-using-the-eth-call-json-rpc-api
+    const functionHash = hash.update(functionString).digest('hex');
+    // no arrays
+    const jsonABIInputsLength = jsonABIArgument.inputs.length;
+    let shouldValidateInputLength = true;
+    // inputs contains 1 or more arrays
+    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
+        shouldValidateInputLength = false;
+    }
+    if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
+        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`);
+    }
+    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
+        var _a;
+        if (input.type.includes('[')) {
+            // strip array and length like "[2]" from type
+            const basicType = (_a = /([^[]*)\[.*$/g.exec(input.type)) === null || _a === void 0 ? void 0 : _a[1];
+            args.forEach((arg) => {
+                acc = acc.concat([[arg, basicType]]);
+            });
+            return acc;
+        }
+        else {
+            return acc.concat([[args[i], input.type]]);
+        }
+    }, []);
+    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
+        let rawArg = arg;
+        if (inputType === 'bool') {
+            return arg ? hexTrue : hexFalse;
+        }
+        else if (inputType.startsWith('bytes')) {
+            // encode each character to hex
+            const argEncoded = rawArg
+                .split('')
+                .map((character) => character.charCodeAt(0).toString(16))
+                .join('');
+            const paddedEncodedArg = argEncoded.padEnd(64, '0');
+            return paddedEncodedArg;
+        }
+        // remove leading "0x" on address types
+        else if (inputType === 'address') {
+            rawArg = arg.replace(/^0x/g, '').toLowerCase();
+        }
+        const argEncoded = rawArg.toString(16);
+        const paddedEncodedArg = argEncoded.padStart(64, '0');
+        return paddedEncodedArg;
+    });
+    const functionEncoded = functionHash.slice(0, 8);
+    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
+    return data;
+}
+exports.encodeData = encodeData;
+function decodeRPCResponse(jsonABIArgument, nodeResponse) {
+    const rawOutputs = jsonABIArgument.outputs;
+    // chunk response every 64 characters
+    const encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
+    const outputs = (encodedOutputs || []).map((output, i) => {
+        const outputType = (rawOutputs || [])[i].type;
+        switch (outputType) {
+            case 'bool':
+                return output === hexTrue;
+            case 'address':
+                /* address types have 26 leading zeroes to remove */
+                return (0, __1.toChecksumAddress)(`0x${output.slice(24)}`);
+            case 'uint256':
+                return (0, __1.tinyBig)((0, hex_to_decimal_1.hexToDecimal)(`0x${output}`));
+            case 'bytes32':
+                return `0x${output}`;
+            case 'uint8':
+                return Number((0, hex_to_decimal_1.hexToDecimal)(`0x${output}`));
+            default:
+                throw new Error(`essential-eth does not yet support "${outputType}" inputs. Make a PR today!"`);
+        }
+    });
+    return outputs.length === 1 ? outputs[0] : outputs;
+}
+exports.decodeRPCResponse = decodeRPCResponse;

package/lib/cjs/classes/utils/fetchers.d.ts

@@ -0,0 +1,9 @@
+export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
+declare type RPCMethodName = 'eth_getBlockByNumber' | 'eth_call';
+export declare function buildRPCPostBody(method: RPCMethodName, params: any[]): {
+    jsonrpc: string;
+    id: number;
+    method: RPCMethodName;
+    params: any[];
+};
+export {};

package/lib/cjs/{rpc → classes}/utils/fetchers.js

@@ -12,7 +12,14 @@ function post(url, body) {
             'Content-Type': 'application/json',
         },
         body: JSON.stringify(body),
-    }).then((r) => r.json());
+    })
+        .then((r) => r.json())
+        .then((response) => {
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return response.result;
+    });
 }
 exports.post = post;
 function buildRPCPostBody(method, params) {

package/lib/cjs/index.d.ts

@@ -1,7 +1,11 @@
-import { etherToWei } from './ether-to-wei';
-import { isAddress } from './is-address';
-import { EssentialEth } from './rpc/index';
+import { Transaction } from 'ethers';
+import { Contract } from './classes/Contract';
+import { JsonRpcProvider, jsonRpcProvider } from './providers/JsonRpcProvider';
 import { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-import { toChecksumAddress } from './to-checksum-address';
-import { weiToEther } from './wei-to-ether';
-export { toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, EssentialEth, };
+import { Block } from './types/block.types';
+import { JSONABI, JSONABIArgument } from './types/Contract.types';
+import { etherToWei } from './utils/ether-to-wei';
+import { isAddress } from './utils/is-address';
+import { toChecksumAddress } from './utils/to-checksum-address';
+import { weiToEther } from './utils/wei-to-ether';
+export { jsonRpcProvider, JsonRpcProvider, toChecksumAddress, isAddress, etherToWei, weiToEther, tinyBig, TinyBig, Contract, JSONABI, Block, JSONABIArgument, Transaction, };

package/lib/cjs/index.js

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EssentialEth = exports.TinyBig = exports.tinyBig = exports.weiToEther = exports.etherToWei = exports.isAddress = exports.toChecksumAddress = void 0;
-const ether_to_wei_1 = require("./ether-to-wei");
-Object.defineProperty(exports, "etherToWei", { enumerable: true, get: function () { return ether_to_wei_1.etherToWei; } });
-const is_address_1 = require("./is-address");
-Object.defineProperty(exports, "isAddress", { enumerable: true, get: function () { return is_address_1.isAddress; } });
-const index_1 = require("./rpc/index");
-Object.defineProperty(exports, "EssentialEth", { enumerable: true, get: function () { return index_1.EssentialEth; } });
+exports.Contract = exports.TinyBig = exports.tinyBig = exports.weiToEther = exports.etherToWei = exports.isAddress = exports.toChecksumAddress = exports.JsonRpcProvider = exports.jsonRpcProvider = void 0;
+const Contract_1 = require("./classes/Contract");
+Object.defineProperty(exports, "Contract", { enumerable: true, get: function () { return Contract_1.Contract; } });
+const JsonRpcProvider_1 = require("./providers/JsonRpcProvider");
+Object.defineProperty(exports, "JsonRpcProvider", { enumerable: true, get: function () { return JsonRpcProvider_1.JsonRpcProvider; } });
+Object.defineProperty(exports, "jsonRpcProvider", { enumerable: true, get: function () { return JsonRpcProvider_1.jsonRpcProvider; } });
 const tiny_big_1 = require("./shared/tiny-big/tiny-big");
 Object.defineProperty(exports, "tinyBig", { enumerable: true, get: function () { return tiny_big_1.tinyBig; } });
 Object.defineProperty(exports, "TinyBig", { enumerable: true, get: function () { return tiny_big_1.TinyBig; } });
-const to_checksum_address_1 = require("./to-checksum-address");
+const ether_to_wei_1 = require("./utils/ether-to-wei");
+Object.defineProperty(exports, "etherToWei", { enumerable: true, get: function () { return ether_to_wei_1.etherToWei; } });
+const is_address_1 = require("./utils/is-address");
+Object.defineProperty(exports, "isAddress", { enumerable: true, get: function () { return is_address_1.isAddress; } });
+const to_checksum_address_1 = require("./utils/to-checksum-address");
 Object.defineProperty(exports, "toChecksumAddress", { enumerable: true, get: function () { return to_checksum_address_1.toChecksumAddress; } });
-const wei_to_ether_1 = require("./wei-to-ether");
+const wei_to_ether_1 = require("./utils/wei-to-ether");
 Object.defineProperty(exports, "weiToEther", { enumerable: true, get: function () { return wei_to_ether_1.weiToEther; } });

package/lib/cjs/{rpc/index.d.ts → providers/JsonRpcProvider.d.ts}

@@ -1,5 +1,5 @@
 import { Block } from '../types/block.types';
-export declare class EssentialEth {
+export declare class JsonRpcProvider {
     /**
      * The URL to your Eth node. Consider POKT or Infura
      */
@@ -10,3 +10,7 @@ export declare class EssentialEth {
      */
     getBlock(timeFrame: 'latest' | 'earliest' | 'pending' | number, returnTransactionObjects?: boolean): Promise<Block>;
 }
+/**
+ * Helper function to avoid "new"
+ */
+export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/lib/cjs/{rpc/index.js → providers/JsonRpcProvider.js}

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EssentialEth = void 0;
-const clean_block_1 = require("./utils/clean-block");
-const fetchers_1 = require("./utils/fetchers");
-class EssentialEth {
+exports.jsonRpcProvider = exports.JsonRpcProvider = void 0;
+const clean_block_1 = require("../classes/utils/clean-block");
+const fetchers_1 = require("../classes/utils/fetchers");
+class JsonRpcProvider {
     constructor(rpcUrl) {
         this._rpcUrl = rpcUrl || 'https://free-eth-node.com/api/eth';
     }
@@ -30,12 +30,19 @@ class EssentialEth {
                 // "latest", "earliest", and "pending" require no manipulation
                 rpcTimeFrame = timeFrame;
             }
-            const nodeResponse = yield (0, fetchers_1.post)(this._rpcUrl, (0, fetchers_1.buildRPCPostBody)('eth_getBlockByNumber', [
+            const nodeResponse = (yield (0, fetchers_1.post)(this._rpcUrl, (0, fetchers_1.buildRPCPostBody)('eth_getBlockByNumber', [
                 rpcTimeFrame,
                 returnTransactionObjects,
-            ])).then((data) => data.result);
+            ])));
             return (0, clean_block_1.cleanBlock)(nodeResponse, returnTransactionObjects);
         });
     }
 }
-exports.EssentialEth = EssentialEth;
+exports.JsonRpcProvider = JsonRpcProvider;
+/**
+ * Helper function to avoid "new"
+ */
+function jsonRpcProvider(rpcUrl) {
+    return new JsonRpcProvider(rpcUrl);
+}
+exports.jsonRpcProvider = jsonRpcProvider;

package/lib/cjs/shared/tiny-big/tiny-big.d.ts

@@ -4,11 +4,11 @@ import Big from 'big.js';
  * The only important things to know are the "toString" and "toNumber" functions
  */
 export declare class TinyBig extends Big {
-    constructor(value: number | string);
+    constructor(value: number | string | TinyBig);
     toNumber(): number;
     toString(): string;
 }
 /**
  * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
  */
-export declare function tinyBig(value: number | string): TinyBig;
+export declare function tinyBig(value: number | string | TinyBig): TinyBig;

package/lib/cjs/types/Contract.types.d.ts

@@ -0,0 +1,22 @@
+export declare 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 declare type ContractInterface = JSONABI;
+export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
+export declare type 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';
+    gas?: number;
+};
+export declare type JSONABI = JSONABIArgument[];

package/lib/cjs/types/Contract.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,5 @@
-import { TinyBig } from './shared/tiny-big/tiny-big';
+import Big from 'big.js';
+import { TinyBig } from '../shared/tiny-big/tiny-big';
 /**
  * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
  *
@@ -20,4 +21,4 @@ import { TinyBig } from './shared/tiny-big/tiny-big';
  * // 1000000000000000000000
  * ```
  */
-export declare function etherToWei(etherQuantity: string | number): TinyBig;
+export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/cjs/{ether-to-wei.js → utils/ether-to-wei.js}

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.etherToWei = void 0;
-const big_js_1 = __importDefault(require("big.js"));
-const tiny_big_1 = require("./shared/tiny-big/tiny-big");
-const validate_type_1 = require("./shared/validate-type");
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const validate_type_1 = require("../shared/validate-type");
 /**
  * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
  *
@@ -29,8 +25,8 @@ const validate_type_1 = require("./shared/validate-type");
  * ```
  */
 function etherToWei(etherQuantity) {
-    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number']);
-    const result = (0, big_js_1.default)(etherQuantity).times('1000000000000000000').toString();
+    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number', 'object']);
+    const result = (0, tiny_big_1.tinyBig)(etherQuantity).times('1000000000000000000');
     return (0, tiny_big_1.tinyBig)(result);
 }
 exports.etherToWei = etherToWei;

package/lib/cjs/{is-address.js → utils/is-address.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAddress = void 0;
-const _1 = require(".");
-const validate_type_1 = require("./shared/validate-type");
+const __1 = require("..");
+const validate_type_1 = require("../shared/validate-type");
 /**
  * Returns a boolean as to whether the input is a valid address.
  * Does NOT support ICAP addresses
@@ -10,7 +10,7 @@ const validate_type_1 = require("./shared/validate-type");
 function isAddress(address) {
     (0, validate_type_1.validateType)(address, ['string']);
     try {
-        (0, _1.toChecksumAddress)(address);
+        (0, __1.toChecksumAddress)(address);
         return true;
     }
     catch (error) {

package/lib/cjs/utils/tests/ether-to-wei.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/cjs/utils/tests/ether-to-wei.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const big_js_1 = __importDefault(require("big.js"));
+const ethers = __importStar(require("ethers"));
+const web3_1 = __importDefault(require("web3"));
+const index_1 = require("../../index");
+const helpers_1 = require("../../shared/tiny-big/helpers");
+describe('ether-to-wei', () => {
+    it('happy path', () => {
+        expect((0, index_1.etherToWei)('100').toString()).toStrictEqual('100000000000000000000');
+        expect((0, index_1.etherToWei)(100).toString()).toStrictEqual('100000000000000000000');
+        expect((0, index_1.etherToWei)('1000.0').toString()).toStrictEqual('1000000000000000000000');
+        expect((0, index_1.etherToWei)(1000).toString()).toStrictEqual('1000000000000000000000');
+        expect((0, index_1.etherToWei)('1000.0').toNumber()).toStrictEqual(1000000000000000000000);
+        expect((0, index_1.etherToWei)((0, index_1.tinyBig)(1000)).toString()).toStrictEqual('1000000000000000000000');
+        expect((0, index_1.etherToWei)((0, index_1.tinyBig)('1000.0')).toNumber()).toStrictEqual(1000000000000000000000);
+        expect((0, index_1.etherToWei)((0, big_js_1.default)(1000)).toString()).toStrictEqual('1000000000000000000000');
+        expect((0, index_1.etherToWei)((0, big_js_1.default)('1000.0')).toNumber()).toStrictEqual(1000000000000000000000);
+    });
+    it('matches ethers and web3 toString', () => {
+        expect((0, index_1.etherToWei)('-09999.0').toString()).toStrictEqual(ethers.utils.parseEther('-09999.0').toString());
+        expect((0, index_1.etherToWei)('-09999.0').toString()).toStrictEqual(web3_1.default.utils.toWei('-09999.0', 'ether'));
+    });
+    it('matches ethers and web3 toNumber', () => {
+        /* easy */
+        expect((0, index_1.etherToWei)('9').toNumber()).toStrictEqual(Number(ethers.utils.parseEther('9')));
+        // web3 responds with scientific notation
+        expect((0, index_1.etherToWei)('9').toNumber()).toStrictEqual(Number(web3_1.default.utils.toWei('9', 'ether')));
+        /* harder */
+        expect((0, index_1.etherToWei)('-0999999.90').toNumber()).toStrictEqual(Number(ethers.utils.parseEther('-0999999.90')) /* overflow error if you use the ".toNumber()", */);
+        // web3 responds with scientific notation
+        expect((0, index_1.etherToWei)('-0999999.9').toNumber()).toStrictEqual(Number((0, helpers_1.scientificStrToDecimalStr)(web3_1.default.utils.toWei('-0999999.9', 'ether'))));
+    });
+    it('wrong types', () => {
+        expect(() => {
+            // @ts-expect-error should not accept boolean
+            (0, index_1.etherToWei)(false);
+        }).toThrow();
+        expect(() => {
+            // @ts-expect-error should not accept array
+            (0, index_1.etherToWei)([1, 2, 3]);
+        }).toThrow();
+    });
+});

package/lib/cjs/utils/tests/is-address.test.d.ts

@@ -0,0 +1 @@
+export {};