essential-eth 0.9.0 → 0.9.1-next.1

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

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

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

@@ -1,310 +0,0 @@
-import { utils } from "ethers";
-import { solidityKeccak256 } from "../../index";
-/**
- *
- * @param inputs
- */ function testSolidityKeccak256(inputs) {
-    inputs.forEach(function(input) {
-        expect(solidityKeccak256(input.types, input.values)).toBe(utils.solidityKeccak256(input.types, input.values));
-    });
-}
-describe("solidityKeccak256", function() {
-    it("should match ethers.js addresses", function() {
-        var inputs = [
-            {
-                types: [
-                    "address"
-                ],
-                values: [
-                    "0x4d7F1790644Af787933c9fF0e2cff9a9B4299Abb"
-                ]
-            },
-            {
-                types: [
-                    "address",
-                    "address"
-                ],
-                values: [
-                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
-                    "0xaa0fc255b079e775f9307e5cfec472a555cebc3a"
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js strings", function() {
-        var inputs = [
-            {
-                types: [
-                    "string"
-                ],
-                values: [
-                    "essential-eth"
-                ]
-            },
-            {
-                types: [
-                    "string",
-                    "string"
-                ],
-                values: [
-                    "firstText",
-                    "secondString"
-                ]
-            },
-            {
-                types: [
-                    "string",
-                    "string",
-                    "string"
-                ],
-                values: [
-                    "example1",
-                    "2934823",
-                    "true"
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js bytes (dynamic size) & BytesLike", function() {
-        var inputs = [
-            {
-                types: [
-                    "bytes"
-                ],
-                values: [
-                    [
-                        115,
-                        101,
-                        99,
-                        114,
-                        101,
-                        116
-                    ]
-                ]
-            },
-            {
-                types: [
-                    "bytes"
-                ],
-                values: [
-                    "0x62797465734c696b65"
-                ]
-            },
-            {
-                types: [
-                    "bytes",
-                    "bytes"
-                ],
-                values: [
-                    "0x657373656e7469616c2d657468",
-                    [
-                        115,
-                        109,
-                        97,
-                        108,
-                        108,
-                        101,
-                        115,
-                        116
-                    ]
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js bytes (static size)", function() {
-        var 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
-                    ]
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it('should match ethers.js booleans (specified as type "bool" to match solidity)', function() {
-        var inputs = [
-            {
-                types: [
-                    "bool"
-                ],
-                values: [
-                    true
-                ]
-            },
-            {
-                types: [
-                    "bool",
-                    "bool"
-                ],
-                values: [
-                    false,
-                    false
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js (signed and unsigned) integers", function() {
-        var inputs = [
-            {
-                types: [
-                    "int16"
-                ],
-                values: [
-                    -1
-                ]
-            },
-            {
-                types: [
-                    "uint48"
-                ],
-                values: [
-                    12
-                ]
-            },
-            {
-                types: [
-                    "int16",
-                    "uint48"
-                ],
-                values: [
-                    -1,
-                    12
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js array parsing", function() {
-        var inputs = [
-            {
-                types: [
-                    "string[2]"
-                ],
-                values: [
-                    [
-                        "some-text",
-                        "additional-text"
-                    ]
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-    it("should match ethers.js when passing different types into the same solidityKeccak256 function call", function() {
-        var inputs = [
-            {
-                types: [
-                    "int16",
-                    "string",
-                    "bool"
-                ],
-                values: [
-                    -5,
-                    "essential-eth",
-                    true
-                ]
-            },
-            {
-                types: [
-                    "address",
-                    "uint48",
-                    "bytes4"
-                ],
-                values: [
-                    "0xB5503a7db1A9105cd459D99153e69a76a8EF1530",
-                    20,
-                    [
-                        116,
-                        101,
-                        115,
-                        116
-                    ]
-                ]
-            },
-            {
-                types: [
-                    "string[3]",
-                    "bytes",
-                    "bool[2]"
-                ],
-                values: [
-                    [
-                        "ethereum",
-                        "blockchain",
-                        "204"
-                    ],
-                    [
-                        115,
-                        111,
-                        108,
-                        105,
-                        100,
-                        105,
-                        116,
-                        121
-                    ],
-                    [
-                        false,
-                        true
-                    ]
-                ]
-            }
-        ];
-        testSolidityKeccak256(inputs);
-    });
-});

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

@@ -1,25 +0,0 @@
-import { utils } from "ethers";
-import { splitSignature } from "../split-signature";
-describe("splitSignature", function() {
-    it("should match ethers.js", function() {
-        var signatures = [
-            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b",
-            "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
-        ];
-        signatures.forEach(function(signature) {
-            expect(splitSignature(signature)).toStrictEqual(utils.splitSignature(signature));
-        });
-    });
-    it("should throw error on invalid signature", function() {
-        var signature = "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33238423849234765127"; //invalid signature length
-        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,42 +0,0 @@
-import { utils } from "ethers";
-import web3 from "web3";
-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(utils.getAddress(address));
-            expect(toChecksumAddress(address)).toStrictEqual(web3.utils.toChecksumAddress(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,14 +0,0 @@
-import { utils } from "ethers";
-import { toUtf8Bytes } from "../../index";
-describe("utils.toUtf8Bytes", function() {
-    it("should match ethers.js", function() {
-        var inputs = [
-            "0xa",
-            "1",
-            "false"
-        ];
-        inputs.forEach(function(input) {
-            expect(toUtf8Bytes(input)).toStrictEqual(utils.toUtf8Bytes(input));
-        });
-    });
-});

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

@@ -1,51 +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", 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);
-    });
-    describe("matches ethers and web3 toString", function() {
-        it("toString", function() {
-            expect(weiToEther("10").toString()).toStrictEqual(ethers.utils.formatEther("10"));
-            expect(weiToEther("1000000000000000000000").toString()).toBe("1000");
-            expect(weiToEther("10").toString()).toStrictEqual(web3.utils.fromWei("10", "ether"));
-            expect(weiToEther("1000000000000000000000").toString()).toStrictEqual(web3.utils.fromWei("1000000000000000000000", "ether"));
-        });
-        it("toNumber", function() {
-            /* 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")));
-            expect(weiToEther("999999").toNumber()).toStrictEqual(Number(web3.utils.fromWei("999999", "ether")));
-        });
-    });
-    it("support hex", function() {
-        expect(weiToEther("0x14").toString()).toStrictEqual(ethers.utils.formatEther("20"));
-        expect(weiToEther(0x14).toString()).toStrictEqual(ethers.utils.formatEther("20"));
-    });
-    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();
-    });
-});