@mblaney/holster 1.0.24 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",

package/src/get.js

@@ -24,16 +24,26 @@ const Get = (lex, graph) => {
 
     node[key] = graph[soul][key]
     node._[">"][key] = graph[soul]._[">"][key]
-    if (graph[soul]._["s"] && graph[soul]._["s"][key]) {
-      signatures[key] = graph[soul]._["s"][key]
+    const state = graph[soul]._[">"][key]
+    if (graph[soul]._["s"]) {
+      if (graph[soul]._["s"][state]) {
+        signatures[state] = graph[soul]._["s"][state]
+      } else if (graph[soul]._["s"][key]) {
+        signatures[key] = graph[soul]._["s"][key]
+      }
     }
   } else {
     for (const key of Object.keys(graph[soul])) {
       if (match(lex["."], key)) {
         node[key] = graph[soul][key]
         node._[">"][key] = graph[soul]._[">"][key]
-        if (graph[soul]._["s"] && graph[soul]._["s"][key]) {
-          signatures[key] = graph[soul]._["s"][key]
+        const state = graph[soul]._[">"][key]
+        if (graph[soul]._["s"]) {
+          if (graph[soul]._["s"][state]) {
+            signatures[state] = graph[soul]._["s"][state]
+          } else if (graph[soul]._["s"][key]) {
+            signatures[key] = graph[soul]._["s"][key]
+          }
         }
       }
     }

package/src/ham.js

@@ -7,12 +7,20 @@ const MAX_GRAPH_SIZE = 10000
 
 // state and value are the incoming changes.
 // currentState and currentValue are the current graph data.
-const Ham = (state, currentState, value, currentValue) => {
+const Ham = (state, currentState, value, currentValue, signed = false) => {
   if (state < currentState) return {historical: true}
 
   if (state > currentState) return {incoming: true}
 
-  // state is equal to currentState, lexically compare to resolve conflict.
+  // state is equal to currentState
+  // If using signed timestamps then reject conflicting values because the
+  // owner can only create one value per timestamp.
+  if (signed && value !== currentValue) {
+    console.log(`Signed timestamp ${state}: reject conflicting value`)
+    return {historical: true}
+  }
+
+  // Lexically compare to resolve conflict (for unsigned or matching values)
   if (typeof value !== "string") {
     value = JSON.stringify(value) || ""
   }
@@ -44,6 +52,7 @@ Ham.mix = async (change, graph, secure, listen) => {
   const now = {}
   const defer = {}
   const validProperties = new Map() // Track valid properties per soul
+  const validTimestamps = new Map() // Track valid timestamps per soul
   let wait = 0
 
   for (const soul of Object.keys(change)) {
@@ -56,7 +65,7 @@ Ham.mix = async (change, graph, secure, listen) => {
     if (!node || !node._) continue
 
     const pub = node[utils.userPublicKey]
-    // If per-property signatures and public key are provided then always verify.
+    // If timestamp signatures and public key are provided then always verify
     if (node._["s"] && pub) verify = true
 
     // Special case if soul starts with "~". Node must be system data ie,
@@ -77,21 +86,39 @@ Ham.mix = async (change, graph, secure, listen) => {
       }
     }
     if (verify) {
-      // Per-property signatures stored in node._["s"]
+      // Signature verification: check node._["s"] which can contain:
+      // 1. Per-property signatures (legacy): keys are property names
+      // 2. Timestamp signatures (new): keys are numeric timestamps
       if (!pub || !node._) {
         continue
       }
 
-      // Verify properties individually, returns array of valid property names
-      const validProps = await SEA.verifyProperties(node, pub)
+      const signedTimestamps = new Set()
+      const signedProperties = new Set()
+      for (const [key, sig] of Object.entries(node._["s"] || {})) {
+        const asNumber = Number(key)
+        if (!isNaN(asNumber) && asNumber > 0) {
+          const isValid = await SEA.verifyTimestamp(asNumber, sig, pub)
+          if (isValid) {
+            signedTimestamps.add(asNumber)
+            // Add all properties with this timestamp to signed set
+            for (const [prop, ts] of Object.entries(node._[">"] || {})) {
+              if (ts === asNumber) {
+                signedProperties.add(prop)
+              }
+            }
+          }
+        }
+      }
 
       // If no properties verified, skip this update
-      if (validProps.length === 0) {
+      if (signedProperties.size === 0) {
         continue
       }
 
-      // Track valid properties for this soul
-      validProperties.set(soul, new Set(validProps))
+      // Track signed properties and timestamps for this soul
+      validProperties.set(soul, signedProperties)
+      validTimestamps.set(soul, signedTimestamps)
     }
 
     for (const key of Object.keys(node)) {
@@ -100,7 +127,6 @@ Ham.mix = async (change, graph, secure, listen) => {
       // Skip metadata fields (including userSignature for old data)
       if (key === utils.userSignature || key === utils.userPublicKey) continue
 
-      // If this soul had verification, only process properties that have valid signatures
       // Properties without signatures in this update are left unchanged
       if (validProperties.has(soul) && !validProperties.get(soul).has(key)) {
         continue
@@ -129,11 +155,18 @@ Ham.mix = async (change, graph, secure, listen) => {
         }
         defer[soul][key] = value
         defer[soul]._[">"][key] = state
-        if (node._["s"] && node._["s"][key]) {
-          defer[soul]._["s"][key] = node._["s"][key]
+        if (node._["s"]) {
+          if (node._["s"][state]) {
+            defer[soul]._["s"][state] = node._["s"][state]
+          } else if (node._["s"][key]) {
+            defer[soul]._["s"][key] = node._["s"][key]
+          }
         }
       } else {
-        const result = Ham(state, currentState, value, currentValue)
+        // Check if this property has a signed timestamp
+        const isSigned =
+          validTimestamps.has(soul) && validTimestamps.get(soul).has(state)
+        const result = Ham(state, currentState, value, currentValue, isSigned)
         if (result.incoming) {
           if (!now[soul]) {
             now[soul] = {_: {"#": soul, ">": {}, s: {}}}
@@ -143,8 +176,13 @@ Ham.mix = async (change, graph, secure, listen) => {
           }
           graph[soul][key] = now[soul][key] = value
           graph[soul]._[">"][key] = now[soul]._[">"][key] = state
-          if (node._["s"] && node._["s"][key]) {
-            graph[soul]._["s"][key] = now[soul]._["s"][key] = node._["s"][key]
+          if (node._["s"]) {
+            if (node._["s"][state]) {
+              graph[soul]._["s"][state] = now[soul]._["s"][state] =
+                node._["s"][state]
+            } else if (node._["s"][key]) {
+              graph[soul]._["s"][key] = now[soul]._["s"][key] = node._["s"][key]
+            }
           }
           // Call event listeners for update on key, mix is called before
           // put has finished so wait for what could be multiple nested
@@ -163,11 +201,6 @@ Ham.mix = async (change, graph, secure, listen) => {
       }
     }
 
-    if (verify && nodeWait !== 0 && now[soul]) {
-      // Secure updates can't be split, so move now to deferred as well.
-      Object.assign(defer[soul], now[soul])
-      delete now[soul]
-    }
     // Call event listeners for update on soul.
     if (updated && listen[soul]) {
       setTimeout(() => {

package/src/holster.js

@@ -97,9 +97,10 @@ const Holster = opt => {
 
     const graph = async (soul, data, userctx, cb) => {
       if (userctx) {
-        // Sign each property individually
-        const propertySignatures = await SEA.signProperties(data, userctx)
-        return utils.graph(soul, data, propertySignatures, userctx.pub)
+        // Sign the timestamp
+        const timestamp = Date.now()
+        const sig = await SEA.signTimestamp(timestamp, userctx)
+        return utils.graph(soul, data, sig, userctx.pub, timestamp)
       }
 
       if (opt.secure) {
@@ -270,7 +271,7 @@ const Holster = opt => {
         // Top level keys are added to a root node so their values don't need
         // to be objects.
         ctxid = utils.text.random()
-        allctx.set(ctxid, {chain: [{item: key, soul: "root"}], cb: cb})
+        allctx.set(ctxid, {chain: [{item: String(key), soul: "root"}], cb: cb})
         if (!cb) return api(ctxid)
 
         const _done = done(ctxid)
@@ -325,7 +326,7 @@ const Holster = opt => {
 
         // Push the key to the context as it needs a soul lookup.
         // (null is used to call the api with updated context)
-        if (key !== null) ctx.chain.push({item: key, soul: null})
+        if (key !== null) ctx.chain.push({item: String(key), soul: null})
         if (!ctx.cb) return api(ctxid)
 
         // When there's a callback need to resolve the context first.
@@ -446,81 +447,92 @@ const Holster = opt => {
 
         // Otherwise put the data using the keys returned in result.
         // Need to check if a rel has already been added on the current node.
-        wire.get({"#": soul, ".": item}, async msg => {
-          if (msg.err) {
-            _ack(`error getting ${soul}.${item}: ${msg.err}`)
-            return
-          }
+        // Use attemptRead to retry if data hasn't propagated yet.
+        const attemptRead = (retries = 0) => {
+          wire.get({"#": soul, ".": item}, async msg => {
+            if (msg.err) {
+              _ack(`error getting ${soul}.${item}: ${msg.err}`)
+              return
+            }
 
-          let node = msg.put && msg.put[soul]
-          const current = node && node[item]
-          const id = utils.rel.is(current)
-          if (!id) {
-            // The current rel doesn't exist, so add it first.
-            if (!node) node = {}
-            node[item] = utils.rel.ify(utils.text.random())
-            const g = await graph(soul, node, ctx.user, _ack)
-            if (g === null) return
-
-            wire.put(g, err => {
-              if (err) {
-                _ack(`error putting ${item} on ${soul}: ${err}`)
-              } else {
-                const _ctxid = utils.text.random()
-                const chain = [{item: item, soul: soul}]
-                // Pass on the previous context's callback and user flag here.
-                allctx.set(_ctxid, {chain: chain, user: ctx.user, cb: ctx.cb})
-                api(_ctxid).put(data)
-              }
-            })
-            return
-          }
+            let node = msg.put && msg.put[soul]
+            const current = node && node[item]
 
-          const update = []
-          for (const key of result) {
-            const err = await new Promise(res => {
-              if (utils.obj.is(data[key]) && !utils.rel.is(data[key])) {
-                // Use the current rel as the context for nested objects.
-                const _ctxid = utils.text.random()
-                const chain = [{item: key, soul: id}]
-                allctx.set(_ctxid, {chain: chain, user: ctx.user})
-                api(_ctxid).put(data[key], res)
-              } else {
-                // Group the rest of the updates for put below.
-                update.push(key)
-                res(null)
-              }
-            })
-            if (err) {
-              _ack(err, ctxid)
+            // If we didn't find the item but still have retries, retry
+            if (!current && retries < 5) {
+              await new Promise(r => setTimeout(r, 50))
+              return attemptRead(retries + 1)
+            }
+
+            const id = utils.rel.is(current)
+            if (!id) {
+              // The current rel doesn't exist, so add it first.
+              if (!node) node = {}
+              node[item] = utils.rel.ify(utils.text.random())
+              const g = await graph(soul, node, ctx.user, _ack)
+              if (g === null) return
+
+              wire.put(g, err => {
+                if (err) {
+                  _ack(`error putting ${item} on ${soul}: ${err}`)
+                } else {
+                  const _ctxid = utils.text.random()
+                  const chain = [{item: item, soul: soul}]
+                  // Pass on the previous context's callback and user flag here.
+                  allctx.set(_ctxid, {chain: chain, user: ctx.user, cb: ctx.cb})
+                  api(_ctxid).put(data)
+                }
+              })
               return
             }
-          }
 
-          if (update.length === 0) {
-            _ack(null)
-            return
-          }
+            const update = []
+            for (const key of result) {
+              const err = await new Promise(res => {
+                if (utils.obj.is(data[key]) && !utils.rel.is(data[key])) {
+                  // Use the current rel as the context for nested objects.
+                  const _ctxid = utils.text.random()
+                  const chain = [{item: key, soul: id}]
+                  allctx.set(_ctxid, {chain: chain, user: ctx.user})
+                  api(_ctxid).put(data[key], res)
+                } else {
+                  // Group the rest of the updates for put below.
+                  update.push(key)
+                  res(null)
+                }
+              })
+              if (err) {
+                _ack(err, ctxid)
+                return
+              }
+            }
 
-          // The nested objects created above will also have rels on the parent
-          // object, so fetch the node so the rest of the updates can be added.
-          wire.get({"#": id}, async msg => {
-            if (msg.err) {
-              _ack(`error getting ${id}: ${msg.err}`)
+            if (update.length === 0) {
+              _ack(null)
               return
             }
 
-            let node = msg.put && msg.put[id]
-            if (!node) node = {}
-            update.forEach(key => {
-              node[key] = data[key]
-            })
-            const g = await graph(id, node, ctx.user, _ack)
-            if (g === null) return
+            // The nested objects created above will also have rels on the parent
+            // object, so fetch the node so the rest of the updates can be added.
+            wire.get({"#": id}, async msg => {
+              if (msg.err) {
+                _ack(`error getting ${id}: ${msg.err}`)
+                return
+              }
 
-            wire.put(g, _ack)
+              let node = msg.put && msg.put[id]
+              if (!node) node = {}
+              update.forEach(key => {
+                node[key] = data[key]
+              })
+              const g = await graph(id, node, ctx.user, _ack)
+              if (g === null) return
+
+              wire.put(g, _ack)
+            })
           })
-        })
+        }
+        attemptRead()
       },
       on: (lex, cb, _get, _opt) => {
         if (typeof lex === "function") {
@@ -557,8 +569,8 @@ const Holster = opt => {
               const current = msg.put && msg.put[soul] && msg.put[soul][item]
               const id = utils.rel.is(current)
               if (id) {
-                // It's a rel, read the related node. It might not be in the graph
-                // yet when the listener fires, so we retry with delays.
+                // It's a rel, read the related node. It might not be in the
+                // graph yet when the listener fires, so we retry with delays.
                 const attemptRead = async (retries = 0) => {
                   const data = await new Promise(res => {
                     const _ctxid = utils.text.random()
@@ -587,8 +599,16 @@ const Holster = opt => {
         // queueing. Initially register the soul without _get, then update if
         // it's a rel.
         let initialLex
-        if (lex) initialLex = utils.obj.put(lex, "#", soul)
-        else initialLex = {"#": soul, ".": item}
+        if (lex) {
+          initialLex = utils.obj.put(lex, "#", soul)
+          // Normalize numeric property filters to strings for wire operations
+          // Only convert if it's a number, not if it's a complex filter object
+          if (initialLex["."] != null && typeof initialLex["."] === "number") {
+            initialLex = {...initialLex, ".": String(initialLex["."])}
+          }
+        } else {
+          initialLex = {"#": soul, ".": item}
+        }
         wire.on(initialLex, map.get(cb), false, _opt)
 
         // Check if item is a rel and update listener if needed.
@@ -609,7 +629,7 @@ const Holster = opt => {
               wire.off(initialLex, map.get(cb))
               // Then add listener on the related node
               let relLex
-              if (lex) relLex = utils.obj.put(lex, "#", id)
+              if (lex) relLex = utils.obj.put(initialLex, "#", id)
               else relLex = {"#": id, ".": null}
               wire.on(relLex, map.get(cb), _get, _opt)
             } else if (_get) {
@@ -691,7 +711,7 @@ const Holster = opt => {
             }
 
             ctxid = utils.text.random()
-            const chain = [{item: key, soul: "~" + pub}]
+            const chain = [{item: String(key), soul: "~" + pub}]
             allctx.set(ctxid, {chain: chain, user: user.is, cb: cb})
             if (!cb) return api(ctxid)
 

package/src/sea.js

@@ -135,59 +135,6 @@ const SEA = {
     if (cb) cb(null)
     return null
   },
-  // Verify individual property signatures stored in node._["s"]
-  // Returns array of valid property names
-  verifyProperties: async (node, pub, cb) => {
-    if (!pub || !node) {
-      if (cb) cb([])
-      return []
-    }
-
-    const key = await utils.subtle.importKey(
-      "jwk",
-      utils.jwk(pub),
-      {name: "ECDSA", namedCurve: "P-256"},
-      false,
-      ["verify"],
-    )
-
-    const alg = {name: "ECDSA", hash: {name: "SHA-256"}}
-    const valid = []
-    const propertySignatures = (node._ && node._["s"]) || {}
-
-    // Verify each property individually
-    for (const k of Object.keys(node).sort()) {
-      if (k === "_" || k == userPublicKey) continue
-
-      const propSig = propertySignatures[k]
-      if (!propSig) {
-        console.log(`warning: property '${k}' missing signature`)
-        continue
-      }
-
-      try {
-        const hash = await utils.sha256(node[k])
-        const sig = new Uint8Array(SafeBuffer.from(propSig, "base64"))
-
-        const isValid = await utils.subtle.verify(
-          alg,
-          key,
-          sig,
-          new Uint8Array(hash),
-        )
-        if (isValid) {
-          valid.push(k)
-        } else {
-          console.log(`warning: property '${k}' signature verification failed`)
-        }
-      } catch (err) {
-        console.log(`warning: property '${k}' error verifying: ${err.message}`)
-      }
-    }
-
-    if (cb) cb(valid)
-    return valid
-  },
   sign: async (data, pair, cb) => {
     if (!pair || !pair.pub || !pair.priv) {
       if (cb) cb(null)
@@ -225,36 +172,71 @@ const SEA = {
     if (cb) cb(signed)
     return signed
   },
-  // Sign individual properties for per-property verification
-  signProperties: async (data, pair, cb) => {
+  // Sign a timestamp to prove ownership of an update
+  signTimestamp: async (timestamp, pair, cb) => {
     if (!pair || !pair.pub || !pair.priv) {
       if (cb) cb(null)
       return null
     }
 
-    const check = utils.parse(data)
-    const propertySignatures = {}
+    // Convert timestamp to string for consistent hashing
+    const timestampStr = timestamp.toString()
+    const hash = await utils.sha256(timestampStr)
     const jwk = utils.jwk(pair.pub, pair.priv)
     const alg = {name: "ECDSA", namedCurve: "P-256"}
-    const key = await utils.subtle.importKey("jwk", jwk, alg, false, ["sign"])
 
-    // Sign each property individually
-    for (const k of Object.keys(check).sort()) {
-      if (k !== "_" && k != userPublicKey && k != userSignature) {
-        const hash = await utils.sha256(check[k])
-        const sig = await utils.subtle.sign(
+    const sig = await utils.subtle
+      .importKey("jwk", jwk, alg, false, ["sign"])
+      .then(key =>
+        utils.subtle.sign(
           {name: "ECDSA", hash: {name: "SHA-256"}},
           key,
           new Uint8Array(hash),
-        )
-        propertySignatures[k] = SafeBuffer.from(sig, "binary").toString(
-          "base64",
-        )
-      }
+        ),
+      )
+
+    const signature = SafeBuffer.from(sig, "binary").toString("base64")
+
+    if (cb) cb(signature)
+    return signature
+  },
+  // Verify a timestamp signature to confirm ownership of update
+  verifyTimestamp: async (timestamp, signature, publicKey, cb) => {
+    if (!publicKey || !timestamp || !signature) {
+      if (cb) cb(false)
+      return false
     }
 
-    if (cb) cb(propertySignatures)
-    return propertySignatures
+    try {
+      // Convert timestamp to string for consistent hashing
+      const timestampStr = timestamp.toString()
+      const hash = await utils.sha256(timestampStr)
+
+      const key = await utils.subtle.importKey(
+        "jwk",
+        utils.jwk(publicKey),
+        {name: "ECDSA", namedCurve: "P-256"},
+        false,
+        ["verify"],
+      )
+
+      const sig = new Uint8Array(SafeBuffer.from(signature, "base64"))
+      const alg = {name: "ECDSA", hash: {name: "SHA-256"}}
+
+      const isValid = await utils.subtle.verify(
+        alg,
+        key,
+        sig,
+        new Uint8Array(hash),
+      )
+
+      if (cb) cb(isValid)
+      return isValid
+    } catch (err) {
+      console.log(`error verifying timestamp signature: ${err.message}`)
+      if (cb) cb(false)
+      return false
+    }
   },
   work: async (data, salt, cb) => {
     if (typeof salt === "function") {

package/src/store.js

@@ -233,6 +233,11 @@ const Store = opt => {
         node._[">"][key] = value[1]
         // If signature is present, store it in _["s"]
         if (value.length === 3 && value[2]) {
+          const state = value[1]
+          // Store signature under both state and key for compatibility
+          signatures[state] = value[2]
+          // TODO: Can probably remove the following when old data is no
+          // longer a problem.
           signatures[key] = value[2]
         }
       }
@@ -286,8 +291,7 @@ const Store = opt => {
           count++
           let value = node[key]
           let state = node._[">"][key]
-          let sig = node._["s"] && node._["s"][key]
-          // Only pass signature if it exists, otherwise just [value, state]
+          let sig = node._["s"] && node._["s"][state]
           let data = sig ? [value, state, sig] : [value, state]
           radisk(soul + enq + key, data, ack)
         })