@bsv/sdk 1.3.13 → 1.3.15

package/src/primitives/__tests/BigNumber.utils.test.ts

@@ -1,437 +1,437 @@
 /* eslint-env jest */
-import BigNumber from "../../primitives/BigNumber";
+import BigNumber from '../../primitives/BigNumber'
 
-describe("BN.js/Utils", () => {
-  describe(".toString()", () => {
-    describe("hex no padding", () => {
-      it("should have same length as input", () => {
-        let hex = "1";
+describe('BN.js/Utils', () => {
+  describe('.toString()', () => {
+    describe('hex no padding', () => {
+      it('should have same length as input', () => {
+        let hex = '1'
         for (let i = 1; i <= 128; i++) {
-          const n = new BigNumber(hex, 16);
-          expect(n.toString(16).length).toEqual(i);
-          hex = hex + "0";
+          const n = new BigNumber(hex, 16)
+          expect(n.toString(16).length).toEqual(i)
+          hex = hex + '0'
         }
-      });
-    });
-    describe("binary padding", () => {
-      it("should have a length of 256", () => {
-        const a = new BigNumber(0);
+      })
+    })
+    describe('binary padding', () => {
+      it('should have a length of 256', () => {
+        const a = new BigNumber(0)
 
-        expect(a.toString(2, 256).length).toEqual(256);
-      });
-    });
-    describe("hex padding", () => {
-      it("should have length of 8 from leading 15", () => {
-        const a = new BigNumber("ffb9602", 16);
+        expect(a.toString(2, 256).length).toEqual(256)
+      })
+    })
+    describe('hex padding', () => {
+      it('should have length of 8 from leading 15', () => {
+        const a = new BigNumber('ffb9602', 16)
 
-        expect(a.toString("hex", 2).length).toEqual(8);
-      });
+        expect(a.toString('hex', 2).length).toEqual(8)
+      })
 
-      it("should have length of 8 from leading zero", () => {
-        const a = new BigNumber("fb9604", 16);
+      it('should have length of 8 from leading zero', () => {
+        const a = new BigNumber('fb9604', 16)
 
-        expect(a.toString("hex", 8).length).toEqual(8);
-      });
+        expect(a.toString('hex', 8).length).toEqual(8)
+      })
 
-      it("should have length of 8 from leading zeros", () => {
-        const a = new BigNumber(0);
+      it('should have length of 8 from leading zeros', () => {
+        const a = new BigNumber(0)
 
-        expect(a.toString("hex", 8).length).toEqual(8);
-      });
+        expect(a.toString('hex', 8).length).toEqual(8)
+      })
 
-      it("should have length of 64 from leading 15", () => {
+      it('should have length of 64 from leading 15', () => {
         const a = new BigNumber(
-          "ffb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003",
+          'ffb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
           16
-        );
+        )
 
-        expect(a.toString("hex", 2).length).toEqual(64);
-      });
+        expect(a.toString('hex', 2).length).toEqual(64)
+      })
 
-      it("should have length of 64 from leading zero", () => {
+      it('should have length of 64 from leading zero', () => {
         const a = new BigNumber(
-          "fb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003",
+          'fb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
           16
-        );
+        )
 
-        expect(a.toString("hex", 64).length).toEqual(64);
-      });
-    });
-  });
+        expect(a.toString('hex', 64).length).toEqual(64)
+      })
+    })
+  })
 
-  describe(".isNeg()", () => {
-    it("should return true for negative numbers", () => {
-      expect(new BigNumber(-1).isNeg()).toEqual(true);
-      expect(new BigNumber(1).isNeg()).toEqual(false);
-      expect(new BigNumber(0).isNeg()).toEqual(false);
-      expect(new BigNumber("-0", 10).isNeg()).toEqual(false);
-    });
-  });
+  describe('.isNeg()', () => {
+    it('should return true for negative numbers', () => {
+      expect(new BigNumber(-1).isNeg()).toEqual(true)
+      expect(new BigNumber(1).isNeg()).toEqual(false)
+      expect(new BigNumber(0).isNeg()).toEqual(false)
+      expect(new BigNumber('-0', 10).isNeg()).toEqual(false)
+    })
+  })
 
-  describe(".isOdd()", () => {
-    it("should return true for odd numbers", () => {
-      expect(new BigNumber(0).isOdd()).toEqual(false);
-      expect(new BigNumber(1).isOdd()).toEqual(true);
-      expect(new BigNumber(2).isOdd()).toEqual(false);
-      expect(new BigNumber("-0", 10).isOdd()).toEqual(false);
-      expect(new BigNumber("-1", 10).isOdd()).toEqual(true);
-      expect(new BigNumber("-2", 10).isOdd()).toEqual(false);
-    });
-  });
+  describe('.isOdd()', () => {
+    it('should return true for odd numbers', () => {
+      expect(new BigNumber(0).isOdd()).toEqual(false)
+      expect(new BigNumber(1).isOdd()).toEqual(true)
+      expect(new BigNumber(2).isOdd()).toEqual(false)
+      expect(new BigNumber('-0', 10).isOdd()).toEqual(false)
+      expect(new BigNumber('-1', 10).isOdd()).toEqual(true)
+      expect(new BigNumber('-2', 10).isOdd()).toEqual(false)
+    })
+  })
 
-  describe(".isEven()", () => {
-    it("should return true for even numbers", () => {
-      expect(new BigNumber(0).isEven()).toEqual(true);
-      expect(new BigNumber(1).isEven()).toEqual(false);
-      expect(new BigNumber(2).isEven()).toEqual(true);
-      expect(new BigNumber("-0", 10).isEven()).toEqual(true);
-      expect(new BigNumber("-1", 10).isEven()).toEqual(false);
-      expect(new BigNumber("-2", 10).isEven()).toEqual(true);
-    });
-  });
+  describe('.isEven()', () => {
+    it('should return true for even numbers', () => {
+      expect(new BigNumber(0).isEven()).toEqual(true)
+      expect(new BigNumber(1).isEven()).toEqual(false)
+      expect(new BigNumber(2).isEven()).toEqual(true)
+      expect(new BigNumber('-0', 10).isEven()).toEqual(true)
+      expect(new BigNumber('-1', 10).isEven()).toEqual(false)
+      expect(new BigNumber('-2', 10).isEven()).toEqual(true)
+    })
+  })
 
-  describe(".isZero()", () => {
-    it("should return true for zero", () => {
-      expect(new BigNumber(0).isZero()).toEqual(true);
-      expect(new BigNumber(1).isZero()).toEqual(false);
-      expect(new BigNumber(0xffffffff).isZero()).toEqual(false);
-    });
-  });
+  describe('.isZero()', () => {
+    it('should return true for zero', () => {
+      expect(new BigNumber(0).isZero()).toEqual(true)
+      expect(new BigNumber(1).isZero()).toEqual(false)
+      expect(new BigNumber(0xffffffff).isZero()).toEqual(false)
+    })
+  })
 
-  describe(".bitLength()", () => {
-    it("should return proper bitLength", () => {
-      expect(new BigNumber(0).bitLength()).toEqual(0);
-      expect(new BigNumber(0x1).bitLength()).toEqual(1);
-      expect(new BigNumber(0x2).bitLength()).toEqual(2);
-      expect(new BigNumber(0x3).bitLength()).toEqual(2);
-      expect(new BigNumber(0x4).bitLength()).toEqual(3);
-      expect(new BigNumber(0x8).bitLength()).toEqual(4);
-      expect(new BigNumber(0x10).bitLength()).toEqual(5);
-      expect(new BigNumber(0x100).bitLength()).toEqual(9);
-      expect(new BigNumber(0x123456).bitLength()).toEqual(21);
-      expect(new BigNumber("123456789", 16).bitLength()).toEqual(33);
-      expect(new BigNumber("8023456789", 16).bitLength()).toEqual(40);
-    });
-  });
+  describe('.bitLength()', () => {
+    it('should return proper bitLength', () => {
+      expect(new BigNumber(0).bitLength()).toEqual(0)
+      expect(new BigNumber(0x1).bitLength()).toEqual(1)
+      expect(new BigNumber(0x2).bitLength()).toEqual(2)
+      expect(new BigNumber(0x3).bitLength()).toEqual(2)
+      expect(new BigNumber(0x4).bitLength()).toEqual(3)
+      expect(new BigNumber(0x8).bitLength()).toEqual(4)
+      expect(new BigNumber(0x10).bitLength()).toEqual(5)
+      expect(new BigNumber(0x100).bitLength()).toEqual(9)
+      expect(new BigNumber(0x123456).bitLength()).toEqual(21)
+      expect(new BigNumber('123456789', 16).bitLength()).toEqual(33)
+      expect(new BigNumber('8023456789', 16).bitLength()).toEqual(40)
+    })
+  })
 
-  describe(".byteLength()", () => {
-    it("should return proper byteLength", () => {
-      expect(new BigNumber(0).byteLength()).toEqual(0);
-      expect(new BigNumber(0x1).byteLength()).toEqual(1);
-      expect(new BigNumber(0x2).byteLength()).toEqual(1);
-      expect(new BigNumber(0x3).byteLength()).toEqual(1);
-      expect(new BigNumber(0x4).byteLength()).toEqual(1);
-      expect(new BigNumber(0x8).byteLength()).toEqual(1);
-      expect(new BigNumber(0x10).byteLength()).toEqual(1);
-      expect(new BigNumber(0x100).byteLength()).toEqual(2);
-      expect(new BigNumber(0x123456).byteLength()).toEqual(3);
-      expect(new BigNumber("123456789", 16).byteLength()).toEqual(5);
-      expect(new BigNumber("8023456789", 16).byteLength()).toEqual(5);
-    });
-  });
+  describe('.byteLength()', () => {
+    it('should return proper byteLength', () => {
+      expect(new BigNumber(0).byteLength()).toEqual(0)
+      expect(new BigNumber(0x1).byteLength()).toEqual(1)
+      expect(new BigNumber(0x2).byteLength()).toEqual(1)
+      expect(new BigNumber(0x3).byteLength()).toEqual(1)
+      expect(new BigNumber(0x4).byteLength()).toEqual(1)
+      expect(new BigNumber(0x8).byteLength()).toEqual(1)
+      expect(new BigNumber(0x10).byteLength()).toEqual(1)
+      expect(new BigNumber(0x100).byteLength()).toEqual(2)
+      expect(new BigNumber(0x123456).byteLength()).toEqual(3)
+      expect(new BigNumber('123456789', 16).byteLength()).toEqual(5)
+      expect(new BigNumber('8023456789', 16).byteLength()).toEqual(5)
+    })
+  })
 
-  describe(".toArray()", () => {
-    it("should return [ 0 ] for `0`", () => {
-      const n = new BigNumber(0);
-      expect(n.toArray("be")).toEqual([0]);
-      expect(n.toArray("le")).toEqual([0]);
-    });
+  describe('.toArray()', () => {
+    it('should return [ 0 ] for `0`', () => {
+      const n = new BigNumber(0)
+      expect(n.toArray('be')).toEqual([0])
+      expect(n.toArray('le')).toEqual([0])
+    })
 
-    it("should zero pad to desired lengths", () => {
-      const n = new BigNumber(0x123456);
-      expect(n.toArray("be", 5)).toEqual([0x00, 0x00, 0x12, 0x34, 0x56]);
-      expect(n.toArray("le", 5)).toEqual([0x56, 0x34, 0x12, 0x00, 0x00]);
-    });
+    it('should zero pad to desired lengths', () => {
+      const n = new BigNumber(0x123456)
+      expect(n.toArray('be', 5)).toEqual([0x00, 0x00, 0x12, 0x34, 0x56])
+      expect(n.toArray('le', 5)).toEqual([0x56, 0x34, 0x12, 0x00, 0x00])
+    })
 
-    it("should throw when naturally larger than desired length", () => {
-      const n = new BigNumber(0x123456);
+    it('should throw when naturally larger than desired length', () => {
+      const n = new BigNumber(0x123456)
       expect(() => {
-        n.toArray("be", 2);
-      }).toThrow(new Error("byte array longer than desired length"));
-    });
-  });
+        n.toArray('be', 2)
+      }).toThrow(new Error('byte array longer than desired length'))
+    })
+  })
 
-  describe(".toNumber()", () => {
-    it("should return proper Number if below the limit", () => {
-      expect(new BigNumber(0x123456).toNumber()).toEqual(0x123456);
-      expect(new BigNumber(0x3ffffff).toNumber()).toEqual(0x3ffffff);
-      expect(new BigNumber(0x4000000).toNumber()).toEqual(0x4000000);
+  describe('.toNumber()', () => {
+    it('should return proper Number if below the limit', () => {
+      expect(new BigNumber(0x123456).toNumber()).toEqual(0x123456)
+      expect(new BigNumber(0x3ffffff).toNumber()).toEqual(0x3ffffff)
+      expect(new BigNumber(0x4000000).toNumber()).toEqual(0x4000000)
       expect(new BigNumber(0x10000000000000).toNumber()).toEqual(
         0x10000000000000
-      );
+      )
       expect(new BigNumber(0x10040004004000).toNumber()).toEqual(
         0x10040004004000
-      );
-      expect(new BigNumber(-0x123456).toNumber()).toEqual(-0x123456);
-      expect(new BigNumber(-0x3ffffff).toNumber()).toEqual(-0x3ffffff);
-      expect(new BigNumber(-0x4000000).toNumber()).toEqual(-0x4000000);
+      )
+      expect(new BigNumber(-0x123456).toNumber()).toEqual(-0x123456)
+      expect(new BigNumber(-0x3ffffff).toNumber()).toEqual(-0x3ffffff)
+      expect(new BigNumber(-0x4000000).toNumber()).toEqual(-0x4000000)
       expect(new BigNumber(-0x10000000000000).toNumber()).toEqual(
         -0x10000000000000
-      );
+      )
       expect(new BigNumber(-0x10040004004000).toNumber()).toEqual(
         -0x10040004004000
-      );
-    });
+      )
+    })
 
-    it("should throw when number exceeds 53 bits", () => {
-      const n = new BigNumber(1).iushln(54);
+    it('should throw when number exceeds 53 bits', () => {
+      const n = new BigNumber(1).iushln(54)
       expect(() => {
-        n.toNumber();
-      }).toThrow(new Error("Number can only safely store up to 53 bits"));
-    });
-  });
+        n.toNumber()
+      }).toThrow(new Error('Number can only safely store up to 53 bits'))
+    })
+  })
 
-  describe(".zeroBits()", () => {
-    it("should return proper zeroBits", () => {
-      expect(new BigNumber(0).zeroBits()).toEqual(0);
-      expect(new BigNumber(0x1).zeroBits()).toEqual(0);
-      expect(new BigNumber(0x2).zeroBits()).toEqual(1);
-      expect(new BigNumber(0x3).zeroBits()).toEqual(0);
-      expect(new BigNumber(0x4).zeroBits()).toEqual(2);
-      expect(new BigNumber(0x8).zeroBits()).toEqual(3);
-      expect(new BigNumber(0x10).zeroBits()).toEqual(4);
-      expect(new BigNumber(0x100).zeroBits()).toEqual(8);
-      expect(new BigNumber(0x1000000).zeroBits()).toEqual(24);
-      expect(new BigNumber(0x123456).zeroBits()).toEqual(1);
-    });
-  });
+  describe('.zeroBits()', () => {
+    it('should return proper zeroBits', () => {
+      expect(new BigNumber(0).zeroBits()).toEqual(0)
+      expect(new BigNumber(0x1).zeroBits()).toEqual(0)
+      expect(new BigNumber(0x2).zeroBits()).toEqual(1)
+      expect(new BigNumber(0x3).zeroBits()).toEqual(0)
+      expect(new BigNumber(0x4).zeroBits()).toEqual(2)
+      expect(new BigNumber(0x8).zeroBits()).toEqual(3)
+      expect(new BigNumber(0x10).zeroBits()).toEqual(4)
+      expect(new BigNumber(0x100).zeroBits()).toEqual(8)
+      expect(new BigNumber(0x1000000).zeroBits()).toEqual(24)
+      expect(new BigNumber(0x123456).zeroBits()).toEqual(1)
+    })
+  })
 
-  describe(".toJSON", () => {
-    it("should return hex string", () => {
-      expect(new BigNumber(0x123).toJSON()).toEqual("123");
-    });
-  });
+  describe('.toJSON', () => {
+    it('should return hex string', () => {
+      expect(new BigNumber(0x123).toJSON()).toEqual('123')
+    })
+  })
 
-  describe(".cmpn", () => {
-    it("should return -1, 0, 1 correctly", () => {
-      expect(new BigNumber(42).cmpn(42)).toEqual(0);
-      expect(new BigNumber(42).cmpn(43)).toEqual(-1);
-      expect(new BigNumber(42).cmpn(41)).toEqual(1);
-      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffe)).toEqual(0);
-      expect(new BigNumber(0x3fffffe).cmpn(0x3ffffff)).toEqual(-1);
-      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffd)).toEqual(1);
+  describe('.cmpn', () => {
+    it('should return -1, 0, 1 correctly', () => {
+      expect(new BigNumber(42).cmpn(42)).toEqual(0)
+      expect(new BigNumber(42).cmpn(43)).toEqual(-1)
+      expect(new BigNumber(42).cmpn(41)).toEqual(1)
+      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffe)).toEqual(0)
+      expect(new BigNumber(0x3fffffe).cmpn(0x3ffffff)).toEqual(-1)
+      expect(new BigNumber(0x3fffffe).cmpn(0x3fffffd)).toEqual(1)
       expect(() => {
-        new BigNumber(0x3fffffe).cmpn(0x4000000);
-      }).toThrow(new Error("Number is too big"));
-      expect(new BigNumber(42).cmpn(-42)).toEqual(1);
-      expect(new BigNumber(-42).cmpn(42)).toEqual(-1);
-      expect(new BigNumber(-42).cmpn(-42)).toEqual(0);
-      expect(1 / new BigNumber(-42).cmpn(-42)).toEqual(Infinity);
-    });
-  });
+        new BigNumber(0x3fffffe).cmpn(0x4000000)
+      }).toThrow(new Error('Number is too big'))
+      expect(new BigNumber(42).cmpn(-42)).toEqual(1)
+      expect(new BigNumber(-42).cmpn(42)).toEqual(-1)
+      expect(new BigNumber(-42).cmpn(-42)).toEqual(0)
+      expect(1 / new BigNumber(-42).cmpn(-42)).toEqual(Infinity)
+    })
+  })
 
-  describe(".cmp", () => {
-    it("should return -1, 0, 1 correctly", () => {
-      expect(new BigNumber(42).cmp(new BigNumber(42))).toEqual(0);
-      expect(new BigNumber(42).cmp(new BigNumber(43))).toEqual(-1);
-      expect(new BigNumber(42).cmp(new BigNumber(41))).toEqual(1);
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffe))).toEqual(0);
+  describe('.cmp', () => {
+    it('should return -1, 0, 1 correctly', () => {
+      expect(new BigNumber(42).cmp(new BigNumber(42))).toEqual(0)
+      expect(new BigNumber(42).cmp(new BigNumber(43))).toEqual(-1)
+      expect(new BigNumber(42).cmp(new BigNumber(41))).toEqual(1)
+      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffe))).toEqual(0)
       expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3ffffff))).toEqual(
         -1
-      );
-      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffd))).toEqual(1);
+      )
+      expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x3fffffd))).toEqual(1)
       expect(new BigNumber(0x3fffffe).cmp(new BigNumber(0x4000000))).toEqual(
         -1
-      );
-      expect(new BigNumber(42).cmp(new BigNumber(-42))).toEqual(1);
-      expect(new BigNumber(-42).cmp(new BigNumber(42))).toEqual(-1);
-      expect(new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(0);
-      expect(1 / new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(Infinity);
-    });
-  });
+      )
+      expect(new BigNumber(42).cmp(new BigNumber(-42))).toEqual(1)
+      expect(new BigNumber(-42).cmp(new BigNumber(42))).toEqual(-1)
+      expect(new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(0)
+      expect(1 / new BigNumber(-42).cmp(new BigNumber(-42))).toEqual(Infinity)
+    })
+  })
 
-  describe("comparison shorthands", () => {
-    it(".gtn greater than", () => {
-      expect(new BigNumber(3).gtn(2)).toEqual(true);
-      expect(new BigNumber(3).gtn(3)).toEqual(false);
-      expect(new BigNumber(3).gtn(4)).toEqual(false);
-    });
-    it(".gt greater than", () => {
-      expect(new BigNumber(3).gt(new BigNumber(2))).toEqual(true);
-      expect(new BigNumber(3).gt(new BigNumber(3))).toEqual(false);
-      expect(new BigNumber(3).gt(new BigNumber(4))).toEqual(false);
-    });
-    it(".gten greater than or equal", () => {
-      expect(new BigNumber(3).gten(3)).toEqual(true);
-      expect(new BigNumber(3).gten(2)).toEqual(true);
-      expect(new BigNumber(3).gten(4)).toEqual(false);
-    });
-    it(".gte greater than or equal", () => {
-      expect(new BigNumber(3).gte(new BigNumber(3))).toEqual(true);
-      expect(new BigNumber(3).gte(new BigNumber(2))).toEqual(true);
-      expect(new BigNumber(3).gte(new BigNumber(4))).toEqual(false);
-    });
-    it(".ltn less than", () => {
-      expect(new BigNumber(2).ltn(3)).toEqual(true);
-      expect(new BigNumber(2).ltn(2)).toEqual(false);
-      expect(new BigNumber(2).ltn(1)).toEqual(false);
-    });
-    it(".lt less than", () => {
-      expect(new BigNumber(2).lt(new BigNumber(3))).toEqual(true);
-      expect(new BigNumber(2).lt(new BigNumber(2))).toEqual(false);
-      expect(new BigNumber(2).lt(new BigNumber(1))).toEqual(false);
-    });
-    it(".lten less than or equal", () => {
-      expect(new BigNumber(3).lten(3)).toEqual(true);
-      expect(new BigNumber(3).lten(2)).toEqual(false);
-      expect(new BigNumber(3).lten(4)).toEqual(true);
-    });
-    it(".lte less than or equal", () => {
-      expect(new BigNumber(3).lte(new BigNumber(3))).toEqual(true);
-      expect(new BigNumber(3).lte(new BigNumber(2))).toEqual(false);
-      expect(new BigNumber(3).lte(new BigNumber(4))).toEqual(true);
-    });
-    it(".eqn equal", () => {
-      expect(new BigNumber(3).eqn(3)).toEqual(true);
-      expect(new BigNumber(3).eqn(2)).toEqual(false);
-      expect(new BigNumber(3).eqn(4)).toEqual(false);
-    });
-    it(".eq equal", () => {
-      expect(new BigNumber(3).eq(new BigNumber(3))).toEqual(true);
-      expect(new BigNumber(3).eq(new BigNumber(2))).toEqual(false);
-      expect(new BigNumber(3).eq(new BigNumber(4))).toEqual(false);
-    });
-  });
+  describe('comparison shorthands', () => {
+    it('.gtn greater than', () => {
+      expect(new BigNumber(3).gtn(2)).toEqual(true)
+      expect(new BigNumber(3).gtn(3)).toEqual(false)
+      expect(new BigNumber(3).gtn(4)).toEqual(false)
+    })
+    it('.gt greater than', () => {
+      expect(new BigNumber(3).gt(new BigNumber(2))).toEqual(true)
+      expect(new BigNumber(3).gt(new BigNumber(3))).toEqual(false)
+      expect(new BigNumber(3).gt(new BigNumber(4))).toEqual(false)
+    })
+    it('.gten greater than or equal', () => {
+      expect(new BigNumber(3).gten(3)).toEqual(true)
+      expect(new BigNumber(3).gten(2)).toEqual(true)
+      expect(new BigNumber(3).gten(4)).toEqual(false)
+    })
+    it('.gte greater than or equal', () => {
+      expect(new BigNumber(3).gte(new BigNumber(3))).toEqual(true)
+      expect(new BigNumber(3).gte(new BigNumber(2))).toEqual(true)
+      expect(new BigNumber(3).gte(new BigNumber(4))).toEqual(false)
+    })
+    it('.ltn less than', () => {
+      expect(new BigNumber(2).ltn(3)).toEqual(true)
+      expect(new BigNumber(2).ltn(2)).toEqual(false)
+      expect(new BigNumber(2).ltn(1)).toEqual(false)
+    })
+    it('.lt less than', () => {
+      expect(new BigNumber(2).lt(new BigNumber(3))).toEqual(true)
+      expect(new BigNumber(2).lt(new BigNumber(2))).toEqual(false)
+      expect(new BigNumber(2).lt(new BigNumber(1))).toEqual(false)
+    })
+    it('.lten less than or equal', () => {
+      expect(new BigNumber(3).lten(3)).toEqual(true)
+      expect(new BigNumber(3).lten(2)).toEqual(false)
+      expect(new BigNumber(3).lten(4)).toEqual(true)
+    })
+    it('.lte less than or equal', () => {
+      expect(new BigNumber(3).lte(new BigNumber(3))).toEqual(true)
+      expect(new BigNumber(3).lte(new BigNumber(2))).toEqual(false)
+      expect(new BigNumber(3).lte(new BigNumber(4))).toEqual(true)
+    })
+    it('.eqn equal', () => {
+      expect(new BigNumber(3).eqn(3)).toEqual(true)
+      expect(new BigNumber(3).eqn(2)).toEqual(false)
+      expect(new BigNumber(3).eqn(4)).toEqual(false)
+    })
+    it('.eq equal', () => {
+      expect(new BigNumber(3).eq(new BigNumber(3))).toEqual(true)
+      expect(new BigNumber(3).eq(new BigNumber(2))).toEqual(false)
+      expect(new BigNumber(3).eq(new BigNumber(4))).toEqual(false)
+    })
+  })
 
-  describe(".fromTwos", () => {
+  describe('.fromTwos', () => {
     it("should convert from two's complement to negative number", () => {
-      expect(new BigNumber("00000000", 16).fromTwos(32).toNumber()).toEqual(0);
-      expect(new BigNumber("00000001", 16).fromTwos(32).toNumber()).toEqual(1);
-      expect(new BigNumber("7fffffff", 16).fromTwos(32).toNumber()).toEqual(
+      expect(new BigNumber('00000000', 16).fromTwos(32).toNumber()).toEqual(0)
+      expect(new BigNumber('00000001', 16).fromTwos(32).toNumber()).toEqual(1)
+      expect(new BigNumber('7fffffff', 16).fromTwos(32).toNumber()).toEqual(
         2147483647
-      );
-      expect(new BigNumber("80000000", 16).fromTwos(32).toNumber()).toEqual(
+      )
+      expect(new BigNumber('80000000', 16).fromTwos(32).toNumber()).toEqual(
         -2147483648
-      );
-      expect(new BigNumber("f0000000", 16).fromTwos(32).toNumber()).toEqual(
+      )
+      expect(new BigNumber('f0000000', 16).fromTwos(32).toNumber()).toEqual(
         -268435456
-      );
-      expect(new BigNumber("f1234567", 16).fromTwos(32).toNumber()).toEqual(
+      )
+      expect(new BigNumber('f1234567', 16).fromTwos(32).toNumber()).toEqual(
         -249346713
-      );
-      expect(new BigNumber("ffffffff", 16).fromTwos(32).toNumber()).toEqual(-1);
-      expect(new BigNumber("fffffffe", 16).fromTwos(32).toNumber()).toEqual(-2);
+      )
+      expect(new BigNumber('ffffffff', 16).fromTwos(32).toNumber()).toEqual(-1)
+      expect(new BigNumber('fffffffe', 16).fromTwos(32).toNumber()).toEqual(-2)
       expect(
-        new BigNumber("fffffffffffffffffffffffffffffffe", 16)
+        new BigNumber('fffffffffffffffffffffffffffffffe', 16)
           .fromTwos(128)
           .toNumber()
-      ).toEqual(-2);
+      ).toEqual(-2)
       expect(
         new BigNumber(
-          "ffffffffffffffffffffffffffffffff" +
-            "fffffffffffffffffffffffffffffffe",
+          'ffffffffffffffffffffffffffffffff' +
+            'fffffffffffffffffffffffffffffffe',
           16
         )
           .fromTwos(256)
           .toNumber()
-      ).toEqual(-2);
+      ).toEqual(-2)
       expect(
         new BigNumber(
-          "ffffffffffffffffffffffffffffffff" +
-            "ffffffffffffffffffffffffffffffff",
+          'ffffffffffffffffffffffffffffffff' +
+            'ffffffffffffffffffffffffffffffff',
           16
         )
           .fromTwos(256)
           .toNumber()
-      ).toEqual(-1);
+      ).toEqual(-1)
       expect(
         new BigNumber(
-          "7fffffffffffffffffffffffffffffff" +
-            "ffffffffffffffffffffffffffffffff",
+          '7fffffffffffffffffffffffffffffff' +
+            'ffffffffffffffffffffffffffffffff',
           16
         )
           .fromTwos(256)
           .toString(10)
       ).toEqual(
         new BigNumber(
-          "5789604461865809771178549250434395392663499" +
-            "2332820282019728792003956564819967",
+          '5789604461865809771178549250434395392663499' +
+            '2332820282019728792003956564819967',
           10
         ).toString(10)
-      );
+      )
       expect(
         new BigNumber(
-          "80000000000000000000000000000000" +
-            "00000000000000000000000000000000",
+          '80000000000000000000000000000000' +
+            '00000000000000000000000000000000',
           16
         )
           .fromTwos(256)
           .toString(10)
       ).toEqual(
         new BigNumber(
-          "-578960446186580977117854925043439539266349" +
-            "92332820282019728792003956564819968",
+          '-578960446186580977117854925043439539266349' +
+            '92332820282019728792003956564819968',
           10
         ).toString(10)
-      );
-    });
-  });
+      )
+    })
+  })
 
-  describe(".toTwos", () => {
+  describe('.toTwos', () => {
     it("should convert from negative number to two's complement", () => {
-      expect(new BigNumber(0).toTwos(32).toString(16)).toEqual("0");
-      expect(new BigNumber(1).toTwos(32).toString(16)).toEqual("1");
+      expect(new BigNumber(0).toTwos(32).toString(16)).toEqual('0')
+      expect(new BigNumber(1).toTwos(32).toString(16)).toEqual('1')
       expect(new BigNumber(2147483647).toTwos(32).toString(16)).toEqual(
-        "7fffffff"
-      );
-      expect(new BigNumber("-2147483648", 10).toTwos(32).toString(16)).toEqual(
-        "80000000"
-      );
-      expect(new BigNumber("-268435456", 10).toTwos(32).toString(16)).toEqual(
-        "f0000000"
-      );
-      expect(new BigNumber("-249346713", 10).toTwos(32).toString(16)).toEqual(
-        "f1234567"
-      );
-      expect(new BigNumber("-1", 10).toTwos(32).toString(16)).toEqual(
-        "ffffffff"
-      );
-      expect(new BigNumber("-2", 10).toTwos(32).toString(16)).toEqual(
-        "fffffffe"
-      );
-      expect(new BigNumber("-2", 10).toTwos(128).toString(16)).toEqual(
-        "fffffffffffffffffffffffffffffffe"
-      );
-      expect(new BigNumber("-2", 10).toTwos(256).toString(16)).toEqual(
-        "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
-      );
-      expect(new BigNumber("-1", 10).toTwos(256).toString(16)).toEqual(
-        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-      );
+        '7fffffff'
+      )
+      expect(new BigNumber('-2147483648', 10).toTwos(32).toString(16)).toEqual(
+        '80000000'
+      )
+      expect(new BigNumber('-268435456', 10).toTwos(32).toString(16)).toEqual(
+        'f0000000'
+      )
+      expect(new BigNumber('-249346713', 10).toTwos(32).toString(16)).toEqual(
+        'f1234567'
+      )
+      expect(new BigNumber('-1', 10).toTwos(32).toString(16)).toEqual(
+        'ffffffff'
+      )
+      expect(new BigNumber('-2', 10).toTwos(32).toString(16)).toEqual(
+        'fffffffe'
+      )
+      expect(new BigNumber('-2', 10).toTwos(128).toString(16)).toEqual(
+        'fffffffffffffffffffffffffffffffe'
+      )
+      expect(new BigNumber('-2', 10).toTwos(256).toString(16)).toEqual(
+        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe'
+      )
+      expect(new BigNumber('-1', 10).toTwos(256).toString(16)).toEqual(
+        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+      )
       expect(
         new BigNumber(
-          "5789604461865809771178549250434395392663" +
-            "4992332820282019728792003956564819967",
+          '5789604461865809771178549250434395392663' +
+            '4992332820282019728792003956564819967',
           10
         )
           .toTwos(256)
           .toString(16)
       ).toEqual(
-        "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-      );
+        '7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+      )
       expect(
         new BigNumber(
-          "-578960446186580977117854925043439539266" +
-            "34992332820282019728792003956564819968",
+          '-578960446186580977117854925043439539266' +
+            '34992332820282019728792003956564819968',
           10
         )
           .toTwos(256)
           .toString(16)
       ).toEqual(
-        "8000000000000000000000000000000000000000000000000000000000000000"
-      );
-    });
-  });
+        '8000000000000000000000000000000000000000000000000000000000000000'
+      )
+    })
+  })
 
-  describe(".isBN", () => {
-    it("should return true for BN", () => {
-      expect(BigNumber.isBN(new BigNumber())).toEqual(true);
-    });
+  describe('.isBN', () => {
+    it('should return true for BN', () => {
+      expect(BigNumber.isBN(new BigNumber())).toEqual(true)
+    })
 
-    it("should return false for everything else", () => {
-      expect(BigNumber.isBN(1)).toEqual(false);
-      expect(BigNumber.isBN([])).toEqual(false);
-      expect(BigNumber.isBN({})).toEqual(false);
-    });
-  });
-});
+    it('should return false for everything else', () => {
+      expect(BigNumber.isBN(1)).toEqual(false)
+      expect(BigNumber.isBN([])).toEqual(false)
+      expect(BigNumber.isBN({})).toEqual(false)
+    })
+  })
+})