diff --git a/src/selection.js b/src/selection.js
index b92171e..b03b0af 100644
--- a/src/selection.js
+++ b/src/selection.js
@@ -15,7 +15,7 @@ const bestRecord = (selectors, k, records) => {
   if (records.length === 0) {
     const errMsg = `No records given`
 
-    throw errcode(new Error(errMsg), 'ERR_NO_RECORDS_RECEIVED')
+    throw errcode(errMsg, 'ERR_NO_RECORDS_RECEIVED')
   }
 
   const parts = bsplit(k, Buffer.from('/'))
@@ -23,7 +23,7 @@ const bestRecord = (selectors, k, records) => {
   if (parts.length < 3) {
     const errMsg = `Record key does not have a selector function`
 
-    throw errcode(new Error(errMsg), 'ERR_NO_SELECTOR_FUNCTION_FOR_RECORD_KEY')
+    throw errcode(errMsg, 'ERR_NO_SELECTOR_FUNCTION_FOR_RECORD_KEY')
   }
 
   const selector = selectors[parts[1].toString()]
@@ -31,7 +31,7 @@ const bestRecord = (selectors, k, records) => {
   if (!selector) {
     const errMsg = `Unrecognized key prefix: ${parts[1]}`
 
-    throw errcode(new Error(errMsg), 'ERR_UNRECOGNIZED_KEY_PREFIX')
+    throw errcode(errMsg, 'ERR_UNRECOGNIZED_KEY_PREFIX')
   }
 
   return selector(k, records)
diff --git a/src/validator.js b/src/validator.js
index bff4109..95ade5e 100644
--- a/src/validator.js
+++ b/src/validator.js
@@ -26,7 +26,7 @@ const verifyRecord = (validators, record) => {
   if (!validator) {
     const errMsg = `Invalid record keytype`
 
-    throw errcode(new Error(errMsg), 'ERR_INVALID_RECORD_KEY_TYPE')
+    throw errcode(errMsg, 'ERR_INVALID_RECORD_KEY_TYPE')
   }
 
   return validator.func(key, record.value)
diff --git a/src/validators/public-key.js b/src/validators/public-key.js
index 0673992..95e2d41 100644
--- a/src/validators/public-key.js
+++ b/src/validators/public-key.js
@@ -1,6 +1,7 @@
 'use strict'
 
 const multihashing = require('multihashing-async')
+const errcode = require('err-code')
 
 /**
  * Validator for publick key records.
@@ -14,17 +15,17 @@ const multihashing = require('multihashing-async')
  */
 const validatePublicKeyRecord = async (key, publicKey) => {
   if (!Buffer.isBuffer(key)) {
-    throw new Error('"key" must be a Buffer')
+    throw errcode('"key" must be a Buffer', 'ERR_INVALID_RECORD_KEY_NOT_BUFFER')
   }
 
-  if (key.length < 3) {
-    throw new Error('invalid public key record')
+  if (key.length < 5) {
+    throw errcode('invalid public key record', 'ERR_INVALID_RECORD_KEY_TOO_SHORT')
   }
 
   const prefix = key.slice(0, 4).toString()
 
   if (prefix !== '/pk/') {
-    throw new Error('key was not prefixed with /pk/')
+    throw errcode('key was not prefixed with /pk/', 'ERR_INVALID_RECORD_KEY_BAD_PREFIX')
   }
 
   const keyhash = key.slice(4)
@@ -32,7 +33,7 @@ const validatePublicKeyRecord = async (key, publicKey) => {
   const publicKeyHash = await multihashing(publicKey, 'sha2-256')
 
   if (!keyhash.equals(publicKeyHash)) {
-    throw new Error('public key does not match passed in key')
+    throw errcode('public key does not match passed in key', 'ERR_INVALID_RECORD_HASH_MISMATCH')
   }
 }
 
diff --git a/test/validator.spec.js b/test/validator.spec.js
index d911f01..a043941 100644
--- a/test/validator.spec.js
+++ b/test/validator.spec.js
@@ -27,14 +27,16 @@ const generateCases = (hash) => {
     invalid: {
       publicKey: [
         // missing hashkey
-        Buffer.from('/pk/'),
+        [Buffer.from('/pk/'), 'ERR_INVALID_RECORD_KEY_TOO_SHORT'],
         // not the hash of a key
-        Buffer.concat([
+        [Buffer.concat([
           Buffer.from('/pk/'),
           Buffer.from('random')
-        ]),
+        ]), 'ERR_INVALID_RECORD_HASH_MISMATCH'],
         // missing prefix
-        hash
+        [hash, 'ERR_INVALID_RECORD_KEY_BAD_PREFIX'],
+        // not a buffer
+        ['not a buffer', 'ERR_INVALID_RECORD_KEY_NOT_BUFFER']
       ]
     }
   }
@@ -103,17 +105,21 @@ describe('validator', () => {
       })
 
       it('does not error on valid record', () => {
-        return Promise.all(cases.valid.publicKey, (k) => {
+        return Promise.all(cases.valid.publicKey.map((k) => {
           return validator.validators.pk.func(k, key.public.bytes)
-        })
+        }))
       })
 
       it('throws on invalid records', () => {
-        return Promise.all(cases.invalid.publicKey, (k) => {
-          return expect(
-            () => validator.validators.pk.func(k, key.public.bytes)
-          ).to.throw()
-        })
+        return Promise.all(cases.invalid.publicKey.map(async ([k, errCode]) => {
+          try {
+            await validator.validators.pk.func(k, key.public.bytes)
+          } catch (err) {
+            expect(err.code).to.eql(errCode)
+            return
+          }
+          expect.fail('did not throw an error with code ' + errCode)
+        }))
       })
     })
   })