essential-eth 0.9.0 → 0.9.1-next.1

package/dist/cjs/utils/tests/bytes/hexlify.test.js

@@ -1,62 +0,0 @@
-import { utils as ethers } from "ethers";
-import { hexlify } from "../../bytes";
-describe("utils.hexlify", function() {
-    it("numbers - matches ethers strings", function() {
-        var decimalValues = [
-            0,
-            4,
-            5,
-            16,
-            BigInt(0),
-            BigInt(16)
-        ];
-        decimalValues.forEach(function(decimalValue) {
-            expect(hexlify(decimalValue)).toBe(ethers.hexlify(decimalValue));
-        });
-        var opts = {
-            allowMissingPrefix: true
-        };
-        expect(hexlify("22", opts)).toBe(ethers.hexlify("22", opts));
-    });
-    it("should match ethers.js - hexPad options", function() {
-        var values = [
-            [
-                "0x3342e95",
-                {
-                    hexPad: "left"
-                }
-            ],
-            [
-                "0x41c942c42",
-                {
-                    hexPad: "right"
-                }
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(hexlify(value[0], value[1])).toBe(ethers.hexlify(value[0], value[1]));
-        });
-    });
-    it("should throw error - hex data is odd-length", function() {
-        var values = [
-            "0x931",
-            "0x34414"
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexlify(value);
-            }).toThrow("hex data is odd-length");
-        });
-    });
-    it("should throw error - invalid hexlify value", function() {
-        var values = [
-            "non-hex string",
-            false
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return hexlify(value);
-            }).toThrow("invalid hexlify value");
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/is-bytes-like.test.js

@@ -1,69 +0,0 @@
-import { utils as ethers } from "ethers";
-import { isBytesLike } from "../../bytes";
-describe("utils.isBytesLike", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
-        });
-    });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                185,
-                203
-            ],
-            [
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
-        });
-    });
-    it("should match ethers.js - number", function() {
-        var values = [
-            152,
-            513,
-            2354
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
-        });
-    });
-    it("should match ethers.js - non-hex string", function() {
-        var values = [
-            "essential-eth",
-            "ethers.js",
-            "ethereum"
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
-        });
-    });
-    it("should match ethers.js - boolean", function() {
-        var values = [
-            false,
-            true
-        ];
-        values.forEach(function(value) {
-            expect(isBytesLike(value)).toBe(ethers.isBytesLike(value));
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/is-bytes.test.js

@@ -1,33 +0,0 @@
-import * as ethers from "ethers";
-import { isBytes, isBytesLike } from "../../..";
-describe("isBytesLike", function() {
-    it("matches ethers", function() {
-        var inputs = [
-            [
-                "1",
-                "2",
-                "3"
-            ],
-            [
-                1,
-                2,
-                3
-            ],
-            "0x123",
-            123,
-            0x123,
-            "bad",
-            false,
-            {
-                test: "bad"
-            },
-            null,
-            new Uint8Array(),
-            new Uint8Array(1)
-        ];
-        inputs.forEach(function(input) {
-            expect(isBytesLike(input)).toBe(ethers.utils.isBytesLike(input));
-            expect(isBytes(input)).toBe(ethers.utils.isBytes(input));
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/is-hex-string.test.js

@@ -1,88 +0,0 @@
-import { utils as ethers } from "ethers";
-import { isHexString } from "../../bytes";
-describe("utils.isHexString", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            "0x9347",
-            "0x185754",
-            "0x00005823"
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
-        });
-    });
-    it("should match ethers.js - hex string of specific length", function() {
-        var values = [
-            [
-                "0x9347",
-                2
-            ],
-            [
-                "0x185754",
-                5
-            ],
-            [
-                "0x00005823",
-                4
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value[0], value[1])).toBe(ethers.isHexString(value[0], value[1]));
-        });
-    });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                185,
-                203
-            ],
-            [
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
-        });
-    });
-    it("should match ethers.js - number", function() {
-        var values = [
-            152,
-            513,
-            2354
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
-        });
-    });
-    it("should match ethers.js - non-hex string", function() {
-        var values = [
-            "essential-eth",
-            "ethers.js",
-            "ethereum"
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
-        });
-    });
-    it("should match ethers.js - boolean", function() {
-        var values = [
-            false,
-            true
-        ];
-        values.forEach(function(value) {
-            expect(isHexString(value)).toBe(ethers.isHexString(value));
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/strip-zeros.test.js

@@ -1,57 +0,0 @@
-import { utils as ethers } from "ethers";
-import { stripZeros } from "../../bytes";
-describe("utils.stripZeros", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            "0x00009347",
-            "0x00185754",
-            "0x00000000005823"
-        ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
-        });
-    });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                0,
-                0,
-                0,
-                9,
-                58,
-                29,
-                24
-            ],
-            [
-                0,
-                185,
-                203
-            ],
-            [
-                0,
-                0,
-                0,
-                0,
-                239,
-                30,
-                49,
-                41,
-                5,
-                10,
-                42
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
-        });
-    });
-    it("should match ethers.js - empty array", function() {
-        var values = [
-            [],
-            "0x"
-        ];
-        values.forEach(function(value) {
-            expect(stripZeros(value)).toStrictEqual(ethers.stripZeros(value));
-        });
-    });
-});

package/dist/cjs/utils/tests/bytes/zero-pad.test.js

@@ -1,80 +0,0 @@
-import { utils as ethers } from "ethers";
-import { zeroPad } from "../../bytes";
-describe("utils.zeroPad", function() {
-    it("should match ethers.js - hex string", function() {
-        var values = [
-            [
-                "0x9347",
-                10
-            ],
-            [
-                "0x185754",
-                5
-            ],
-            [
-                "0x00005823",
-                7
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(zeroPad(value[0], value[1])).toStrictEqual(ethers.zeroPad(value[0], value[1]));
-        });
-    });
-    it("should match ethers.js - UInt8Array", function() {
-        var values = [
-            [
-                [
-                    9,
-                    58,
-                    29,
-                    24
-                ],
-                5
-            ],
-            [
-                [
-                    185,
-                    203
-                ],
-                4
-            ],
-            [
-                [
-                    239,
-                    30,
-                    49,
-                    41,
-                    5,
-                    10,
-                    42
-                ],
-                10
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(zeroPad(value[0], value[1])).toStrictEqual(ethers.zeroPad(value[0], value[1]));
-        });
-    });
-    it("should throw error - value out of range", function() {
-        var values = [
-            [
-                [
-                    9,
-                    58,
-                    29,
-                    24
-                ],
-                3
-            ],
-            [
-                "0x185754",
-                1
-            ]
-        ];
-        values.forEach(function(value) {
-            expect(function() {
-                return zeroPad(value[0], value[1]);
-            }).toThrow("value out of range");
-        });
-    });
-});

package/dist/cjs/utils/tests/compute-address.test.js

@@ -1,27 +0,0 @@
-import { utils } from "ethers";
-import { computeAddress } from "../../index";
-function testComputeAddress(keys) {
-    keys.forEach(function(key) {
-        expect(computeAddress(key)).toBe(utils.computeAddress(key));
-    });
-}
-describe("computeAddress", function() {
-    it("should match ethers.js - public key", function() {
-        var publicKeys = [
-            "0x04aaa2abcf8d119ad68b2c190abf34355a0029197911e2446007d5b44e6fddfd54352326fedac51eca491d59937c592ecffff65c6941037babbe26edfdbb32a688",
-            "0x04e8aa3d196e3a785fb5b431265074c01f571a79231e0cc0fc28e67d9c648471aca8229cafcc6cd806cd1a679f538326577bf9485c68f7a1c90b5116b669f30473",
-            "0x04110dfa471c3f04a6c9dfd857705eb080542c9672cf0f30d95f5fca382181293d6e91320916dd649d03c76818af8e7ee173781888e42e2f00bda9a8f797e0fd61",
-            "0x04593bea29e692123fda1b6f8280b8414524c7838fd448abe6dd1e072bee5e2e9c66e19976b9310ce514d8612c5736201ddc3bb966412076cd4b24e7f649e779b3"
-        ];
-        testComputeAddress(publicKeys);
-    });
-    it("should match ethers.js - private key", function() {
-        var privateKeys = [
-            "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-            "0x42e12f76412f53de9d60df199a368699b6ec15d3798efb0b2a45b8c1b4f902a6",
-            "0x262f8fffb353d3e11be770dd4208dcab1fa5c205d574a78088829f45b1ac2487",
-            "0x1bcfb8b7a46e2f886ef61f8010426f70ce3c7fc1362973aa26d30b8f77711d93"
-        ];
-        testComputeAddress(privateKeys);
-    });
-});

package/dist/cjs/utils/tests/compute-public-key.test.js

@@ -1,15 +0,0 @@
-import { utils } from "ethers";
-import { computePublicKey } from "../../index";
-describe("computePublicKey", function() {
-    it("should match ethers.js", function() {
-        var privateKeys = [
-            "0x8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f",
-            "0x38a3159d73cefd392d0176c29b3cc60ff43e81813f5ab5782571511df9bb16e2",
-            "0xb6d36857e1f9b68e413d2496bb588f3650cdcc2398b3941963c44db8108b8671",
-            "0xf237d9763445d41150f9a199ad93ad478dff29ad8fe6fa00149ed12f40f8eb6f"
-        ];
-        privateKeys.forEach(function(key) {
-            expect(computePublicKey(key)).toBe(utils.computePublicKey(key));
-        });
-    });
-});

package/dist/cjs/utils/tests/ether-to-gwei.test.js

@@ -1,26 +0,0 @@
-import Big from "big.js";
-import { etherToGwei, tinyBig } from "../../index";
-describe("gweiToEther", function() {
-    it("happy path", function() {
-        expect(etherToGwei("100.0").toString()).toBe("100000000000");
-        expect(etherToGwei(100.0).toString()).toBe("100000000000");
-        expect(etherToGwei("0.000000001").toNumber()).toBe(1);
-        expect(etherToGwei(0.000000001).toNumber()).toBe(1);
-        expect(etherToGwei(tinyBig(1000)).toNumber()).toBe(1000000000000);
-        expect(etherToGwei(Big(0.000000001)).toNumber()).toBe(1);
-    });
-    it("wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            etherToGwei(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            etherToGwei([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

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

@@ -1,44 +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", function() {
-    it("happy path", function() {
-        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", function() {
-        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", function() {
-        /* 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")));
-        // 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", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            etherToWei(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            etherToWei([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

package/dist/cjs/utils/tests/gwei-to-ether.test.js

@@ -1,28 +0,0 @@
-import Big from "big.js";
-import { gweiToEther, tinyBig } from "../../index";
-describe("gweiToEther", function() {
-    it("happy path", function() {
-        expect(gweiToEther("100000000000.0").toString()).toBe("100");
-        expect(gweiToEther(100000000000.0).toString()).toBe("100");
-        expect(gweiToEther("1000000000000.0").toNumber()).toBe(1000);
-        expect(gweiToEther(1000000000000.0).toNumber()).toBe(1000);
-        expect(gweiToEther(tinyBig("1000000000000.0")).toNumber()).toBe(1000);
-        expect(gweiToEther(tinyBig(1000000000000.0)).toNumber()).toBe(1000);
-        expect(gweiToEther(Big("1000000000000.0")).toNumber()).toBe(1000);
-        expect(gweiToEther(Big(1000000000000.0)).toNumber()).toBe(1000);
-    });
-    it("wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            gweiToEther(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            gweiToEther([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});

package/dist/cjs/utils/tests/hash-message.test.js

@@ -1,21 +0,0 @@
-import { utils } from "ethers";
-import { hashMessage } from "../../index";
-describe("utils.hashMessage", function() {
-    it("should match ethers.js", function() {
-        var messages = [
-            "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb",
-            "27b1fdb04752bbc536007a920d24acb045561c26" /* leading "0x" is not required */ ,
-            [
-                1,
-                2
-            ],
-            [
-                0x1,
-                0x2
-            ]
-        ];
-        messages.forEach(function(message) {
-            expect(hashMessage(message)).toStrictEqual(utils.hashMessage(message));
-        });
-    });
-});

package/dist/cjs/utils/tests/is-address.test.js

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