hypercore-storage 2.7.1 → 2.9.0

package/index.js

@@ -21,6 +21,7 @@ const {
   createBitfieldStream,
   createUserDataStream,
   createTreeNodeStream,
+  createMarkStream,
   createLocalStream
 } = require('./lib/streams.js')
 
@@ -238,6 +239,10 @@ class HypercoreStorage {
     return createUserDataStream(this.core, this.db, this.view, opts)
   }
 
+  createMarkStream(opts) {
+    return createMarkStream(this.core, this.db, this.view, opts)
+  }
+
   createLocalStream(opts) {
     return createLocalStream(this.core, this.db, this.view, opts)
   }

package/lib/keys.js

@@ -21,6 +21,7 @@ const DATA_TREE = 4
 const DATA_BITFIELD = 5
 const DATA_USER_DATA = 6
 const DATA_LOCAL = 7
+const DATA_MARK = 8
 
 const slab = { buffer: b4a.allocUnsafe(65536), start: 0, end: 0 }
 
@@ -224,6 +225,16 @@ core.userDataEnd = function (ptr) {
   return state.buffer.subarray(start, state.start)
 }
 
+core.mark = function (ptr, index) {
+  const state = alloc()
+  const start = state.start
+  UINT.encode(state, TL_DATA)
+  UINT.encode(state, ptr)
+  UINT.encode(state, DATA_MARK)
+  UINT.encode(state, index)
+  return state.buffer.subarray(start, state.start)
+}
+
 core.local = function (ptr, key) {
   if (key.byteLength > 2048) {
     throw new Error('local keys has an upper limit of 2048 bytes atm')
@@ -273,6 +284,14 @@ core.userDataKey = function (buffer) {
   return STRING.decode(state)
 }
 
+core.markKey = function (buffer) {
+  const state = { buffer, start: 0, end: buffer.byteLength }
+  UINT.decode(state) // ns
+  UINT.decode(state) // ptr
+  UINT.decode(state) // type
+  return UINT.decode(state)
+}
+
 core.localKey = function (buffer) {
   const state = { buffer, start: 0, end: buffer.byteLength }
   UINT.decode(state) // ns

package/lib/streams.js

@@ -15,6 +15,7 @@ module.exports = {
   createAliasStream,
   createDiscoveryKeyStream,
   createTreeNodeStream,
+  createMarkStream,
   createLocalStream
 }
 
@@ -117,6 +118,20 @@ function createUserDataStream(
   return ite
 }
 
+function createMarkStream(
+  ptr,
+  db,
+  view,
+  { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}
+) {
+  const s = core.mark(ptr.dataPointer, gte)
+  const e = core.mark(ptr.dataPointer, lt === -1 ? Infinity : lt)
+  const ite = view.iterator(db, s, e, reverse)
+
+  ite._readableState.map = mapMark
+  return ite
+}
+
 function createLocalStream(
   ptr,
   db,
@@ -139,6 +154,11 @@ function mapBitfield(data) {
   return { index, page: data.value }
 }
 
+function mapMark(data) {
+  const index = core.markKey(data.key)
+  return { index, page: data.value }
+}
+
 function mapLocal(data) {
   const key = core.localKey(data.key)
   return { key, value: data.value }

package/lib/tx.js

@@ -108,6 +108,22 @@ class CoreTX {
     this.changes.push([core.userData(this.core.dataPointer, key), null, null])
   }
 
+  putMark(index, data) {
+    this.changes.push([core.mark(this.core.dataPointer, index), data, null])
+  }
+
+  deleteMark(index) {
+    this.changes.push([core.mark(this.core.dataPointer, index), null, null])
+  }
+
+  deleteMarkRange(start, end) {
+    this.changes.push([
+      core.mark(this.core.dataPointer, start),
+      null,
+      core.mark(this.core.dataPointer, end === -1 ? Infinity : end)
+    ])
+  }
+
   putLocal(key, value) {
     this.changes.push([core.local(this.core.dataPointer, key), value, null])
   }
@@ -213,6 +229,10 @@ class CoreRX {
     return this.view.get(this.read, core.userData(this.core.dataPointer, key))
   }
 
+  getMark(index) {
+    return this.view.get(this.read, core.mark(this.core.dataPointer, index))
+  }
+
   getLocal(key) {
     return this.view.get(this.read, core.local(this.core.dataPointer, key))
   }

package/migrations/0/messages.js

@@ -364,14 +364,14 @@ const dataUpgrade = {
     c.uint.preencode(state, u.length)
     nodeArray.preencode(state, u.nodes)
     nodeArray.preencode(state, u.additionalNodes)
-    c.buffer.preencode(state, u.signature)
+    c.optionalBuffer.preencode(state, u.signature)
   },
   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)
+    c.optionalBuffer.encode(state, u.signature)
   },
   decode (state) {
     return {
@@ -379,7 +379,7 @@ const dataUpgrade = {
       length: c.uint.decode(state),
       nodes: nodeArray.decode(state),
       additionalNodes: nodeArray.decode(state),
-      signature: c.buffer.decode(state)
+      signature: c.optionalBuffer.decode(state)
     }
   }
 }
@@ -404,18 +404,18 @@ const dataSeek = {
 const dataBlock = {
   preencode (state, b) {
     c.uint.preencode(state, b.index)
-    c.buffer.preencode(state, b.value)
+    c.optionalBuffer.preencode(state, b.value)
     nodeArray.preencode(state, b.nodes)
   },
   encode (state, b) {
     c.uint.encode(state, b.index)
-    c.buffer.encode(state, b.value)
+    c.optionalBuffer.encode(state, b.value)
     nodeArray.encode(state, b.nodes)
   },
   decode (state) {
     return {
       index: c.uint.decode(state),
-      value: c.buffer.decode(state) || EMPTY,
+      value: c.optionalBuffer.decode(state) || EMPTY,
       nodes: nodeArray.decode(state)
     }
   }
@@ -633,16 +633,16 @@ wire.extension = {
 const keyValue = {
   preencode (state, p) {
     c.string.preencode(state, p.key)
-    c.buffer.preencode(state, p.value)
+    c.optionalBuffer.preencode(state, p.value)
   },
   encode (state, p) {
     c.string.encode(state, p.key)
-    c.buffer.encode(state, p.value)
+    c.optionalBuffer.encode(state, p.value)
   },
   decode (state) {
     return {
       key: c.string.decode(state),
-      value: c.buffer.decode(state)
+      value: c.optionalBuffer.decode(state)
     }
   }
 }
@@ -652,20 +652,20 @@ const treeUpgrade = {
     c.uint.preencode(state, u.fork)
     c.uint.preencode(state, u.ancestors)
     c.uint.preencode(state, u.length)
-    c.buffer.preencode(state, u.signature)
+    c.optionalBuffer.preencode(state, u.signature)
   },
   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)
+    c.optionalBuffer.encode(state, u.signature)
   },
   decode (state) {
     return {
       fork: c.uint.decode(state),
       ancestors: c.uint.decode(state),
       length: c.uint.decode(state),
-      signature: c.buffer.decode(state)
+      signature: c.optionalBuffer.decode(state)
     }
   }
 }
@@ -737,17 +737,17 @@ oplog.entry = {
 
 const keyPair = {
   preencode (state, kp) {
-    c.buffer.preencode(state, kp.publicKey)
-    c.buffer.preencode(state, kp.secretKey)
+    c.optionalBuffer.preencode(state, kp.publicKey)
+    c.optionalBuffer.preencode(state, kp.secretKey)
   },
   encode (state, kp) {
-    c.buffer.encode(state, kp.publicKey)
-    c.buffer.encode(state, kp.secretKey)
+    c.optionalBuffer.encode(state, kp.publicKey)
+    c.optionalBuffer.encode(state, kp.secretKey)
   },
   decode (state) {
     return {
-      publicKey: c.buffer.decode(state),
-      secretKey: c.buffer.decode(state)
+      publicKey: c.optionalBuffer.decode(state),
+      secretKey: c.optionalBuffer.decode(state)
     }
   }
 }
@@ -795,21 +795,21 @@ const treeHeader = {
   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)
+    c.optionalBuffer.preencode(state, t.rootHash)
+    c.optionalBuffer.preencode(state, t.signature)
   },
   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)
+    c.optionalBuffer.encode(state, t.rootHash)
+    c.optionalBuffer.encode(state, t.signature)
   },
   decode (state) {
     return {
       fork: c.uint.decode(state),
       length: c.uint.decode(state),
-      rootHash: c.buffer.decode(state),
-      signature: c.buffer.decode(state)
+      rootHash: c.optionalBuffer.decode(state),
+      signature: c.optionalBuffer.decode(state)
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore-storage",
-  "version": "2.7.1",
+  "version": "2.9.0",
   "main": "index.js",
   "files": [
     "index.js",
@@ -41,7 +41,7 @@
     "b4a": "^1.6.7",
     "bare-fs": "^4.0.1",
     "bare-path": "^3.0.0",
-    "compact-encoding": "^2.16.0",
+    "compact-encoding": "^3.0.0",
     "device-file": "^2.1.2",
     "flat-tree": "^1.12.1",
     "hypercore-crypto": "^3.4.2",

package/spec/hyperschema/index.js

@@ -299,15 +299,15 @@ const encoding9 = {
 const encoding10 = {
   preencode(state, m) {
     c.buffer.preencode(state, m.publicKey)
-    c.buffer.preencode(state, m.secretKey)
+    c.optionalBuffer.preencode(state, m.secretKey)
   },
   encode(state, m) {
     c.buffer.encode(state, m.publicKey)
-    c.buffer.encode(state, m.secretKey)
+    c.optionalBuffer.encode(state, m.secretKey)
   },
   decode(state) {
     const r0 = c.buffer.decode(state)
-    const r1 = c.buffer.decode(state)
+    const r1 = c.optionalBuffer.decode(state)
 
     return {
       publicKey: r0,
@@ -362,19 +362,19 @@ const encoding12 = {
     c.uint.preencode(state, m.fork)
     c.uint.preencode(state, m.length)
     c.fixed32.preencode(state, m.rootHash)
-    c.buffer.preencode(state, m.signature)
+    c.optionalBuffer.preencode(state, m.signature)
   },
   encode(state, m) {
     c.uint.encode(state, m.fork)
     c.uint.encode(state, m.length)
     c.fixed32.encode(state, m.rootHash)
-    c.buffer.encode(state, m.signature)
+    c.optionalBuffer.encode(state, m.signature)
   },
   decode(state) {
     const r0 = c.uint.decode(state)
     const r1 = c.uint.decode(state)
     const r2 = c.fixed32.decode(state)
-    const r3 = c.buffer.decode(state)
+    const r3 = c.optionalBuffer.decode(state)
 
     return {
       fork: r0,