@bsv/sdk 1.3.12 → 1.3.14

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

@@ -1,29 +1,45 @@
 /* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('BN.js/Binary', function () {
   describe('.shl()', function () {
     it('should shl numbers', function () {
-      expect(new BigNumber('69527932928').shln(13).toString(16)).toEqual('2060602000000')
-      expect(new BigNumber('69527932928').shln(45).toString(16)).toEqual('206060200000000000000')
+      expect(new BigNumber('69527932928').shln(13).toString(16)).toEqual(
+        '2060602000000'
+      )
+      expect(new BigNumber('69527932928').shln(45).toString(16)).toEqual(
+        '206060200000000000000'
+      )
     })
 
     it('should ushl numbers', function () {
-      expect(new BigNumber('69527932928').ushln(13).toString(16)).toEqual('2060602000000')
-      expect(new BigNumber('69527932928').ushln(45).toString(16)).toEqual('206060200000000000000')
+      expect(new BigNumber('69527932928').ushln(13).toString(16)).toEqual(
+        '2060602000000'
+      )
+      expect(new BigNumber('69527932928').ushln(45).toString(16)).toEqual(
+        '206060200000000000000'
+      )
     })
   })
 
   describe('.shr()', function () {
     it('should shr numbers', function () {
-      expect(new BigNumber('69527932928').shrn(13).toString(16)).toEqual('818180')
-      expect(new BigNumber('69527932928').shrn(17).toString(16)).toEqual('81818')
+      expect(new BigNumber('69527932928').shrn(13).toString(16)).toEqual(
+        '818180'
+      )
+      expect(new BigNumber('69527932928').shrn(17).toString(16)).toEqual(
+        '81818'
+      )
       expect(new BigNumber('69527932928').shrn(256).toString(16)).toEqual('0')
     })
 
     it('should ushr numbers', function () {
-      expect(new BigNumber('69527932928').ushrn(13).toString(16)).toEqual('818180')
-      expect(new BigNumber('69527932928').ushrn(17).toString(16)).toEqual('81818')
+      expect(new BigNumber('69527932928').ushrn(13).toString(16)).toEqual(
+        '818180'
+      )
+      expect(new BigNumber('69527932928').ushrn(17).toString(16)).toEqual(
+        '81818'
+      )
       expect(new BigNumber('69527932928').ushrn(256).toString(16)).toEqual('0')
     })
   })
@@ -32,9 +48,13 @@ describe('BN.js/Binary', function () {
     it('should increment bit', function () {
       expect(new BigNumber(0).bincn(1).toString(16)).toEqual('2')
       expect(new BigNumber(2).bincn(1).toString(16)).toEqual('4')
-      expect(new BigNumber(2).bincn(1).bincn(1).toString(16)).toEqual(new BigNumber(2).bincn(2).toString(16))
+      expect(new BigNumber(2).bincn(1).bincn(1).toString(16)).toEqual(
+        new BigNumber(2).bincn(2).toString(16)
+      )
       expect(new BigNumber(0xffffff).bincn(1).toString(16)).toEqual('1000001')
-      expect(new BigNumber(2).bincn(63).toString(16)).toEqual('8000000000000002')
+      expect(new BigNumber(2).bincn(63).toString(16)).toEqual(
+        '8000000000000002'
+      )
     })
   })
 
@@ -42,9 +62,15 @@ describe('BN.js/Binary', function () {
     it('should mask bits in-place', function () {
       expect(new BigNumber(0).imaskn(1).toString(16)).toEqual('0')
       expect(new BigNumber(3).imaskn(1).toString(16)).toEqual('1')
-      expect(new BigNumber('123456789', 16).imaskn(4).toString(16)).toEqual('9')
-      expect(new BigNumber('123456789', 16).imaskn(16).toString(16)).toEqual('6789')
-      expect(new BigNumber('123456789', 16).imaskn(28).toString(16)).toEqual('3456789')
+      expect(new BigNumber('123456789', 16).imaskn(4).toString(16)).toEqual(
+        '9'
+      )
+      expect(new BigNumber('123456789', 16).imaskn(16).toString(16)).toEqual(
+        '6789'
+      )
+      expect(new BigNumber('123456789', 16).imaskn(28).toString(16)).toEqual(
+        '3456789'
+      )
     })
 
     it('should not mask when number is bigger than length', function () {
@@ -70,7 +96,8 @@ describe('BN.js/Binary', function () {
         expect(bn.testn(bl)).toEqual(false)
       })
 
-      const xbits = '01111001010111001001000100011101' +
+      const xbits =
+        '01111001010111001001000100011101' +
         '11010011101100011000111001011101' +
         '10010100111000000001011000111101' +
         '01011111001111100100011110000010' +
@@ -94,110 +121,164 @@ describe('BN.js/Binary', function () {
 
   describe('.and()', function () {
     it('should and numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .and(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('0')
+      expect(
+        new BigNumber('1010101010101010101010101010101010101010', 2)
+          .and(new BigNumber('101010101010101010101010101010101010101', 2))
+          .toString(2)
+      ).toEqual('0')
     })
 
     it('should and numbers of different limb-length', function () {
       expect(
         new BigNumber('abcd0000ffff', 16)
-          .and(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd')
+          .and(new BigNumber('abcd', 16))
+          .toString(16)
+      ).toEqual('abcd')
     })
   })
 
   describe('.iand()', function () {
     it('should iand numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .iand(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('0')
-      expect(new BigNumber('1000000000000000000000000000000000000001', 2)
-        .iand(new BigNumber('1', 2))
-        .toString(2)).toEqual('1')
-      expect(new BigNumber('1', 2)
-        .iand(new BigNumber('1000000000000000000000000000000000000001', 2))
-        .toString(2)).toEqual('1')
+      expect(
+        new BigNumber('1010101010101010101010101010101010101010', 2)
+          .iand(new BigNumber('101010101010101010101010101010101010101', 2))
+          .toString(2)
+      ).toEqual('0')
+      expect(
+        new BigNumber('1000000000000000000000000000000000000001', 2)
+          .iand(new BigNumber('1', 2))
+          .toString(2)
+      ).toEqual('1')
+      expect(
+        new BigNumber('1', 2)
+          .iand(new BigNumber('1000000000000000000000000000000000000001', 2))
+          .toString(2)
+      ).toEqual('1')
     })
   })
 
   describe('.or()', function () {
     it('should or numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .or(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('1111111111111111111111111111111111111111')
+      expect(
+        new BigNumber('1010101010101010101010101010101010101010', 2)
+          .or(new BigNumber('101010101010101010101010101010101010101', 2))
+          .toString(2)
+      ).toEqual('1111111111111111111111111111111111111111')
     })
 
     it('should or numbers of different limb-length', function () {
       expect(
         new BigNumber('abcd00000000', 16)
-          .or(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd0000abcd')
+          .or(new BigNumber('abcd', 16))
+          .toString(16)
+      ).toEqual('abcd0000abcd')
     })
   })
 
   describe('.ior()', function () {
     it('should ior numbers', function () {
-      expect(new BigNumber('1010101010101010101010101010101010101010', 2)
-        .ior(new BigNumber('101010101010101010101010101010101010101', 2))
-        .toString(2)).toEqual('1111111111111111111111111111111111111111')
-      expect(new BigNumber('1000000000000000000000000000000000000000', 2)
-        .ior(new BigNumber('1', 2))
-        .toString(2)).toEqual('1000000000000000000000000000000000000001')
-      expect(new BigNumber('1', 2)
-        .ior(new BigNumber('1000000000000000000000000000000000000000', 2))
-        .toString(2)).toEqual('1000000000000000000000000000000000000001')
+      expect(
+        new BigNumber('1010101010101010101010101010101010101010', 2)
+          .ior(new BigNumber('101010101010101010101010101010101010101', 2))
+          .toString(2)
+      ).toEqual('1111111111111111111111111111111111111111')
+      expect(
+        new BigNumber('1000000000000000000000000000000000000000', 2)
+          .ior(new BigNumber('1', 2))
+          .toString(2)
+      ).toEqual('1000000000000000000000000000000000000001')
+      expect(
+        new BigNumber('1', 2)
+          .ior(new BigNumber('1000000000000000000000000000000000000000', 2))
+          .toString(2)
+      ).toEqual('1000000000000000000000000000000000000001')
     })
   })
 
   describe('.xor()', function () {
     it('should xor numbers', function () {
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .xor(new BigNumber('1100110011001100110011001100110', 2))
-        .toString(2)).toEqual('10101010101010101010101010101010')
+      expect(
+        new BigNumber('11001100110011001100110011001100', 2)
+          .xor(new BigNumber('1100110011001100110011001100110', 2))
+          .toString(2)
+      ).toEqual('10101010101010101010101010101010')
     })
   })
 
   describe('.ixor()', function () {
     it('should ixor numbers', function () {
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .ixor(new BigNumber('1100110011001100110011001100110', 2))
-        .toString(2)).toEqual('10101010101010101010101010101010')
-      expect(new BigNumber('11001100110011001100110011001100', 2)
-        .ixor(new BigNumber('1', 2))
-        .toString(2)).toEqual('11001100110011001100110011001101')
-      expect(new BigNumber('1', 2)
-        .ixor(new BigNumber('11001100110011001100110011001100', 2))
-        .toString(2)).toEqual('11001100110011001100110011001101')
+      expect(
+        new BigNumber('11001100110011001100110011001100', 2)
+          .ixor(new BigNumber('1100110011001100110011001100110', 2))
+          .toString(2)
+      ).toEqual('10101010101010101010101010101010')
+      expect(
+        new BigNumber('11001100110011001100110011001100', 2)
+          .ixor(new BigNumber('1', 2))
+          .toString(2)
+      ).toEqual('11001100110011001100110011001101')
+      expect(
+        new BigNumber('1', 2)
+          .ixor(new BigNumber('11001100110011001100110011001100', 2))
+          .toString(2)
+      ).toEqual('11001100110011001100110011001101')
     })
 
     it('should and numbers of different limb-length', function () {
       expect(
         new BigNumber('abcd0000ffff', 16)
-          .ixor(new BigNumber('abcd', 16)).toString(16)).toEqual('abcd00005432')
+          .ixor(new BigNumber('abcd', 16))
+          .toString(16)
+      ).toEqual('abcd00005432')
     })
   })
 
   describe('.setn()', function () {
     it('should allow single bits to be set', function () {
       expect(new BigNumber(0).setn(2, true).toString(2)).toEqual('100')
-      expect(new BigNumber(0).setn(27, true).toString(2)).toEqual('1000000000000000000000000000')
-      expect(new BigNumber(0).setn(63, true).toString(16)).toEqual(new BigNumber(1).iushln(63).toString(16))
-      expect(new BigNumber('1000000000000000000000000001', 2).setn(27, false).toString(2)).toEqual('1')
+      expect(new BigNumber(0).setn(27, true).toString(2)).toEqual(
+        '1000000000000000000000000000'
+      )
+      expect(new BigNumber(0).setn(63, true).toString(16)).toEqual(
+        new BigNumber(1).iushln(63).toString(16)
+      )
+      expect(
+        new BigNumber('1000000000000000000000000001', 2)
+          .setn(27, false)
+          .toString(2)
+      ).toEqual('1')
       expect(new BigNumber('101', 2).setn(2, false).toString(2)).toEqual('1')
     })
   })
 
   describe('.notn()', function () {
     it('should allow bitwise negation', function () {
-      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual('111000')
-      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual('111000111')
-      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual('111000')
-      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual('111000111')
-      expect(new BigNumber('111000111', 2).notn(32).toString(2)).toEqual('11111111111111111111111000111000')
-      expect(new BigNumber('000111000', 2).notn(32).toString(2)).toEqual('11111111111111111111111111000111')
-      expect(new BigNumber('111000111', 2).notn(68).toString(2)).toEqual('11111111111111111111111111111111' +
-        '111111111111111111111111111000111000')
-      expect(new BigNumber('000111000', 2).notn(68).toString(2)).toEqual('11111111111111111111111111111111' +
-        '111111111111111111111111111111000111')
+      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual(
+        '111000'
+      )
+      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual(
+        '111000111'
+      )
+      expect(new BigNumber('111000111', 2).notn(9).toString(2)).toEqual(
+        '111000'
+      )
+      expect(new BigNumber('000111000', 2).notn(9).toString(2)).toEqual(
+        '111000111'
+      )
+      expect(new BigNumber('111000111', 2).notn(32).toString(2)).toEqual(
+        '11111111111111111111111000111000'
+      )
+      expect(new BigNumber('000111000', 2).notn(32).toString(2)).toEqual(
+        '11111111111111111111111111000111'
+      )
+      expect(new BigNumber('111000111', 2).notn(68).toString(2)).toEqual(
+        '11111111111111111111111111111111' +
+          '111111111111111111111111111000111000'
+      )
+      expect(new BigNumber('000111000', 2).notn(68).toString(2)).toEqual(
+        '11111111111111111111111111111111' +
+          '111111111111111111111111111111000111'
+      )
     })
   })
 })

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

@@ -1,4 +1,4 @@
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import BigNumber from '../../primitives/BigNumber'
 
 describe('BN.js/Constructor', () => {
   describe('with Smi input', () => {
@@ -29,14 +29,20 @@ describe('BN.js/Constructor', () => {
     })
 
     it('should accept two-limb LE number', () => {
-      expect(new BigNumber(0x4123456, undefined, 'le').toString(16)).toEqual('56341204')
+      expect(new BigNumber(0x4123456, undefined, 'le').toString(16)).toEqual(
+        '56341204'
+      )
     })
   })
 
   describe('with String input', () => {
     it('should accept base-16', () => {
-      expect(new BigNumber('1A6B765D8CDF', 16).toString(16)).toEqual('1a6b765d8cdf')
-      expect(new BigNumber('1A6B765D8CDF', 16).toString()).toEqual('29048849665247')
+      expect(new BigNumber('1A6B765D8CDF', 16).toString(16)).toEqual(
+        '1a6b765d8cdf'
+      )
+      expect(new BigNumber('1A6B765D8CDF', 16).toString()).toEqual(
+        '29048849665247'
+      )
     })
 
     it('should accept base-hex', () => {
@@ -45,7 +51,9 @@ describe('BN.js/Constructor', () => {
 
     it('should accept base-16 with spaces', () => {
       const num = 'a89c e5af8724 c0a23e0e 0ff77500'
-      expect(new BigNumber(num, 16).toString(16)).toEqual(num.replace(/ /g, ''))
+      expect(new BigNumber(num, 16).toString(16)).toEqual(
+        num.replace(/ /g, '')
+      )
     })
 
     it('should accept long base-16', () => {
@@ -55,11 +63,15 @@ describe('BN.js/Constructor', () => {
 
     it('should accept positive base-10', () => {
       expect(new BigNumber('10654321').toString()).toEqual('10654321')
-      expect(new BigNumber('29048849665247').toString(16)).toEqual('1a6b765d8cdf')
+      expect(new BigNumber('29048849665247').toString(16)).toEqual(
+        '1a6b765d8cdf'
+      )
     })
 
     it('should accept negative base-10', () => {
-      expect(new BigNumber('-29048849665247').toString(16)).toEqual('-1a6b765d8cdf')
+      expect(new BigNumber('-29048849665247').toString(16)).toEqual(
+        '-1a6b765d8cdf'
+      )
     })
 
     it('should accept long base-10', () => {
@@ -74,18 +86,21 @@ describe('BN.js/Constructor', () => {
 
     it('should accept base-36', () => {
       const base36 = 'zzZzzzZzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz'
-      expect(new BigNumber(base36, 36).toString(36)).toEqual(base36.toLowerCase())
+      expect(new BigNumber(base36, 36).toString(36)).toEqual(
+        base36.toLowerCase()
+      )
     })
 
     it('should not overflow limbs during base-10', () => {
-      const num = '65820182292848241686198767302293' +
-        '20890292528855852623664389292032'
+      const num =
+        '65820182292848241686198767302293' + '20890292528855852623664389292032'
       expect(new BigNumber(num).words[0]).toBeLessThan(0x4000000)
     })
 
     it('should accept base-16 LE integer', () => {
-      expect(new BigNumber('1A6B765D8CDF', 16, 'le').toString(16))
-        .toEqual('df8c5d766b1a')
+      expect(new BigNumber('1A6B765D8CDF', 16, 'le').toString(16)).toEqual(
+        'df8c5d766b1a'
+      )
     })
 
     it('should accept base-16 LE integer with leading zeros', () => {
@@ -139,38 +154,63 @@ describe('BN.js/Constructor', () => {
       expect(new BigNumber([1, 2, 3, 4]).toString(16)).toEqual('1020304')
       expect(new BigNumber([1, 2, 3, 4, 5]).toString(16)).toEqual('102030405')
       expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toString(16)).toEqual(
-        '102030405060708')
-      expect(new BigNumber([1, 2, 3, 4]).toArray().join(',')).toEqual('1,2,3,4')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray().join(',')).toEqual('1,2,3,4,5,6,7,8')
+        '102030405060708'
+      )
+      expect(new BigNumber([1, 2, 3, 4]).toArray().join(',')).toEqual(
+        '1,2,3,4'
+      )
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray().join(',')
+      ).toEqual('1,2,3,4,5,6,7,8')
     })
 
     it('should import little endian', () => {
       expect(new BigNumber([0, 1], 16, 'le').toString(16)).toEqual('100')
       expect(new BigNumber([1, 2, 3], 16, 'le').toString(16)).toEqual('30201')
-      expect(new BigNumber([1, 2, 3, 4], 16, 'le').toString(16)).toEqual('4030201')
-      expect(new BigNumber([1, 2, 3, 4, 5], 16, 'le').toString(16)).toEqual('504030201')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8], 'le').toString(16)).toEqual('807060504030201')
-      expect(new BigNumber([1, 2, 3, 4]).toArray('le').join(',')).toEqual('4,3,2,1')
-      expect(new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray('le').join(',')).toEqual('8,7,6,5,4,3,2,1')
+      expect(new BigNumber([1, 2, 3, 4], 16, 'le').toString(16)).toEqual(
+        '4030201'
+      )
+      expect(new BigNumber([1, 2, 3, 4, 5], 16, 'le').toString(16)).toEqual(
+        '504030201'
+      )
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8], 'le').toString(16)
+      ).toEqual('807060504030201')
+      expect(new BigNumber([1, 2, 3, 4]).toArray('le').join(',')).toEqual(
+        '4,3,2,1'
+      )
+      expect(
+        new BigNumber([1, 2, 3, 4, 5, 6, 7, 8]).toArray('le').join(',')
+      ).toEqual('8,7,6,5,4,3,2,1')
     })
 
     it('should import big endian with implicit base', () => {
-      expect(new BigNumber([1, 2, 3, 4, 5], 'le').toString(16)).toEqual('504030201')
+      expect(new BigNumber([1, 2, 3, 4, 5], 'le').toString(16)).toEqual(
+        '504030201'
+      )
     })
   })
 
-  // the Array code is able to handle Buffer
   describe('with Buffer input', () => {
     it('should not fail on empty Buffer', () => {
-      expect(new BigNumber(Buffer.alloc(0)).toString(16)).toEqual('0')
+      expect(
+        new BigNumber(Buffer.alloc(0).toString('hex') === '' ? '0' : Buffer.alloc(0).toString('hex')).toString(16)
+      ).toEqual('0')
     })
 
     it('should import/export big endian', () => {
-      expect(new BigNumber(Buffer.from('010203', 'hex')).toString(16)).toEqual('10203')
+      expect(
+        new BigNumber(
+          Buffer.from('010203', 'hex').toString('hex'),
+          16
+        ).toString(16)
+      ).toEqual('10203')
     })
 
     it('should import little endian', () => {
-      expect(new BigNumber(Buffer.from('010203', 'hex'), 'le').toString(16)).toEqual('30201')
+      expect(
+        new BigNumber([...Buffer.from('010203', 'hex')], 'le').toString(16)
+      ).toEqual('30201')
     })
   })
 })

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

@@ -1,18 +1,22 @@
 /* eslint-env jest */
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
-import ReductionContext from '../../../dist/cjs/src/primitives/ReductionContext'
+import BigNumber from '../../primitives/BigNumber'
+import ReductionContext from '../../primitives/ReductionContext'
 import { dhGroups } from './BigNumber.fixtures'
 
 describe('BN.js/Slow DH test', () => {
   Object.keys(dhGroups).forEach(function (name) {
-    it('should match public key for ' + name + ' group', () => {
-      const group = dhGroups[name]
-      const base = new BigNumber(2)
-      const mont = new ReductionContext(new BigNumber(group.prime, 16))
-      const priv = new BigNumber(group.priv, 16)
-      const multed = base.toRed(mont).redPow(priv).fromRed()
-      const actual = Buffer.from(multed.toArray())
-      expect(actual.toString('hex')).toEqual(group.pub)
-    }, 3600 * 1000)
+    it(
+      'should match public key for ' + name + ' group',
+      () => {
+        const group = dhGroups[name]
+        const base = new BigNumber(2)
+        const mont = new ReductionContext(new BigNumber(group.prime, 16))
+        const priv = new BigNumber(group.priv, 16)
+        const multed = base.toRed(mont).redPow(priv).fromRed()
+        const actual = Buffer.from(multed.toArray())
+        expect(actual.toString('hex')).toEqual(group.pub)
+      },
+      3600 * 1000
+    )
   })
 })

package/src/primitives/__tests/BigNumber.fixtures.ts

@@ -1,6 +1,7 @@
 export const dhGroups = {
   p16: {
-    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd1' +
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd1' +
       '29024e088a67cc74020bbea63b139b22514a08798e3404dd' +
       'ef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245' +
       'e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7ed' +
@@ -22,7 +23,8 @@ export const dhGroups = {
       '1f612970cee2d7afb81bdd762170481cd0069127d5b05aa9' +
       '93b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199' +
       'ffffffffffffffff',
-    priv: '6d5923e6449122cbbcc1b96093e0b7e4fd3e469f58daddae' +
+    priv:
+      '6d5923e6449122cbbcc1b96093e0b7e4fd3e469f58daddae' +
       '53b49b20664f4132675df9ce98ae0cfdcac0f4181ccb643b' +
       '625f98104dcf6f7d8e81961e2cab4b5014895260cb977c7d' +
       '2f981f8532fb5da60b3676dfe57f293f05d525866053ac7e' +
@@ -44,7 +46,8 @@ export const dhGroups = {
       'd3889d0cc17e5fa00b54d8d9f0f46fb523698af965950f4b' +
       '941369e180f0aece3870d9335f2301db251595d173902cad' +
       '394eaa6ffef8be6c',
-    pub: 'd53703b7340bc89bfc47176d351e5cf86d5a18d9662eca3c' +
+    pub:
+      'd53703b7340bc89bfc47176d351e5cf86d5a18d9662eca3c' +
       '9759c83b6ccda8859649a5866524d77f79e501db923416ca' +
       '2636243836d3e6df752defc0fb19cc386e3ae48ad647753f' +
       'bf415e2612f8a9fd01efe7aca249589590c7e6a0332630bb' +
@@ -68,7 +71,8 @@ export const dhGroups = {
       'b024b04e698d54a5'
   },
   p17: {
-    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd1' +
+    prime:
+      'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd1' +
       '29024e088a67cc74020bbea63b139b22514a08798e3404dd' +
       'ef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245' +
       'e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7ed' +
@@ -100,7 +104,8 @@ export const dhGroups = {
       '06a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55c' +
       'da56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee' +
       '12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff',
-    priv: '6017f2bc23e1caff5b0a8b4e1fc72422b5204415787801dc' +
+    priv:
+      '6017f2bc23e1caff5b0a8b4e1fc72422b5204415787801dc' +
       '025762b8dbb98ab57603aaaa27c4e6bdf742b4a1726b9375' +
       'a8ca3cf07771779589831d8bd18ddeb79c43e7e77d433950' +
       'e652e49df35b11fa09644874d71d62fdaffb580816c2c88c' +
@@ -132,7 +137,8 @@ export const dhGroups = {
       'a29fadd82491a4b4c23f2d06ba45483ab59976da1433c9ce' +
       '500164b957a04cf62dd67595319b512fc4b998424d1164dd' +
       'bbe5d1a0f7257cbb04ec9b5ed92079a1502d98725023ecb2',
-    pub: '3bf836229c7dd874fe37c1790d201e82ed8e192ed61571ca' +
+    pub:
+      '3bf836229c7dd874fe37c1790d201e82ed8e192ed61571ca' +
       '7285264974eb2a0171f3747b2fc23969a916cbd21e14f7e2' +
       'f0d72dcd2247affba926f9e7bb99944cb5609aed85e71b89' +
       'e89d2651550cb5bd8281bd3144066af78f194032aa777739' +
@@ -164,7 +170,8 @@ export const dhGroups = {
       '6985cc83f693f686eaac17411a8247bf62f5ccc7782349b5' +
       'cc1f20e312fa2acc0197154d1bfee507e8db77e8f2732f2d' +
       '641440ccf248e8643b2bd1e1f9e8239356ab91098fcb431d',
-    q: 'a899c59999bf877d96442d284359783bdc64b5f878b688fe' +
+    q:
+      'a899c59999bf877d96442d284359783bdc64b5f878b688fe' +
       '51407f0526e616553ad0aaaac4d5bed3046f10a1faaf42bb' +
       '2342dc4b7908eea0c46e4c4576897675c2bfdc4467870d3d' +
       'cd90adaed4359237a4bc6924bfb99aa6bf5f5ede15b574ea' +
@@ -196,7 +203,8 @@ export const dhGroups = {
       'fe83fbd3ab53602263410f143b73d5b46fc761882e78c782' +
       'd2c36e716a770a7aefaf7f76cea872db7bffefdbc4c2f9e0' +
       '39c19adac915e7a63dcb8c8c78c113f29a3e0bc10e100ce0',
-    qs: '6f0a2fb763eaeb8eb324d564f03d4a55fdcd709e5f1b65e9' +
+    qs:
+      '6f0a2fb763eaeb8eb324d564f03d4a55fdcd709e5f1b65e9' +
       '5702b0141182f9f945d71bc3e64a7dfdae7482a7dd5a4e58' +
       'bc38f78de2013f2c468a621f08536969d2c8d011bb3bc259' +
       '2124692c91140a5472cad224acdacdeae5751dadfdf068b8' +