essential-eth 0.9.1-next.0 → 0.9.1

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

@@ -1,311 +0,0 @@
-import { solidityKeccak256 } from "../../index";
-/**
- *
- * @param inputs
- */ function testSolidityKeccak256(inputs) {
-    inputs.forEach(function(input) {
-        expect(solidityKeccak256(input.types, input.values)).toBe(input.expected);
-    });
-}
-describe("solidityKeccak256", function() {
-    it("should match expected hash - addresses", function() {
-        var inputs = [
-            {
-                types: [
-                    "address"
-                ],
-                values: [
-                    "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb"
-                ],
-                expected: "0x72fe4a1287bb827ec8d04e045f7559955a8e694063af513008f111670674178a"
-            },
-            {
-                types: [
-                    "address",
-                    "address"
-                ],
-                values: [
-                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
-                    "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
-                ],
-                expected: "0x36020dd625e805ec80eb7c7e36e5b69108500af4bb4913245a3d643d33466581"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match expected hash - strings", function() {
-        var inputs = [
-            {
-                types: [
-                    "string"
-                ],
-                values: [
-                    "essential-eth"
-                ],
-                expected: "0xd5b027dc2bddae7475604f19ca210363f0a3c63a32d79c2fff540b9c21249f2c"
-            },
-            {
-                types: [
-                    "string",
-                    "string"
-                ],
-                values: [
-                    "firstText",
-                    "secondString"
-                ],
-                expected: "0xf9b3d91668a0f53719a929eb38ac29b07896b3a33ef806cfbe5033bb5ce1e58b"
-            },
-            {
-                types: [
-                    "string",
-                    "string",
-                    "string"
-                ],
-                values: [
-                    "example1",
-                    "2934823",
-                    "true"
-                ],
-                expected: "0x731e3313bb527075d72c8a724eea170cdc200edf65c958d3014f666faf9a4d41"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match expected hash for bytes (dynamic size) & BytesLike", function() {
-        var inputs = [
-            {
-                types: [
-                    "bytes"
-                ],
-                values: [
-                    [
-                        115,
-                        101,
-                        99,
-                        114,
-                        101,
-                        116
-                    ]
-                ],
-                expected: "0x65462b0520ef7d3df61b9992ed3bea0c56ead753be7c8b3614e0ce01e4cac41b"
-            },
-            {
-                types: [
-                    "bytes"
-                ],
-                values: [
-                    "0x62797465734c696b65"
-                ],
-                expected: "0x89ddb668afdb92cd9027c2ecf8ef3f36f2a76d07f72db32f17be6ddd5552abfb"
-            },
-            {
-                types: [
-                    "bytes",
-                    "bytes"
-                ],
-                values: [
-                    "0x657373656e7469616c2d657468",
-                    [
-                        115,
-                        109,
-                        97,
-                        108,
-                        108,
-                        101,
-                        115,
-                        116
-                    ]
-                ],
-                expected: "0xb57d179e947e0bfe9813227c428eeea3558dc20e47a9fe64b9d9f29b9b5eeff0"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match expected hash for bytes (static size)", function() {
-        var inputs = [
-            {
-                types: [
-                    "bytes4"
-                ],
-                values: [
-                    [
-                        116,
-                        101,
-                        115,
-                        116
-                    ]
-                ],
-                expected: "0x9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658"
-            },
-            {
-                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
-                    ]
-                ],
-                expected: "0xe44f351d6a5adfe8e8917ee07b7269e9fb019a97fba5eeab82899b02e3f15d1f"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it('should match expected hash for booleans (specified as type "bool" to match solidity)', function() {
-        var inputs = [
-            {
-                types: [
-                    "bool"
-                ],
-                values: [
-                    true
-                ],
-                expected: "0x5fe7f977e71dba2ea1a68e21057beebb9be2ac30c6410aa38d4f3fbe41dcffd2"
-            },
-            {
-                types: [
-                    "bool",
-                    "bool"
-                ],
-                values: [
-                    false,
-                    false
-                ],
-                expected: "0x54a8c0ab653c15bfb48b47fd011ba2b9617af01cb45cab344acd57c924d56798"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match expected hash for (signed and unsigned) integers", function() {
-        var inputs = [
-            {
-                types: [
-                    "int16"
-                ],
-                values: [
-                    -1
-                ],
-                expected: "0x06d41322d79dfed27126569cb9a80eb0967335bf2f3316359d2a93c779fcd38a"
-            },
-            {
-                types: [
-                    "uint48"
-                ],
-                values: [
-                    12
-                ],
-                expected: "0x505be1cd98680abcc2473d7336b83f86f30185d233a18e7dbf9a0add7f7fb583"
-            },
-            {
-                types: [
-                    "int16",
-                    "uint48"
-                ],
-                values: [
-                    -1,
-                    12
-                ],
-                expected: "0x81da7abb5c9c7515f57dab2fc946f01217ab52f3bd8958bc36bd55894451a93c"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match expected hash when passing different types into the same solidityKeccak256 function call", function() {
-        var inputs = [
-            {
-                types: [
-                    "int16",
-                    "string",
-                    "bool"
-                ],
-                values: [
-                    -5,
-                    "essential-eth",
-                    true
-                ],
-                expected: "0xa7bbaa8154fe7d3d9a9d813fa435b386fd75dc57d02b620baafc04074658c454"
-            },
-            {
-                types: [
-                    "address",
-                    "uint48",
-                    "bytes4"
-                ],
-                values: [
-                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
-                    20,
-                    [
-                        116,
-                        101,
-                        115,
-                        116
-                    ]
-                ],
-                expected: "0x6e4e133a4879decc8bf952c54092cb965ba979f38d5e6fb62d47e6bdd7ea390c"
-            },
-            {
-                types: [
-                    "string[3]",
-                    "bytes",
-                    "bool[2]"
-                ],
-                values: [
-                    [
-                        "ethereum",
-                        "blockchain",
-                        "204"
-                    ],
-                    [
-                        115,
-                        111,
-                        108,
-                        105,
-                        100,
-                        105,
-                        116,
-                        121
-                    ],
-                    [
-                        false,
-                        true
-                    ]
-                ],
-                expected: "0xb66a5a976e76e7f2d8b2d5baff670f9937c12b6c3484a9479075d9ecfc2700d2"
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-});

package/dist/cjs/utils/tests/split-signature.test.js

@@ -1,46 +0,0 @@
-import { splitSignature } from "../split-signature";
-describe("splitSignature", function() {
-    it("should match expected results", function() {
-        var testCases = [
-            {
-                signature: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b",
-                expected: {
-                    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
-                    recoveryParam: 0,
-                    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    v: 27,
-                    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
-                }
-            },
-            {
-                signature: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                expected: {
-                    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
-                    recoveryParam: 0,
-                    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
-                    v: 27,
-                    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
-                }
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(splitSignature(testCase.signature)).toStrictEqual(testCase.expected);
-        });
-    });
-    it("should throw error on invalid signature", function() {
-        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33238423849234765127";
-        expect(function() {
-            splitSignature(signature);
-        }).toThrow("invalid signature string");
-    });
-    it("should throw error on invalid v byte", function() {
-        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee3305";
-        expect(function() {
-            splitSignature(signature);
-        }).toThrow("signature invalid v byte");
-    });
-});

package/dist/cjs/utils/tests/to-checksum-address.test.js

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

package/dist/cjs/utils/tests/to-utf8-bytes.test.js

@@ -1,34 +0,0 @@
-import { toUtf8Bytes } from "../../index";
-describe("utils.toUtf8Bytes", function() {
-    it("should correctly convert to UTF8 bytes", function() {
-        var testCases = [
-            {
-                input: "0xa",
-                expected: new Uint8Array([
-                    48,
-                    120,
-                    97
-                ])
-            },
-            {
-                input: "1",
-                expected: new Uint8Array([
-                    49
-                ])
-            },
-            {
-                input: "false",
-                expected: new Uint8Array([
-                    102,
-                    97,
-                    108,
-                    115,
-                    101
-                ])
-            }
-        ];
-        testCases.forEach(function(testCase) {
-            expect(toUtf8Bytes(testCase.input)).toStrictEqual(testCase.expected);
-        });
-    });
-});

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

@@ -1,41 +0,0 @@
-import Big from "big.js";
-import { tinyBig, weiToEther } from "../../index";
-describe("wei-to-ether", function() {
-    it("happy path", function() {
-        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);
-    });
-    it("matches expected value toString", function() {
-        expect(weiToEther("10").toString()).toBe("0.00000000000000001");
-        expect(weiToEther("1000000000000000000000").toString()).toBe("1000");
-    });
-    it("matches expected value toNumber", function() {
-        /* easy */ expect(weiToEther("9").toNumber()).toBe(9e-18);
-        expect(weiToEther("9").toNumber()).toBe(9e-18);
-        /* harder */ expect(weiToEther("999999").toNumber()).toBe(9.99999e-13);
-    });
-    it("support hex", function() {
-        expect(weiToEther("0x14").toString()).toBe("0.00000000000000002");
-        expect(weiToEther(0x14).toString()).toBe("0.00000000000000002");
-    });
-    it("wrong types", function() {
-        expect(function() {
-            // @ts-expect-error should not accept boolean
-            weiToEther(false);
-        }).toThrow();
-        expect(function() {
-            // @ts-expect-error should not accept array
-            weiToEther([
-                1,
-                2,
-                3
-            ]);
-        }).toThrow();
-    });
-});