hypercore 11.16.2 → 11.17.0

package/lib/messages.js

@@ -12,10 +12,10 @@ const MANIFEST_LINKED = 0b00000100
 const MANIFEST_USER_DATA = 0b00001000
 
 const hashes = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // small uint
   },
-  encode (state, m) {
+  encode(state, m) {
     if (m === 'blake2b') {
       c.uint.encode(state, 0)
       return
@@ -23,7 +23,7 @@ const hashes = {
 
     throw new Error('Unknown hash: ' + m)
   },
-  decode (state) {
+  decode(state) {
     const n = c.uint.decode(state)
     if (n === 0) return 'blake2b'
     throw new Error('Unknown hash id: ' + n)
@@ -31,10 +31,10 @@ const hashes = {
 }
 
 const signatures = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // small uint
   },
-  encode (state, m) {
+  encode(state, m) {
     if (m === 'ed25519') {
       c.uint.encode(state, 0)
       return
@@ -42,7 +42,7 @@ const signatures = {
 
     throw new Error('Unknown signature: ' + m)
   },
-  decode (state) {
+  decode(state) {
     const n = c.uint.decode(state)
     if (n === 0) return 'ed25519'
     throw new Error('Unknown signature id: ' + n)
@@ -50,17 +50,17 @@ const signatures = {
 }
 
 const signer = {
-  preencode (state, m) {
+  preencode(state, m) {
     signatures.preencode(state, m.signature)
     c.fixed32.preencode(state, m.namespace)
     c.fixed32.preencode(state, m.publicKey)
   },
-  encode (state, m) {
+  encode(state, m) {
     signatures.encode(state, m.signature)
     c.fixed32.encode(state, m.namespace)
     c.fixed32.encode(state, m.publicKey)
   },
-  decode (state) {
+  decode(state) {
     return {
       signature: signatures.decode(state),
       namespace: c.fixed32.decode(state),
@@ -72,15 +72,15 @@ const signer = {
 const signerArray = c.array(signer)
 
 const prologue = {
-  preencode (state, p) {
+  preencode(state, p) {
     c.fixed32.preencode(state, p.hash)
     c.uint.preencode(state, p.length)
   },
-  encode (state, p) {
+  encode(state, p) {
     c.fixed32.encode(state, p.hash)
     c.uint.encode(state, p.length)
   },
-  decode (state) {
+  decode(state) {
     return {
       hash: c.fixed32.decode(state),
       length: c.uint.decode(state)
@@ -89,7 +89,7 @@ const prologue = {
 }
 
 const manifestv0 = {
-  preencode (state, m) {
+  preencode(state, m) {
     hashes.preencode(state, m.hash)
     state.end++ // type
 
@@ -106,7 +106,7 @@ const manifestv0 = {
       signerArray.preencode(state, m.signers)
     }
   },
-  encode (state, m) {
+  encode(state, m) {
     hashes.encode(state, m.hash)
 
     if (m.prologue && m.signers.length === 0) {
@@ -125,7 +125,7 @@ const manifestv0 = {
       signerArray.encode(state, m.signers)
     }
   },
-  decode (state) {
+  decode(state) {
     const hash = hashes.decode(state)
     const type = c.uint.decode(state)
 
@@ -177,8 +177,8 @@ const manifestv0 = {
 
 const fixed32Array = c.array(c.fixed32)
 
-const manifest = exports.manifest = {
-  preencode (state, m) {
+const manifest = (exports.manifest = {
+  preencode(state, m) {
     state.end++ // version
 
     if (m.version === 0) return manifestv0.preencode(state, m)
@@ -193,7 +193,7 @@ const manifest = exports.manifest = {
     if (m.linked) fixed32Array.preencode(state, m.linked)
     if (m.userData) c.buffer.preencode(state, m.userData)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.version)
 
     if (m.version === 0) return manifestv0.encode(state, m)
@@ -214,7 +214,7 @@ const manifest = exports.manifest = {
     if (m.linked) fixed32Array.encode(state, m.linked)
     if (m.userData) c.buffer.encode(state, m.userData)
   },
-  decode (state) {
+  decode(state) {
     const version = c.uint.decode(state)
 
     if (version === 0) return manifestv0.decode(state)
@@ -241,20 +241,20 @@ const manifest = exports.manifest = {
       userData: hasUserData ? c.buffer.decode(state) : null
     }
   }
-}
+})
 
 const node = {
-  preencode (state, n) {
+  preencode(state, n) {
     c.uint.preencode(state, n.index)
     c.uint.preencode(state, n.size)
     c.fixed32.preencode(state, n.hash)
   },
-  encode (state, n) {
+  encode(state, n) {
     c.uint.encode(state, n.index)
     c.uint.encode(state, n.size)
     c.fixed32.encode(state, n.hash)
   },
-  decode (state) {
+  decode(state) {
     return {
       index: c.uint.decode(state),
       size: c.uint.decode(state),
@@ -265,18 +265,18 @@ const node = {
 
 const nodeArray = c.array(node)
 
-const wire = exports.wire = {}
+const wire = (exports.wire = {})
 
 wire.handshake = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, 1)
     c.fixed32.preencode(state, m.capability)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.seeks ? 1 : 0)
     c.fixed32.encode(state, m.capability)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
     return {
       seeks: (flags & 1) !== 0,
@@ -286,15 +286,15 @@ wire.handshake = {
 }
 
 const requestBlock = {
-  preencode (state, b) {
+  preencode(state, b) {
     c.uint.preencode(state, b.index)
     c.uint.preencode(state, b.nodes)
   },
-  encode (state, b) {
+  encode(state, b) {
     c.uint.encode(state, b.index)
     c.uint.encode(state, b.nodes)
   },
-  decode (state) {
+  decode(state) {
     return {
       index: c.uint.decode(state),
       nodes: c.uint.decode(state)
@@ -303,15 +303,15 @@ const requestBlock = {
 }
 
 const requestSeek = {
-  preencode (state, s) {
+  preencode(state, s) {
     c.uint.preencode(state, s.bytes)
     c.uint.preencode(state, s.padding)
   },
-  encode (state, s) {
+  encode(state, s) {
     c.uint.encode(state, s.bytes)
     c.uint.encode(state, s.padding)
   },
-  decode (state) {
+  decode(state) {
     return {
       bytes: c.uint.decode(state),
       padding: c.uint.decode(state)
@@ -320,15 +320,15 @@ const requestSeek = {
 }
 
 const requestUpgrade = {
-  preencode (state, u) {
+  preencode(state, u) {
     c.uint.preencode(state, u.start)
     c.uint.preencode(state, u.length)
   },
-  encode (state, u) {
+  encode(state, u) {
     c.uint.encode(state, u.start)
     c.uint.encode(state, u.length)
   },
-  decode (state) {
+  decode(state) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state)
@@ -337,7 +337,7 @@ const requestUpgrade = {
 }
 
 wire.request = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // flags
     c.uint.preencode(state, m.id)
     c.uint.preencode(state, m.fork)
@@ -348,8 +348,14 @@ wire.request = {
     if (m.upgrade) requestUpgrade.preencode(state, m.upgrade)
     if (m.priority) c.uint.preencode(state, m.priority)
   },
-  encode (state, m) {
-    const flags = (m.block ? 1 : 0) | (m.hash ? 2 : 0) | (m.seek ? 4 : 0) | (m.upgrade ? 8 : 0) | (m.manifest ? 16 : 0) | (m.priority ? 32 : 0)
+  encode(state, m) {
+    const flags =
+      (m.block ? 1 : 0) |
+      (m.hash ? 2 : 0) |
+      (m.seek ? 4 : 0) |
+      (m.upgrade ? 8 : 0) |
+      (m.manifest ? 16 : 0) |
+      (m.priority ? 32 : 0)
 
     c.uint.encode(state, flags)
     c.uint.encode(state, m.id)
@@ -361,7 +367,7 @@ wire.request = {
     if (m.upgrade) requestUpgrade.encode(state, m.upgrade)
     if (m.priority) c.uint.encode(state, m.priority)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -378,13 +384,13 @@ wire.request = {
 }
 
 wire.cancel = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.request)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.request)
   },
-  decode (state, m) {
+  decode(state, m) {
     return {
       request: c.uint.decode(state)
     }
@@ -392,21 +398,21 @@ wire.cancel = {
 }
 
 const dataUpgrade = {
-  preencode (state, u) {
+  preencode(state, u) {
     c.uint.preencode(state, u.start)
     c.uint.preencode(state, u.length)
     nodeArray.preencode(state, u.nodes)
     nodeArray.preencode(state, u.additionalNodes)
     c.buffer.preencode(state, u.signature)
   },
-  encode (state, u) {
+  encode(state, u) {
     c.uint.encode(state, u.start)
     c.uint.encode(state, u.length)
     nodeArray.encode(state, u.nodes)
     nodeArray.encode(state, u.additionalNodes)
     c.buffer.encode(state, u.signature)
   },
-  decode (state) {
+  decode(state) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state),
@@ -418,15 +424,15 @@ const dataUpgrade = {
 }
 
 const dataSeek = {
-  preencode (state, s) {
+  preencode(state, s) {
     c.uint.preencode(state, s.bytes)
     nodeArray.preencode(state, s.nodes)
   },
-  encode (state, s) {
+  encode(state, s) {
     c.uint.encode(state, s.bytes)
     nodeArray.encode(state, s.nodes)
   },
-  decode (state) {
+  decode(state) {
     return {
       bytes: c.uint.decode(state),
       nodes: nodeArray.decode(state)
@@ -435,17 +441,17 @@ const dataSeek = {
 }
 
 const dataBlock = {
-  preencode (state, b) {
+  preencode(state, b) {
     c.uint.preencode(state, b.index)
     c.buffer.preencode(state, b.value)
     nodeArray.preencode(state, b.nodes)
   },
-  encode (state, b) {
+  encode(state, b) {
     c.uint.encode(state, b.index)
     c.buffer.encode(state, b.value)
     nodeArray.encode(state, b.nodes)
   },
-  decode (state) {
+  decode(state) {
     return {
       index: c.uint.decode(state),
       value: c.buffer.decode(state) || EMPTY,
@@ -455,15 +461,15 @@ const dataBlock = {
 }
 
 const dataHash = {
-  preencode (state, b) {
+  preencode(state, b) {
     c.uint.preencode(state, b.index)
     nodeArray.preencode(state, b.nodes)
   },
-  encode (state, b) {
+  encode(state, b) {
     c.uint.encode(state, b.index)
     nodeArray.encode(state, b.nodes)
   },
-  decode (state) {
+  decode(state) {
     return {
       index: c.uint.decode(state),
       nodes: nodeArray.decode(state)
@@ -472,7 +478,7 @@ const dataHash = {
 }
 
 wire.data = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // flags
     c.uint.preencode(state, m.request)
     c.uint.preencode(state, m.fork)
@@ -483,8 +489,13 @@ wire.data = {
     if (m.upgrade) dataUpgrade.preencode(state, m.upgrade)
     if (m.manifest) manifest.preencode(state, m.manifest)
   },
-  encode (state, m) {
-    const flags = (m.block ? 1 : 0) | (m.hash ? 2 : 0) | (m.seek ? 4 : 0) | (m.upgrade ? 8 : 0) | (m.manifest ? 16 : 0)
+  encode(state, m) {
+    const flags =
+      (m.block ? 1 : 0) |
+      (m.hash ? 2 : 0) |
+      (m.seek ? 4 : 0) |
+      (m.upgrade ? 8 : 0) |
+      (m.manifest ? 16 : 0)
 
     c.uint.encode(state, flags)
     c.uint.encode(state, m.request)
@@ -496,7 +507,7 @@ wire.data = {
     if (m.upgrade) dataUpgrade.encode(state, m.upgrade)
     if (m.manifest) manifest.encode(state, m.manifest)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -512,17 +523,17 @@ wire.data = {
 }
 
 wire.noData = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.request)
     c.uint.preencode(state, m.reason ? 1 : 0)
     if (m.reason) c.uint.preencode(state, m.reason)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.request)
     c.uint.encode(state, m.reason ? 1 : 0)
     if (m.reason) c.uint.encode(state, m.reason)
   },
-  decode (state, m) {
+  decode(state, m) {
     const request = c.uint.decode(state)
     const flags = state.start < state.end ? c.uint.decode(state) : 0
     return {
@@ -533,15 +544,15 @@ wire.noData = {
 }
 
 wire.want = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.start)
     c.uint.preencode(state, m.length)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.start)
     c.uint.encode(state, m.length)
   },
-  decode (state) {
+  decode(state) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state)
@@ -550,15 +561,15 @@ wire.want = {
 }
 
 wire.unwant = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.start)
     c.uint.preencode(state, m.length)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.start)
     c.uint.encode(state, m.length)
   },
-  decode (state, m) {
+  decode(state, m) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state)
@@ -567,17 +578,17 @@ wire.unwant = {
 }
 
 wire.range = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // flags
     c.uint.preencode(state, m.start)
     if (m.length !== 1) c.uint.preencode(state, m.length)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, (m.drop ? 1 : 0) | (m.length === 1 ? 2 : 0))
     c.uint.encode(state, m.start)
     if (m.length !== 1) c.uint.encode(state, m.length)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -589,15 +600,15 @@ wire.range = {
 }
 
 wire.bitfield = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.start)
     c.uint32array.preencode(state, m.bitfield)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.start)
     c.uint32array.encode(state, m.bitfield)
   },
-  decode (state, m) {
+  decode(state, m) {
     return {
       start: c.uint.decode(state),
       bitfield: c.uint32array.decode(state)
@@ -606,19 +617,25 @@ wire.bitfield = {
 }
 
 wire.sync = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // flags
     c.uint.preencode(state, m.fork)
     c.uint.preencode(state, m.length)
     c.uint.preencode(state, m.remoteLength)
   },
-  encode (state, m) {
-    c.uint.encode(state, (m.canUpgrade ? 1 : 0) | (m.uploading ? 2 : 0) | (m.downloading ? 4 : 0) | (m.hasManifest ? 8 : 0))
+  encode(state, m) {
+    c.uint.encode(
+      state,
+      (m.canUpgrade ? 1 : 0) |
+        (m.uploading ? 2 : 0) |
+        (m.downloading ? 4 : 0) |
+        (m.hasManifest ? 8 : 0)
+    )
     c.uint.encode(state, m.fork)
     c.uint.encode(state, m.length)
     c.uint.encode(state, m.remoteLength)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -634,17 +651,17 @@ wire.sync = {
 }
 
 wire.reorgHint = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.from)
     c.uint.preencode(state, m.to)
     c.uint.preencode(state, m.ancestors)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.from)
     c.uint.encode(state, m.to)
     c.uint.encode(state, m.ancestors)
   },
-  decode (state) {
+  decode(state) {
     return {
       from: c.uint.encode(state),
       to: c.uint.encode(state),
@@ -654,15 +671,15 @@ wire.reorgHint = {
 }
 
 wire.extension = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.string.preencode(state, m.name)
     c.raw.preencode(state, m.message)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.string.encode(state, m.name)
     c.raw.encode(state, m.message)
   },
-  decode (state) {
+  decode(state) {
     return {
       name: c.string.decode(state),
       message: c.raw.decode(state)
@@ -671,15 +688,15 @@ wire.extension = {
 }
 
 const keyValue = {
-  preencode (state, p) {
+  preencode(state, p) {
     c.string.preencode(state, p.key)
     c.buffer.preencode(state, p.value)
   },
-  encode (state, p) {
+  encode(state, p) {
     c.string.encode(state, p.key)
     c.buffer.encode(state, p.value)
   },
-  decode (state) {
+  decode(state) {
     return {
       key: c.string.decode(state),
       value: c.buffer.decode(state)
@@ -688,19 +705,19 @@ const keyValue = {
 }
 
 const treeUpgrade = {
-  preencode (state, u) {
+  preencode(state, u) {
     c.uint.preencode(state, u.fork)
     c.uint.preencode(state, u.ancestors)
     c.uint.preencode(state, u.length)
     c.buffer.preencode(state, u.signature)
   },
-  encode (state, u) {
+  encode(state, u) {
     c.uint.encode(state, u.fork)
     c.uint.encode(state, u.ancestors)
     c.uint.encode(state, u.length)
     c.buffer.encode(state, u.signature)
   },
-  decode (state) {
+  decode(state) {
     return {
       fork: c.uint.decode(state),
       ancestors: c.uint.decode(state),
@@ -710,18 +727,19 @@ const treeUpgrade = {
   }
 }
 
-const bitfieldUpdate = { // TODO: can maybe be folded into a HAVE later on with the most recent spec
-  preencode (state, b) {
+const bitfieldUpdate = {
+  // TODO: can maybe be folded into a HAVE later on with the most recent spec
+  preencode(state, b) {
     state.end++ // flags
     c.uint.preencode(state, b.start)
     c.uint.preencode(state, b.length)
   },
-  encode (state, b) {
+  encode(state, b) {
     state.buffer[state.start++] = b.drop ? 1 : 0
     c.uint.encode(state, b.start)
     c.uint.encode(state, b.length)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
     return {
       drop: (flags & 1) !== 0,
@@ -731,17 +749,17 @@ const bitfieldUpdate = { // TODO: can maybe be folded into a HAVE later on with
   }
 }
 
-const oplog = exports.oplog = {}
+const oplog = (exports.oplog = {})
 
 oplog.entry = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // flags
     if (m.userData) keyValue.preencode(state, m.userData)
     if (m.treeNodes) nodeArray.preencode(state, m.treeNodes)
     if (m.treeUpgrade) treeUpgrade.preencode(state, m.treeUpgrade)
     if (m.bitfield) bitfieldUpdate.preencode(state, m.bitfield)
   },
-  encode (state, m) {
+  encode(state, m) {
     const s = state.start++
     let flags = 0
 
@@ -764,7 +782,7 @@ oplog.entry = {
 
     state.buffer[s] = flags
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
     return {
       userData: (flags & 1) !== 0 ? keyValue.decode(state) : null,
@@ -776,15 +794,15 @@ oplog.entry = {
 }
 
 const keyPair = {
-  preencode (state, kp) {
+  preencode(state, kp) {
     c.buffer.preencode(state, kp.publicKey)
     c.buffer.preencode(state, kp.secretKey)
   },
-  encode (state, kp) {
+  encode(state, kp) {
     c.buffer.encode(state, kp.publicKey)
     c.buffer.encode(state, kp.secretKey)
   },
-  decode (state) {
+  decode(state) {
     return {
       publicKey: c.buffer.decode(state),
       secretKey: c.buffer.decode(state)
@@ -793,17 +811,17 @@ const keyPair = {
 }
 
 const reorgHint = {
-  preencode (state, r) {
+  preencode(state, r) {
     c.uint.preencode(state, r.from)
     c.uint.preencode(state, r.to)
     c.uint.preencode(state, r.ancestors)
   },
-  encode (state, r) {
+  encode(state, r) {
     c.uint.encode(state, r.from)
     c.uint.encode(state, r.to)
     c.uint.encode(state, r.ancestors)
   },
-  decode (state) {
+  decode(state) {
     return {
       from: c.uint.decode(state),
       to: c.uint.decode(state),
@@ -815,15 +833,15 @@ const reorgHint = {
 const reorgHintArray = c.array(reorgHint)
 
 const hints = {
-  preencode (state, h) {
+  preencode(state, h) {
     reorgHintArray.preencode(state, h.reorgs)
     c.uint.preencode(state, h.contiguousLength)
   },
-  encode (state, h) {
+  encode(state, h) {
     reorgHintArray.encode(state, h.reorgs)
     c.uint.encode(state, h.contiguousLength)
   },
-  decode (state) {
+  decode(state) {
     return {
       reorgs: reorgHintArray.decode(state),
       contiguousLength: state.start < state.end ? c.uint.decode(state) : 0
@@ -832,19 +850,19 @@ const hints = {
 }
 
 const treeHeader = {
-  preencode (state, t) {
+  preencode(state, t) {
     c.uint.preencode(state, t.fork)
     c.uint.preencode(state, t.length)
     c.buffer.preencode(state, t.rootHash)
     c.buffer.preencode(state, t.signature)
   },
-  encode (state, t) {
+  encode(state, t) {
     c.uint.encode(state, t.fork)
     c.uint.encode(state, t.length)
     c.buffer.encode(state, t.rootHash)
     c.buffer.encode(state, t.signature)
   },
-  decode (state) {
+  decode(state) {
     return {
       fork: c.uint.decode(state),
       length: c.uint.decode(state),
@@ -855,17 +873,17 @@ const treeHeader = {
 }
 
 const types = {
-  preencode (state, t) {
+  preencode(state, t) {
     c.string.preencode(state, t.tree)
     c.string.preencode(state, t.bitfield)
     c.string.preencode(state, t.signer)
   },
-  encode (state, t) {
+  encode(state, t) {
     c.string.encode(state, t.tree)
     c.string.encode(state, t.bitfield)
     c.string.encode(state, t.signer)
   },
-  decode (state) {
+  decode(state) {
     return {
       tree: c.string.decode(state),
       bitfield: c.string.decode(state),
@@ -875,15 +893,15 @@ const types = {
 }
 
 const externalHeader = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.start)
     c.uint.preencode(state, m.length)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.start)
     c.uint.encode(state, m.length)
   },
-  decode (state) {
+  decode(state) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state)
@@ -894,7 +912,7 @@ const externalHeader = {
 const keyValueArray = c.array(keyValue)
 
 oplog.header = {
-  preencode (state, h) {
+  preencode(state, h) {
     state.end += 2 // version + flags
     if (h.external) {
       externalHeader.preencode(state, h.external)
@@ -907,7 +925,7 @@ oplog.header = {
     treeHeader.preencode(state, h.tree)
     hints.preencode(state, h.hints)
   },
-  encode (state, h) {
+  encode(state, h) {
     c.uint.encode(state, 1)
     if (h.external) {
       c.uint.encode(state, 1) // ONLY set the first big for clarity
@@ -922,7 +940,7 @@ oplog.header = {
     treeHeader.encode(state, h.tree)
     hints.encode(state, h.hints)
   },
-  decode (state) {
+  decode(state) {
     const version = c.uint.decode(state)
 
     if (version > 1) {
@@ -946,11 +964,13 @@ oplog.header = {
           hash: old.types.tree,
           allowPatch: false,
           quorum: 1,
-          signers: [{
-            signature: old.types.signer,
-            namespace: DEFAULT_NAMESPACE,
-            publicKey: old.signer.publicKey
-          }],
+          signers: [
+            {
+              signature: old.types.signer,
+              namespace: DEFAULT_NAMESPACE,
+              publicKey: old.signer.publicKey
+            }
+          ],
           prologue: null,
           linked: null,
           userData: null
@@ -991,17 +1011,17 @@ oplog.header = {
 const uintArray = c.array(c.uint)
 
 const multisigInput = {
-  preencode (state, inp) {
+  preencode(state, inp) {
     c.uint.preencode(state, inp.signer)
     c.fixed64.preencode(state, inp.signature)
     c.uint.preencode(state, inp.patch)
   },
-  encode (state, inp) {
+  encode(state, inp) {
     c.uint.encode(state, inp.signer)
     c.fixed64.encode(state, inp.signature)
     c.uint.encode(state, inp.patch)
   },
-  decode (state) {
+  decode(state) {
     return {
       signer: c.uint.decode(state),
       signature: c.fixed64.decode(state),
@@ -1011,17 +1031,17 @@ const multisigInput = {
 }
 
 const patchEncodingv0 = {
-  preencode (state, n) {
+  preencode(state, n) {
     c.uint.preencode(state, n.start)
     c.uint.preencode(state, n.length)
     uintArray.preencode(state, n.nodes)
   },
-  encode (state, n) {
+  encode(state, n) {
     c.uint.encode(state, n.start)
     c.uint.encode(state, n.length)
     uintArray.encode(state, n.nodes)
   },
-  decode (state) {
+  decode(state) {
     return {
       start: c.uint.decode(state),
       length: c.uint.decode(state),
@@ -1031,24 +1051,24 @@ const patchEncodingv0 = {
 }
 
 const multisigInputv0 = {
-  preencode (state, n) {
+  preencode(state, n) {
     state.end++
     c.uint.preencode(state, n.signer)
     c.fixed64.preencode(state, n.signature)
     if (n.patch) patchEncodingv0.preencode(state, n.patch)
   },
-  encode (state, n) {
+  encode(state, n) {
     c.uint.encode(state, n.patch ? 1 : 0)
     c.uint.encode(state, n.signer)
     c.fixed64.encode(state, n.signature)
     if (n.patch) patchEncodingv0.encode(state, n.patch)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
     return {
       signer: c.uint.decode(state),
       signature: c.fixed64.decode(state),
-      patch: (flags & 1) ? patchEncodingv0.decode(state) : null
+      patch: flags & 1 ? patchEncodingv0.decode(state) : null
     }
   }
 }
@@ -1057,17 +1077,17 @@ const multisigInputArrayv0 = c.array(multisigInputv0)
 const multisigInputArray = c.array(multisigInput)
 
 const compactNode = {
-  preencode (state, n) {
+  preencode(state, n) {
     c.uint.preencode(state, n.index)
     c.uint.preencode(state, n.size)
     c.fixed32.preencode(state, n.hash)
   },
-  encode (state, n) {
+  encode(state, n) {
     c.uint.encode(state, n.index)
     c.uint.encode(state, n.size)
     c.fixed32.encode(state, n.hash)
   },
-  decode (state) {
+  decode(state) {
     return {
       index: c.uint.decode(state),
       size: c.uint.decode(state),
@@ -1079,15 +1099,15 @@ const compactNode = {
 const compactNodeArray = c.array(compactNode)
 
 exports.multiSignaturev0 = {
-  preencode (state, s) {
+  preencode(state, s) {
     multisigInputArrayv0.preencode(state, s.proofs)
     compactNodeArray.preencode(state, s.patch)
   },
-  encode (state, s) {
+  encode(state, s) {
     multisigInputArrayv0.encode(state, s.proofs)
     compactNodeArray.encode(state, s.patch)
   },
-  decode (state) {
+  decode(state) {
     return {
       proofs: multisigInputArrayv0.decode(state),
       patch: compactNodeArray.decode(state)
@@ -1096,15 +1116,15 @@ exports.multiSignaturev0 = {
 }
 
 exports.multiSignature = {
-  preencode (state, s) {
+  preencode(state, s) {
     multisigInputArray.preencode(state, s.proofs)
     compactNodeArray.preencode(state, s.patch)
   },
-  encode (state, s) {
+  encode(state, s) {
     multisigInputArray.encode(state, s.proofs)
     compactNodeArray.encode(state, s.patch)
   },
-  decode (state) {
+  decode(state) {
     return {
       proofs: multisigInputArray.decode(state),
       patch: compactNodeArray.decode(state)