diff --git a/libloki/test/proof-of-work_test.js b/libloki/test/proof-of-work_test.js
index f31f1b4bc..68a85ea19 100644
--- a/libloki/test/proof-of-work_test.js
+++ b/libloki/test/proof-of-work_test.js
@@ -8,88 +8,98 @@ const {
   greaterThan,
 } = pow;
 
-describe('Proof of Work Worker', () => {
-  it('should increment a Uint8Array nonce correctly', () => {
-    const arr1Before = new Uint8Array([0,0,0,0,0,0,0,0]);
-    const arr1After = incrementNonce(arr1Before);
-    assert.strictEqual(arr1After[0], 0);
-    assert.strictEqual(arr1After[1], 0);
-    assert.strictEqual(arr1After[2], 0);
-    assert.strictEqual(arr1After[3], 0);
-    assert.strictEqual(arr1After[4], 0);
-    assert.strictEqual(arr1After[5], 0);
-    assert.strictEqual(arr1After[6], 0);
-    assert.strictEqual(arr1After[7], 1);
-  });
+describe('Proof of Work', () => {
+  describe('#incrementNonce', () => {
+    it('should increment a Uint8Array nonce correctly', () => {
+      const arr1Before = new Uint8Array([0,0,0,0,0,0,0,0]);
+      const arr1After = incrementNonce(arr1Before);
+      assert.strictEqual(arr1After[0], 0);
+      assert.strictEqual(arr1After[1], 0);
+      assert.strictEqual(arr1After[2], 0);
+      assert.strictEqual(arr1After[3], 0);
+      assert.strictEqual(arr1After[4], 0);
+      assert.strictEqual(arr1After[5], 0);
+      assert.strictEqual(arr1After[6], 0);
+      assert.strictEqual(arr1After[7], 1);
+    });
 
-  it('should increment a Uint8Array nonce correctly', () => {
-    let arr = new Uint8Array([0,0,0,0,0,0,0,0]);
-    assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,1]));
-    arr = new Uint8Array([0,0,0,0,0,0,0,0]);
-    for(let i = 0; i <= 255; i += 1) {
-      arr = incrementNonce(arr);
-    }
-    assert.deepEqual(arr, new Uint8Array([0,0,0,0,0,0,1,0]));
-    arr = new Uint8Array([255,255,255,255,255,255,255,255]);
-    assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,0]));
+    it('should increment a Uint8Array nonce correctly in a loop', () => {
+      let arr = new Uint8Array([0,0,0,0,0,0,0,0]);
+      assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,1]));
+      arr = new Uint8Array([0,0,0,0,0,0,0,0]);
+      for(let i = 0; i <= 255; i += 1) {
+        arr = incrementNonce(arr);
+      }
+      assert.deepEqual(arr, new Uint8Array([0,0,0,0,0,0,1,0]));
+      arr = new Uint8Array([255,255,255,255,255,255,255,255]);
+      assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,0]));
+    });
   });
 
-  it('should calculate a correct difficulty target', () => {
-    // These values will need to be updated if we adjust the difficulty settings
-    let payloadLen = 625;
-    const ttl = 86400;
-    let expectedTarget = new Uint8Array([0,4,119,164,35,224,222,64]);
+  describe('#calcTarget', () => {
+    it('should calculate a correct difficulty target', () => {
+      // These values will need to be updated if we adjust the difficulty settings
+      let payloadLen = 625;
+      const ttl = 86400;
+      let expectedTarget = new Uint8Array([0,4,119,164,35,224,222,64]);
 
-    let actualTarget = calcTarget(ttl, payloadLen, 10);
-    assert.deepEqual(actualTarget, expectedTarget);
-    payloadLen = 6597;
-    expectedTarget = new Uint8Array([0,0,109,145,174,146,124,3]);
-    actualTarget = calcTarget(ttl, payloadLen, 10);
-    assert.deepEqual(actualTarget, expectedTarget);
+      let actualTarget = calcTarget(ttl, payloadLen, 10);
+      assert.deepEqual(actualTarget, expectedTarget);
+      payloadLen = 6597;
+      expectedTarget = new Uint8Array([0,0,109,145,174,146,124,3]);
+      actualTarget = calcTarget(ttl, payloadLen, 10);
+      assert.deepEqual(actualTarget, expectedTarget);
+    });
   });
 
-  it('should correclty compare two Uint8Arrays', () => {
-    let arr1 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
-    let arr2 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
-    assert.isFalse(greaterThan(arr1, arr2))
-    arr1 = new Uint8Array([0,0,0,0,0,0,0,0,0,2]);
-    arr2 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
-    assert.isTrue(greaterThan(arr1, arr2))
-    arr1 = new Uint8Array([255,255,255,255,255,255,255,255,255,255]);
-    arr2 = new Uint8Array([255,255,255,255,255,255,255,255,255,254]);
-    assert.isTrue(greaterThan(arr1, arr2))
-    arr1 = new Uint8Array([254,255,255,255,255,255,255,255,255,255]);
-    arr2 = new Uint8Array([255,255,255,255,255,255,255,255,255,255]);
-    assert.isFalse(greaterThan(arr1, arr2));
-    arr1 = new Uint8Array([0]);
-    arr2 = new Uint8Array([0,0]);
-    assert.isFalse(greaterThan(arr1, arr2))
+  describe('#greaterThan', () => {
+    it('should correclty compare two Uint8Arrays', () => {
+      let arr1 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
+      let arr2 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
+      assert.isFalse(greaterThan(arr1, arr2))
+      arr1 = new Uint8Array([0,0,0,0,0,0,0,0,0,2]);
+      arr2 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
+      assert.isTrue(greaterThan(arr1, arr2))
+      arr1 = new Uint8Array([255,255,255,255,255,255,255,255,255,255]);
+      arr2 = new Uint8Array([255,255,255,255,255,255,255,255,255,254]);
+      assert.isTrue(greaterThan(arr1, arr2))
+      arr1 = new Uint8Array([254,255,255,255,255,255,255,255,255,255]);
+      arr2 = new Uint8Array([255,255,255,255,255,255,255,255,255,255]);
+      assert.isFalse(greaterThan(arr1, arr2));
+      arr1 = new Uint8Array([0]);
+      arr2 = new Uint8Array([0,0]);
+      assert.isFalse(greaterThan(arr1, arr2))
+    });
   });
 
-  it('should correclty convert a Uint8Array to a base64 string', () => {
-    let arr = new Uint8Array([1,2,3]);
-    let expected = 'AQID';
-    assert.strictEqual(bufferToBase64(arr), expected);
-    arr = new Uint8Array([123,25,3,121,45,87,24,111]);
-    expected = 'exkDeS1XGG8=';
-    assert.strictEqual(bufferToBase64(arr), expected);
-    arr = new Uint8Array([]);
-    expected = '';
-    assert.strictEqual(bufferToBase64(arr), expected);
+  describe('#bufferToBase64', () => {
+    it('should correclty convert a Uint8Array to a base64 string', () => {
+      let arr = new Uint8Array([1,2,3]);
+      let expected = 'AQID';
+      assert.strictEqual(bufferToBase64(arr), expected);
+      arr = new Uint8Array([123,25,3,121,45,87,24,111]);
+      expected = 'exkDeS1XGG8=';
+      assert.strictEqual(bufferToBase64(arr), expected);
+      arr = new Uint8Array([]);
+      expected = '';
+      assert.strictEqual(bufferToBase64(arr), expected);
+    });
   });
 
-  it('should correclty convert a BigInteger to a Uint8Array', () => {
-    let bigInt = JSBI.BigInt(Number.MAX_SAFE_INTEGER);
-    let expected = new Uint8Array([0, 31, 255, 255, 255, 255, 255, 255]);
-    assert.deepEqual(bigIntToUint8Array(bigInt), expected);
-    bigInt = JSBI.BigInt('0');
-    expected = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
-    assert.deepEqual(bigIntToUint8Array(bigInt), expected);
-    bigInt = JSBI.BigInt('255');
-    expected = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 255]);
-    assert.deepEqual(bigIntToUint8Array(bigInt), expected);
-    bigInt = JSBI.BigInt('256');
-    expected = new Uint8Array([0, 0, 0, 0, 0, 0, 1, 0]);
-    assert.deepEqual(bigIntToUint8Array(bigInt), expected);
+  describe('#bigIntToUint8Array', () => {
+    it('should correclty convert a BigInteger to a Uint8Array', () => {
+      let bigInt = JSBI.BigInt(Number.MAX_SAFE_INTEGER);
+      let expected = new Uint8Array([0, 31, 255, 255, 255, 255, 255, 255]);
+      assert.deepEqual(bigIntToUint8Array(bigInt), expected);
+      bigInt = JSBI.BigInt('0');
+      expected = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
+      assert.deepEqual(bigIntToUint8Array(bigInt), expected);
+      bigInt = JSBI.BigInt('255');
+      expected = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 255]);
+      assert.deepEqual(bigIntToUint8Array(bigInt), expected);
+      bigInt = JSBI.BigInt('256');
+      expected = new Uint8Array([0, 0, 0, 0, 0, 0, 1, 0]);
+      assert.deepEqual(bigIntToUint8Array(bigInt), expected);
+    });
   });
 });
diff --git a/libloki/test/service_nodes_test.js b/libloki/test/service_nodes_test.js
index e502e8532..1d72d0b92 100644
--- a/libloki/test/service_nodes_test.js
+++ b/libloki/test/service_nodes_test.js
@@ -1,40 +1,50 @@
-/* global libloki, chai */
+/* global libloki, assert */
 
 describe('ServiceNodes', () => {
   describe('#consolidateLists', () => {
     it('should throw when provided a non-iterable list', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists(null, 1)).to.throw();
+      assert.throws(() => libloki.serviceNodes.consolidateLists(null, 1), Error);
     });
+
     it('should throw when provided a non-iterable item in the list', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists([1, 2, 3], 1)).to.throw();
+      assert.throws(() => libloki.serviceNodes.consolidateLists([1, 2, 3], 1), Error);
     });
+
     it('should throw when provided a non-number threshold', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists([], 'a')).to.throw();
+      assert.throws(
+        () => libloki.serviceNodes.consolidateLists([], 'a'),
+        'Provided threshold is not a number'
+      );
     });
+
     it('should return an empty array when the input is an empty array', () => {
       const result = libloki.serviceNodes.consolidateLists([]);
-      chai.expect(result).to.deep.equal([]);
+      assert.deepEqual(result, []);
     });
+
     it('should return the input when only 1 list is provided', () => {
       const result = libloki.serviceNodes.consolidateLists([['a', 'b', 'c']]);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c']);
+      assert.deepEqual(result, ['a', 'b', 'c']);
     });
+
     it('should return the union of all lists when threshold is 0', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'h'],
         ['d', 'e', 'f', 'g'],
         ['g', 'h'],
       ], 0);
-      chai.expect(result.sort()).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
+      assert.deepEqual(result.sort(), ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
     });
+
     it('should return the intersection of all lists when threshold is 1', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'd'],
         ['a', 'e', 'f', 'g'],
         ['a', 'h'],
       ], 1);
-      chai.expect(result).to.deep.equal(['a']);
+      assert.deepEqual(result, ['a']);
     });
+
     it('should return the elements that have an occurence >= the provided threshold', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
@@ -42,8 +52,9 @@ describe('ServiceNodes', () => {
         ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
         ['a', 'b', 'c', 'd', 'e', 'g', 'h'],
       ], 3/4);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
+      assert.deepEqual(result, ['a', 'b', 'c', 'd', 'e', 'f', 'g']);
     });
+
     it('should work with sets as well', () => {
       const result = libloki.serviceNodes.consolidateLists(new Set([
         new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
@@ -51,7 +62,7 @@ describe('ServiceNodes', () => {
         new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
         new Set(['a', 'b', 'c', 'd', 'e', 'g', 'h']),
       ]), 3/4);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
+      assert.deepEqual(result, ['a', 'b', 'c', 'd', 'e', 'f', 'g']);
     });
   });
 });