Use get in other DBManager methods

Author: s1na

src/dbManager.js

@@ -18,10 +18,6 @@ module.exports = class DBManager {
   constructor (db, common) {
     this._db = db
     this._common = common
-    this._opts = {
-      keyEncoding: 'binary',
-      valueEncoding: 'binary'
-    }
     this._cache = {
       td: new Cache({ max: 1024 }),
       header: new Cache({ max: 512 }),
@@ -32,22 +28,38 @@ module.exports = class DBManager {
   }
 
   getHeads () {
-    return this._db.get(headsKey, {
-      keyEncoding: 'binary',
-      valueEncoding: 'json'
-    })
+    return this.get(headsKey, { valueEncoding: 'json' })
   }
 
   getHeadHeader () {
-    return this._db.get(headHeaderKey, this._opts)
+    return this.get(headHeaderKey)
   }
 
   getHeadBlock () {
-    return this._db.get(headBlockKey, this._opts)
+    return this.get(headBlockKey)
   }
 
-  get (k) {
-    return this._db.get(k, this._opts)
+  async get (key, opts = {}) {
+    const dbOpts = {
+      keyEncoding: opts.keyEncoding || 'binary',
+      valueEncoding: opts.valueEncoding || 'binary'
+    }
+
+    if (opts.cache) {
+      if (!this._cache[opts.cache]) {
+        throw new Error(`Invalid cache: ${opts.cache}`)
+      }
+
+      let value = this._cache[opts.cache].get(key)
+      if (!value) {
+        value = await this._db.get(key, dbOpts)
+        this._cache[opts.cache].set(key, value)
+      }
+
+      return value
+    }
+
+    return this._db.get(key, dbOpts)
   }
 
   batch (ops) {
@@ -60,74 +72,37 @@ module.exports = class DBManager {
    */
   async _hashToNumber (hash) {
     const key = hashToNumberKey(hash)
-    let number = this._cache.hashToNumber.get(key)
-    if (number) {
-      return new BN(number)
-    }
-
-    number = await this.get(key)
-    this._cache.hashToNumber.set(key, number)
-
-    return new BN(number)
+    return new BN(await this.get(key, { cache: 'hashToNumber' }))
   }
 
   /**
    * Performs a block number to block hash lookup
    * @method _numberToHash
    */
-  async _numberToHash (number) {
+  _numberToHash (number) {
     if (number.ltn(0)) {
       throw new level.errors.NotFoundError()
     }
 
     const key = numberToHashKey(number)
-    let hash = this._cache.numberToHash.get(key)
-    if (hash) {
-      return hash
-    }
-
-    hash = await this._db.get(key)
-    this._cache.numberToHash.set(key, hash)
-
-    return hash
+    return this.get(key, { cache: 'numberToHash' })
   }
 
   async _getTd (hash, number) {
     const key = tdKey(number, hash)
-    let td = this._cache.td.get(key)
-    if (td) {
-      return new BN(rlp.decode(td))
-    }
-
-    td = await this._db.get(key)
-    this._cache.td.set(key, td)
-
+    const td = await this.get(key, { cache: 'td' })
     return new BN(rlp.decode(td))
   }
 
   async _getBody (hash, number) {
     const key = bodyKey(number, hash)
-    let encodedBody = this._cache.body.get(key)
-    if (encodedBody) {
-      return rlp.decode(encodedBody)
-    }
-
-    encodedBody = await this._db.get(key)
-    this._cache.body.set(key, encodedBody)
-
-    return rlp.decode(encodedBody)
+    return rlp.decode(await this.get(key, { cache: 'body' }))
   }
 
   async _getHeader (hash, number) {
     const key = headerKey(number, hash)
-    let encodedHeader = this._cache.header.get(key)
-    if (encodedHeader) {
-      return new Block.Header(rlp.decode(encodedHeader), {common: this._common})
-    }
-
-    encodedHeader = await this._db.get(key)
-    this._cache.header.set(key, encodedHeader)
-    return new Block.Header(rlp.decode(encodedHeader), {common: this._common})
+    let encodedHeader = await this.get(key, { cache: 'header' })
+    return new Block.Header(rlp.decode(encodedHeader), { common: this._common })
   }
 
   async _getBlock (blockTag) {