essential-eth 0.6.2 → 0.8.0

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

@@ -0,0 +1,40 @@
+import * as ethers from "ethers";
+import { arrayify, tinyBig } from "../../..";
+describe("arrayify", function() {
+    it("matches ethers", function() {
+        var inputs = [
+            0,
+            1,
+            "0x1234",
+            new Uint8Array(2),
+            tinyBig(17)
+        ];
+        inputs.forEach(function(input) {
+            //       console.log({ input, arr: arrayify(input as any) });
+            expect(arrayify(input)).toStrictEqual(ethers.utils.arrayify(input));
+        });
+        expect(arrayify("12", {
+            allowMissingPrefix: true
+        })).toStrictEqual(ethers.utils.arrayify("12", {
+            allowMissingPrefix: true
+        }));
+        expect(arrayify("0x1", {
+            hexPad: "left"
+        })).toStrictEqual(ethers.utils.arrayify("0x1", {
+            hexPad: "left"
+        }));
+        expect(arrayify("0x1", {
+            hexPad: "right"
+        })).toStrictEqual(ethers.utils.arrayify("0x1", {
+            hexPad: "right"
+        }));
+        // hex data is odd length
+        expect(function() {
+            return arrayify(tinyBig(15));
+        }).toThrow();
+        // invalid arrayify value
+        expect(function() {
+            return arrayify(false);
+        }).toThrow();
+    });
+});

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

@@ -0,0 +1,15 @@
+import * as ethers from "ethers";
+import { concat } from "../../..";
+describe("concat", function() {
+    it("matches ethers", function() {
+        var inputs = [
+            [
+                0,
+                1
+            ]
+        ];
+        inputs.forEach(function(input) {
+            expect(concat(input)).toStrictEqual(ethers.utils.concat(input));
+        });
+    });
+});

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

@@ -0,0 +1,63 @@
+import { utils as ethers } from "ethers";
+import { hexConcat } from "../../bytes";
+describe("utils.hexConcat", function() {
+    it("should match ethers.js - hex values", function() {
+        var values = [
+            "0x2048",
+            "0x6917",
+            "0x85616379"
+        ];
+        expect(hexConcat(values)).toBe(ethers.hexConcat(values));
+    });
+    it("should match ethers.js - UInt8Array values", function() {
+        var values = [
+            [
+                5,
+                10,
+                247,
+                22
+            ],
+            [
+                50,
+                255,
+                3
+            ],
+            [
+                59,
+                36,
+                18,
+                46,
+                198,
+                234
+            ]
+        ];
+        expect(hexConcat(values)).toBe(ethers.hexConcat(values));
+    });
+    it("should match ethers.js - hex & UInt8Array values", function() {
+        var values = [
+            "0x2048",
+            [
+                5,
+                10,
+                247,
+                22
+            ],
+            "0x6917",
+            [
+                50,
+                255,
+                3
+            ],
+            "0x85616379",
+            [
+                59,
+                36,
+                18,
+                46,
+                198,
+                234
+            ]
+        ];
+        expect(hexConcat(values)).toBe(ethers.hexConcat(values));
+    });
+});

package/dist/cjs/utils/tests/bytes/hex-data-length.test.js

@@ -0,0 +1,49 @@
+import { utils as ethers } from "ethers";
+import { hexDataLength } from "../../bytes";
+describe("utils.hexDataLength", function() {
+    it("should match ethers.js - hex values", function() {
+        var values = [
+            "0x9347",
+            "0x185754",
+            "0x00005823"
+        ];
+        values.forEach(function(value) {
+            expect(hexDataLength(value)).toBe(ethers.hexDataLength(value));
+        });
+    });
+    it("should match ethers.js - UInt8Array values", function() {
+        var values = [
+            [
+                9,
+                58,
+                29,
+                24
+            ],
+            [
+                185,
+                203
+            ],
+            [
+                239,
+                30,
+                49,
+                41,
+                5,
+                10,
+                42
+            ]
+        ];
+        values.forEach(function(value) {
+            expect(hexDataLength(value)).toBe(ethers.hexDataLength(value));
+        });
+    });
+    it("should return null - not hex value or not divisible by 2", function() {
+        var values = [
+            "0x383",
+            "non-hex string"
+        ];
+        values.forEach(function(value) {
+            expect(hexDataLength(value)).toBeNull();
+        });
+    });
+});

package/dist/cjs/utils/tests/bytes/hex-data-slice.test.js

@@ -0,0 +1,52 @@
+import { utils as ethers } from "ethers";
+import { hexDataSlice } from "../../bytes";
+describe("utils.hexDataSlice", function() {
+    it("numbers - matches ethers strings", function() {
+        var decimalValues = [
+            "0x123456"
+        ];
+        decimalValues.forEach(function(decimalValue) {
+            expect(hexDataSlice(decimalValue, 0, 2)).toStrictEqual(ethers.hexDataSlice(decimalValue, 0, 2));
+        });
+    });
+    it("numbers - matches ethers hex numbers", function() {
+        var decimalValues = [
+            0x1234567891011
+        ];
+        decimalValues.forEach(function(decimalValue) {
+            expect(hexDataSlice(decimalValue, 3)).toStrictEqual(ethers.hexDataSlice(decimalValue, 3));
+            expect(hexDataSlice(decimalValue, 2, 4)).toStrictEqual(ethers.hexDataSlice(decimalValue, 2, 4));
+            expect(hexDataSlice(decimalValue, 100)).toStrictEqual(ethers.hexDataSlice(decimalValue, 100));
+        });
+    });
+    it("numbers - matches ethers decimals", function() {
+        var decimalValues = [
+            [
+                0,
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9
+            ]
+        ];
+        decimalValues.forEach(function(decimalValue) {
+            expect(hexDataSlice(decimalValue, 1, 2)).toStrictEqual(ethers.hexDataSlice(decimalValue, 1, 2));
+        });
+    });
+    it("should throw error - invalid hexData", function() {
+        var values = [
+            "non-hex string",
+            "0x938"
+        ];
+        values.forEach(function(value) {
+            expect(function() {
+                return hexDataSlice(value, 1, 3);
+            }).toThrow("invalid hexData");
+        });
+    });
+});

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

@@ -0,0 +1,58 @@
+import { utils as ethers } from "ethers";
+import { hexStripZeros } from "../../bytes";
+describe("utils.hexStripZeros", function() {
+    it("should match ethers.js - hex values", function() {
+        var values = [
+            "0x00009347",
+            "0x00185754",
+            "0x00000000005823"
+        ];
+        values.forEach(function(value) {
+            expect(hexStripZeros(value)).toBe(ethers.hexStripZeros(value));
+        });
+    });
+    it("should match ethers.js - UInt8Array values", 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(hexStripZeros(value)).toBe(ethers.hexStripZeros(value));
+        });
+    });
+    it("should throw error - invalid hex string", function() {
+        var values = [
+            "non-hex string"
+        ];
+        values.forEach(function(value) {
+            expect(function() {
+                return hexStripZeros(value);
+            }).toThrow("invalid hex string");
+        });
+    });
+});

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

@@ -0,0 +1,85 @@
+import { utils as ethers } from "ethers";
+import { hexValue } from "../../bytes";
+import { tinyBig } from "./../../../shared/tiny-big/tiny-big";
+describe("utils.hexValue", function() {
+    it("should match ethers.js - hex string", function() {
+        var values = [
+            "0x9347",
+            "0x185754",
+            "0x00005823"
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        });
+    });
+    it("should match ethers.js - UInt8Array", function() {
+        var values = [
+            [
+                4,
+                50,
+                2
+            ],
+            [
+                231,
+                49,
+                40,
+                70,
+                19
+            ],
+            [
+                10,
+                68,
+                20,
+                98
+            ]
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        });
+    });
+    it("should match ethers.js - TinyBig (hexable)", function() {
+        var values = [
+            tinyBig("29389"),
+            tinyBig(2834),
+            tinyBig(402)
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        });
+    });
+    it("should match ethers.js - number", function() {
+        var values = [
+            624,
+            457,
+            23451
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        });
+    });
+    it("should match ethers.js - BigInt", function() {
+        var values = [
+            BigInt(204),
+            BigInt("23491"),
+            BigInt(4183459235723491)
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe(ethers.hexValue(value));
+        });
+    });
+    it("should return 0x0 - only zero data given", function() {
+        var values = [
+            BigInt(0),
+            0,
+            "0x0000",
+            [
+                0,
+                0,
+                0
+            ]
+        ];
+        values.forEach(function(value) {
+            expect(hexValue(value)).toBe("0x0");
+        });
+    });
+});

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

@@ -0,0 +1,62 @@
+import * as ethers from "ethers";
+import { hexZeroPad } from "../../../";
+describe("hexZeroPad", function() {
+    it("numbers - matches ethers", function() {
+        var decimalValues = [
+            123,
+            0
+        ];
+        decimalValues.forEach(function(decimalValue) {
+            expect(hexZeroPad(decimalValue, 30)).toStrictEqual(ethers.utils.hexZeroPad(decimalValue, 30));
+        });
+    });
+    it("arrays of numbers - matches ethers", function() {
+        var decimalValues = [
+            [
+                1,
+                2,
+                3,
+                4
+            ]
+        ];
+        decimalValues.forEach(function(decimalValue) {
+            expect(hexZeroPad(decimalValue, 30)).toStrictEqual(ethers.utils.hexZeroPad(decimalValue, 30));
+        });
+    });
+    it("should reject strings passed in which are not hex strings", function() {
+        var value = "52908";
+        expect(function() {
+            hexZeroPad(value, 23);
+        }).toThrow();
+    });
+    it("should throw error when value is already longer than desired length", function() {
+        var hexValues = [
+            0x123456,
+            "0x5aAebAd",
+            "0xfB691",
+            "0xD1220ab"
+        ];
+        hexValues.forEach(function(hexValue) {
+            expect(function() {
+                return hexZeroPad(hexValue, 2);
+            }).toThrow();
+        });
+    });
+    it("should match ethers.js when padding can be applied", function() {
+        var values = [
+            10,
+            "0x5290",
+            "0x8617E3",
+            "0xde709f210",
+            "0x27b",
+            0x0,
+            0x5aaeb605,
+            "0xfB6916095ca1df",
+            "0xdbF03B407c01E7cD3CBea99509d93",
+            0xd1220a0cf4
+        ];
+        values.forEach(function(value) {
+            expect(hexZeroPad(value, 30)).toStrictEqual(ethers.utils.hexZeroPad(value, 30));
+        });
+    });
+});

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

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

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

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

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