essential-eth 0.6.2 → 0.8.0

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

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

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

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

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

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

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

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

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

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

package/dist/cjs/utils/tests/keccak256.test.js

@@ -0,0 +1,97 @@
+import { utils } from "ethers";
+import { keccak256 } from "./../keccak256";
+import { toUtf8Bytes } from "./../to-utf8-bytes";
+/**
+ *
+ * @param inputs
+ */ function testKeccak256(inputs) {
+    inputs.forEach(function(input) {
+        expect(keccak256(input)).toBe(utils.keccak256(input));
+    });
+}
+describe("keccak256", function() {
+    it("should match ethers.js hex strings", function() {
+        var inputs = [
+            "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb",
+            "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
+            "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
+        ];
+        testKeccak256(inputs);
+    });
+    it("should match ethers.js bytes", function() {
+        var inputs = [
+            [
+                2,
+                182,
+                145
+            ],
+            [
+                0,
+                16,
+                255
+            ],
+            [
+                0x12,
+                0x34
+            ],
+            [
+                0x12
+            ]
+        ];
+        testKeccak256(inputs);
+    });
+    it("should match ethers.js numbers", function() {
+        var inputs = [
+            23874234,
+            123346,
+            12395712
+        ].map(function(n) {
+            return toUtf8Bytes(n.toString());
+        });
+        testKeccak256(inputs);
+    });
+    it("should match ethers.js strings", function() {
+        var inputs = [
+            "essential-eth",
+            "firstText",
+            "secondString",
+            "example1",
+            "2934823",
+            "true"
+        ].map(toUtf8Bytes);
+        testKeccak256(inputs);
+    });
+// it('should match ethers.js bytes (dynamic size) & BytesLike', () => {
+//   const inputs = [
+//     [115, 101, 99, 114, 101, 116],
+//     ['0x62797465734c696b65'],
+//     '0x657373656e7469616c2d657468',
+//     [115, 109, 97, 108, 108, 101, 115, 116],
+//   ];
+//   testKeccak256(inputs);
+// });
+// it('should match ethers.js bytes (static size)', () => {
+//   const inputs = [
+//     { types: ['bytes4'], values: [[116, 101, 115, 116]] },
+//     {
+//       types: ['bytes13', 'bytes1', 'bytes2', 'bytes5', 'bytes1'],
+//       values: [
+//         [101, 115, 115, 101, 110, 116, 105, 97, 108, 45, 101, 116, 104],
+//         [32],
+//         [105, 115],
+//         [103, 114, 101, 97, 116],
+//         [33],
+//       ],
+//     },
+//   ];
+//   testKeccak256(inputs);
+// });
+// it('should match ethers.js (signed and unsigned) integers', () => {
+//   const inputs = [
+//     { types: ['int16'], values: [-1] },
+//     { types: ['uint48'], values: [12] },
+//     { types: ['int16', 'uint48'], values: [-1, 12] },
+//   ];
+//   testKeccak256(inputs);
+// });
+});