@bsv/sdk 1.3.12 → 1.3.14

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

@@ -1,5 +1,5 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import { toArray, encode } from '../../../dist/cjs/src/primitives/utils'
+import BigNumber from '../../primitives/BigNumber'
+import { toArray, encode } from '../../primitives/utils'
 
 describe('BigNumber/Serializers', () => {
   describe('#fromJSON', () => {
@@ -62,7 +62,9 @@ describe('BigNumber/Serializers', () => {
       expect(BigNumber.fromBits(0x04003456).toHex()).toEqual('345600')
       expect(BigNumber.fromBits(0x05003456).toHex()).toEqual('34560000')
       expect(BigNumber.fromBits(0x05f03456).ltn(0)).toEqual(true) // sign bit set
-      expect(() => BigNumber.fromBits(0x05f03456, true)).toThrow('negative bit set')
+      expect(() => BigNumber.fromBits(0x05f03456, true)).toThrow(
+        'negative bit set'
+      )
       expect(BigNumber.fromBits(0x04923456).ltn(0)).toEqual(true)
     })
   })
@@ -122,24 +124,48 @@ describe('BigNumber/Serializers', () => {
 
   describe('#fromScriptNum', () => {
     it('should parse this normal number', () => {
-      expect(BigNumber.fromScriptNum(toArray('01', 'hex')).toNumber()).toEqual(1)
-      expect(BigNumber.fromScriptNum(toArray('0080', 'hex')).toNumber()).toEqual(0)
-      expect(BigNumber.fromScriptNum(toArray('0180', 'hex')).toNumber()).toEqual(-1)
+      expect(BigNumber.fromScriptNum(toArray('01', 'hex')).toNumber()).toEqual(
+        1
+      )
+      expect(
+        BigNumber.fromScriptNum(toArray('0080', 'hex')).toNumber()
+      ).toEqual(0)
+      expect(
+        BigNumber.fromScriptNum(toArray('0180', 'hex')).toNumber()
+      ).toEqual(-1)
     })
 
     it('should allow a number over 4 bytes', () => {
-      expect(() => BigNumber.fromScriptNum(toArray('8100000000', 'hex'))).not.toThrow('script number overflow')
+      expect(() =>
+        BigNumber.fromScriptNum(toArray('8100000000', 'hex'))
+      ).not.toThrow('script number overflow')
     })
 
     it('should throw an error for number that is not a minimal size representation', () => {
-      expect(() => BigNumber.fromScriptNum(toArray('80000000', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(() => BigNumber.fromScriptNum(toArray('800000', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(() => BigNumber.fromScriptNum(toArray('00', 'hex'), true)).toThrow('non-minimally encoded script number')
-      expect(BigNumber.fromScriptNum(toArray('8000', 'hex'), true).toString()).toEqual('128')
-      expect(BigNumber.fromScriptNum(toArray('0081', 'hex'), true).toString()).toEqual('-256')
-      expect(BigNumber.fromScriptNum(toArray('', 'hex'), true).toString()).toEqual('0')
-      expect(BigNumber.fromScriptNum(toArray('01', 'hex'), true).toString()).toEqual('1')
-      expect(BigNumber.fromScriptNum(toArray('00000000', 'hex')).toString()).toEqual('0')
+      expect(() =>
+        BigNumber.fromScriptNum(toArray('80000000', 'hex'), true)
+      ).toThrow('non-minimally encoded script number')
+      expect(() =>
+        BigNumber.fromScriptNum(toArray('800000', 'hex'), true)
+      ).toThrow('non-minimally encoded script number')
+      expect(() => BigNumber.fromScriptNum(toArray('00', 'hex'), true)).toThrow(
+        'non-minimally encoded script number'
+      )
+      expect(
+        BigNumber.fromScriptNum(toArray('8000', 'hex'), true).toString()
+      ).toEqual('128')
+      expect(
+        BigNumber.fromScriptNum(toArray('0081', 'hex'), true).toString()
+      ).toEqual('-256')
+      expect(
+        BigNumber.fromScriptNum(toArray('', 'hex'), true).toString()
+      ).toEqual('0')
+      expect(
+        BigNumber.fromScriptNum(toArray('01', 'hex'), true).toString()
+      ).toEqual('1')
+      expect(
+        BigNumber.fromScriptNum(toArray('00000000', 'hex')).toString()
+      ).toEqual('0')
     })
   })
 

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

@@ -1,5 +1,5 @@
 /* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('BN.js/Utils', () => {
   describe('.toString()', () => {
@@ -42,7 +42,8 @@ describe('BN.js/Utils', () => {
       it('should have length of 64 from leading 15', () => {
         const a = new BigNumber(
           'ffb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
-          16)
+          16
+        )
 
         expect(a.toString('hex', 2).length).toEqual(64)
       })
@@ -50,7 +51,8 @@ describe('BN.js/Utils', () => {
       it('should have length of 64 from leading zero', () => {
         const a = new BigNumber(
           'fb96ff654e61130ba8422f0debca77a0ea74ae5ea8bca9b54ab64aabf01003',
-          16)
+          16
+        )
 
         expect(a.toString('hex', 64).length).toEqual(64)
       })
@@ -154,13 +156,21 @@ describe('BN.js/Utils', () => {
       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(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(-0x10000000000000).toNumber()).toEqual(-0x10000000000000)
-      expect(new BigNumber(-0x10040004004000).toNumber()).toEqual(-0x10040004004000)
+      expect(new BigNumber(-0x10000000000000).toNumber()).toEqual(
+        -0x10000000000000
+      )
+      expect(new BigNumber(-0x10040004004000).toNumber()).toEqual(
+        -0x10040004004000
+      )
     })
 
     it('should throw when number exceeds 53 bits', () => {
@@ -216,9 +226,13 @@ describe('BN.js/Utils', () => {
       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(0x3ffffff))).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(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)
@@ -280,56 +294,132 @@ describe('BN.js/Utils', () => {
   })
 
   describe('.fromTwos', () => {
-    it('should convert from two\'s complement to negative number', () => {
+    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(2147483647)
-      expect(new BigNumber('80000000', 16).fromTwos(32).toNumber()).toEqual(-2147483648)
-      expect(new BigNumber('f0000000', 16).fromTwos(32).toNumber()).toEqual(-268435456)
-      expect(new BigNumber('f1234567', 16).fromTwos(32).toNumber()).toEqual(-249346713)
+      expect(new BigNumber('7fffffff', 16).fromTwos(32).toNumber()).toEqual(
+        2147483647
+      )
+      expect(new BigNumber('80000000', 16).fromTwos(32).toNumber()).toEqual(
+        -2147483648
+      )
+      expect(new BigNumber('f0000000', 16).fromTwos(32).toNumber()).toEqual(
+        -268435456
+      )
+      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('fffffffffffffffffffffffffffffffe', 16)
-        .fromTwos(128).toNumber()).toEqual(-2)
-      expect(new BigNumber('ffffffffffffffffffffffffffffffff' +
-        'fffffffffffffffffffffffffffffffe', 16).fromTwos(256).toNumber()).toEqual(-2)
-      expect(new BigNumber('ffffffffffffffffffffffffffffffff' +
-        'ffffffffffffffffffffffffffffffff', 16).fromTwos(256).toNumber()).toEqual(-1)
       expect(
-        new BigNumber('7fffffffffffffffffffffffffffffff' +
-        'ffffffffffffffffffffffffffffffff', 16).fromTwos(256).toString(10)).toEqual(new BigNumber('5789604461865809771178549250434395392663499' +
-        '2332820282019728792003956564819967', 10).toString(10))
+        new BigNumber('fffffffffffffffffffffffffffffffe', 16)
+          .fromTwos(128)
+          .toNumber()
+      ).toEqual(-2)
       expect(
-        new BigNumber('80000000000000000000000000000000' +
-        '00000000000000000000000000000000', 16).fromTwos(256).toString(10)).toEqual(new BigNumber('-578960446186580977117854925043439539266349' +
-        '92332820282019728792003956564819968', 10).toString(10))
+        new BigNumber(
+          'ffffffffffffffffffffffffffffffff' +
+            'fffffffffffffffffffffffffffffffe',
+          16
+        )
+          .fromTwos(256)
+          .toNumber()
+      ).toEqual(-2)
+      expect(
+        new BigNumber(
+          'ffffffffffffffffffffffffffffffff' +
+            'ffffffffffffffffffffffffffffffff',
+          16
+        )
+          .fromTwos(256)
+          .toNumber()
+      ).toEqual(-1)
+      expect(
+        new BigNumber(
+          '7fffffffffffffffffffffffffffffff' +
+            'ffffffffffffffffffffffffffffffff',
+          16
+        )
+          .fromTwos(256)
+          .toString(10)
+      ).toEqual(
+        new BigNumber(
+          '5789604461865809771178549250434395392663499' +
+            '2332820282019728792003956564819967',
+          10
+        ).toString(10)
+      )
+      expect(
+        new BigNumber(
+          '80000000000000000000000000000000' +
+            '00000000000000000000000000000000',
+          16
+        )
+          .fromTwos(256)
+          .toString(10)
+      ).toEqual(
+        new BigNumber(
+          '-578960446186580977117854925043439539266349' +
+            '92332820282019728792003956564819968',
+          10
+        ).toString(10)
+      )
     })
   })
 
   describe('.toTwos', () => {
-    it('should convert from negative number to two\'s complement', () => {
+    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(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(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')
+        'fffffffffffffffffffffffffffffffe'
+      )
       expect(new BigNumber('-2', 10).toTwos(256).toString(16)).toEqual(
-        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe')
+        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe'
+      )
       expect(new BigNumber('-1', 10).toTwos(256).toString(16)).toEqual(
-        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+      )
       expect(
-        new BigNumber('5789604461865809771178549250434395392663' +
-        '4992332820282019728792003956564819967', 10).toTwos(256).toString(16)).toEqual(
-        '7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
+        new BigNumber(
+          '5789604461865809771178549250434395392663' +
+            '4992332820282019728792003956564819967',
+          10
+        )
+          .toTwos(256)
+          .toString(16)
+      ).toEqual(
+        '7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+      )
       expect(
-        new BigNumber('-578960446186580977117854925043439539266' +
-        '34992332820282019728792003956564819968', 10).toTwos(256).toString(16)).toEqual(
-        '8000000000000000000000000000000000000000000000000000000000000000')
+        new BigNumber(
+          '-578960446186580977117854925043439539266' +
+            '34992332820282019728792003956564819968',
+          10
+        )
+          .toTwos(256)
+          .toString(16)
+      ).toEqual(
+        '8000000000000000000000000000000000000000000000000000000000000000'
+      )
     })
   })
 

package/src/primitives/__tests/Curve.unit.test.ts

@@ -1,8 +1,8 @@
 /* eslint-env jest */
-import Curve from '../../../dist/cjs/src/primitives/Curve.js'
-import Point from '../../../dist/cjs/src/primitives/Point'
-import JPoint from '../../../dist/cjs/src/primitives/JacobianPoint'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+import Point from '../../primitives/Point'
+import JPoint from '../../primitives/JacobianPoint'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('Curve', () => {
   it('should work with secp256k1', () => {
@@ -16,16 +16,21 @@ describe('Curve', () => {
     expect(p.validate()).toBe(true)
     expect(p.dbl().validate()).toBe(true)
     expect(p.toJ().dbl().toP().validate()).toBe(true)
-    expect(p.mul(new BigNumber('79be667e f9dcbbac 55a06295 ce870b07', 16)).validate()).toBe(true)
+    expect(
+      p.mul(new BigNumber('79be667e f9dcbbac 55a06295 ce870b07', 16)).validate()
+    ).toBe(true)
 
     // Endomorphism test
+    if (curve.endo === null || curve.endo === undefined) {
+      throw new Error('curve.endo is undefined')
+    }
     expect(curve.endo).toBeDefined()
-    expect(
-      curve.endo.beta.fromRed().toString(16)
-    ).toEqual('7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee')
-    expect(
-      curve.endo.lambda.toString(16)
-    ).toEqual('5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72')
+    expect(curve.endo.beta.fromRed().toString(16)).toEqual(
+      '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'
+    )
+    expect(curve.endo.lambda.toString(16)).toEqual(
+      '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72'
+    )
 
     const k = new BigNumber('1234567890123456789012345678901234', 16)
     const split = curve._endoSplit(k)
@@ -41,7 +46,10 @@ describe('Curve', () => {
     const g2 = new Point(g1.getX(), g1.getY()) // not precomputed g
     expect(g2.precomputed).toBeNull()
 
-    const a = new BigNumber('6d1229a6b24c2e775c062870ad26bc261051e0198c67203167273c7c62538846', 16)
+    const a = new BigNumber(
+      '6d1229a6b24c2e775c062870ad26bc261051e0198c67203167273c7c62538846',
+      16
+    )
     const p1 = g1.mul(a)
     const p2 = g2.mul(a)
 
@@ -57,8 +65,9 @@ describe('Curve', () => {
 
     const a = new BigNumber(
       '6d1229a6b24c2e775c062870ad26bc26' +
-            '1051e0198c67203167273c7c6253884612345678',
-      16)
+        '1051e0198c67203167273c7c6253884612345678',
+      16
+    )
     const p1 = g1.mul(a)
     const p2 = g2.mul(a)
 
@@ -67,8 +76,14 @@ describe('Curve', () => {
 
   it('should not fail on secp256k1 regression', () => {
     const curve = new Curve()
-    const k1 = new BigNumber('32efeba414cd0c830aed727749e816a01c471831536fd2fce28c56b54f5a3bb1', 16)
-    const k2 = new BigNumber('5f2e49b5d64e53f9811545434706cde4de528af97bfd49fde1f6cf792ee37a8c', 16)
+    const k1 = new BigNumber(
+      '32efeba414cd0c830aed727749e816a01c471831536fd2fce28c56b54f5a3bb1',
+      16
+    )
+    const k2 = new BigNumber(
+      '5f2e49b5d64e53f9811545434706cde4de528af97bfd49fde1f6cf792ee37a8c',
+      16
+    )
 
     let p1 = curve.g.mul(k1)
     let p2 = curve.g.mul(k2)
@@ -90,21 +105,17 @@ describe('Curve', () => {
   })
 
   test('should correctly double the affine point on secp256k1', () => {
-    let bad: any = {
-      x: '026a2073b1ef6fab47ace18e60e728a05180a82755bbcec9a0abc08ad9f7a3d4',
-      y: '9cd8cb48c3281596139f147c1364a3ede88d3f310fdb0eb98c924e599ca1b3c9',
-      z: 'd78587ad45e4102f48b54b5d85598296e069ce6085002e169c6bad78ddc6d9bd'
-    }
-
-    let good: any = {
-      x: 'e7789226739ac2eb3c7ccb2a9a910066beeed86cdb4e0f8a7fee8eeb29dc7016',
-      y: '4b76b191fd6d47d07828ea965e275b76d0e3e0196cd5056d38384fbb819f9fcb',
-      z: 'cbf8d99056618ba132d6145b904eee1ce566e0feedb9595139c45f84e90cfa7d'
-    }
+    const bad = new JPoint(
+      new BigNumber('026a2073b1ef6fab47ace18e60e728a05180a82755bbcec9a0abc08ad9f7a3d4', 16),
+      new BigNumber('9cd8cb48c3281596139f147c1364a3ede88d3f310fdb0eb98c924e599ca1b3c9', 16),
+      new BigNumber('d78587ad45e4102f48b54b5d85598296e069ce6085002e169c6bad78ddc6d9bd', 16)
+    )
 
-    // const curve = new Curve()
-    bad = new JPoint(bad.x, bad.y, bad.z)
-    good = new JPoint(good.x, good.y, good.z)
+    const good = new JPoint(
+      new BigNumber('e7789226739ac2eb3c7ccb2a9a910066beeed86cdb4e0f8a7fee8eeb29dc7016', 16),
+      new BigNumber('4b76b191fd6d47d07828ea965e275b76d0e3e0196cd5056d38384fbb819f9fcb', 16),
+      new BigNumber('cbf8d99056618ba132d6145b904eee1ce566e0feedb9595139c45f84e90cfa7d', 16)
+    )
 
     // They are the same points
     expect(bad.add(good.neg()).isInfinity()).toBe(true)
@@ -122,9 +133,17 @@ describe('Curve', () => {
 })
 
 describe('Point codec', () => {
-  const makeShortTest = (definition: any): any => {
-    const curve = new Curve()
+  interface PointDefinition {
+    coordinates: {
+      x: string
+      y: string
+    }
+    compactEncoded: string
+    encoded: string
+    hybrid: string
+  }
 
+  const makeShortTest = (definition: PointDefinition): () => void => {
     return () => {
       const co = definition.coordinates
       const p = new Point(co.x, co.y)
@@ -146,16 +165,15 @@ describe('Point codec', () => {
       y: '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
     },
     compactEncoded:
-        '02' +
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+      '02' + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
     encoded:
-        '04' +
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
-        '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+      '04' +
+      '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+      '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
     hybrid:
-        '06' +
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
-        '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
+      '06' +
+      '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+      '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'
   }
 
   const shortPointOddY = {
@@ -164,29 +182,33 @@ describe('Point codec', () => {
       y: 'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
     },
     compactEncoded:
-        '03' +
-        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
+      '03' + 'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556',
     encoded:
-        '04' +
-        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
-        'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297',
+      '04' +
+      'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+      'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297',
     hybrid:
-        '07' +
-        'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
-        'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
+      '07' +
+      'fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a1460297556' +
+      'ae12777aacfbb620f3be96017f45c560de80f0f6518fe4a03c870c36b075f297'
   }
 
   it('should throw when trying to decode random bytes', () => {
     expect(() => {
       Point.fromString(
         '05' +
-        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')
+          '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'
+      )
     }).toThrow()
   })
 
-  it('should be able to encode/decode a short curve point with even Y',
-    makeShortTest(shortPointEvenY))
+  it(
+    'should be able to encode/decode a short curve point with even Y',
+    makeShortTest(shortPointEvenY)
+  )
 
-  it('should be able to encode/decode a short curve point with odd Y',
-    makeShortTest(shortPointOddY))
+  it(
+    'should be able to encode/decode a short curve point with odd Y',
+    makeShortTest(shortPointOddY)
+  )
 })

package/src/primitives/__tests/DRBG.test.ts

@@ -1,4 +1,4 @@
-import DRBG from '../../../dist/cjs/src/primitives/DRBG'
+import DRBG from '../../primitives/DRBG'
 import DRBGVectors from './DRBG.vectors'
 
 describe('Hmac_DRBG', () => {