@fireproof/core 0.5.13 → 0.5.14

package/src/clock.js

@@ -21,17 +21,17 @@ import { CIDCounter } from 'prolly-trees/utils'
 
 /**
  * @typedef {{
-*   type: 'put'|'del'
-*   key: string
-*   value: import('./link').AnyLink
-*   root: import('./link').AnyLink
-* }} EventData
-* @typedef {{
-*   root: import('./link').AnyLink
-*   head: import('./clock').EventLink<EventData>[]
-*   event: import('./clock').EventBlockView<EventData>
-* }} Result
-*/
+ *   type: 'put'|'del'
+ *   key: string
+ *   value: import('./link').AnyLink
+ *   root: import('./link').AnyLink
+ * }} EventData
+ * @typedef {{
+ *   root: import('./link').AnyLink
+ *   head: import('./clock').EventLink<EventData>[]
+ *   event: import('./clock').EventBlockView<EventData>
+ * }} Result
+ */
 
 /**
  * Advance the clock by adding an event.
@@ -45,7 +45,7 @@ import { CIDCounter } from 'prolly-trees/utils'
 export async function advance (blocks, head, event) {
   /** @type {EventFetcher<T>} */
   const events = new EventFetcher(blocks)
-  const headmap = new Map(head.map((cid) => [cid.toString(), cid]))
+  const headmap = new Map(head.map(cid => [cid.toString(), cid]))
 
   // Check if the headmap already includes the event, return head if it does
   if (headmap.has(event.toString())) return { head, cids: await events.all() }
@@ -167,14 +167,16 @@ export async function decodeEventBlock (bytes) {
 async function contains (events, a, b) {
   if (a.toString() === b.toString()) return true
   const [{ value: aevent }, { value: bevent }] = await Promise.all([events.get(a), events.get(b)])
-  const links = [...aevent.parents]
+  // const links = [...aevent.parents]
+  // console.log('aevent', aevent.parents)
+  const links = [...(aevent.parents || [])]
   while (links.length) {
     const link = links.shift()
     if (!link) break
     if (link.toString() === b.toString()) return true
     // if any of b's parents are this link, then b cannot exist in any of the
     // tree below, since that would create a cycle.
-    if (bevent.parents.some((p) => link.toString() === p.toString())) continue
+    if (bevent.parents.some(p => link.toString() === p.toString())) continue
     const { value: event } = await events.get(link)
     links.push(...event.parents)
   }
@@ -190,15 +192,19 @@ async function contains (events, a, b) {
  */
 export async function * vis (blocks, head, options = {}) {
   // @ts-ignore
-  const renderNodeLabel = options.renderNodeLabel ?? ((b) => {
-    // @ts-ignore
-    const { key, root, type } = b.value.data
-    return b.cid.toString() + '\n' + JSON.stringify({ key, root: root.cid.toString(), type }, null, 2).replace(/"/g, '\'')
-  })
+  const renderNodeLabel =
+    options.renderNodeLabel ??
+    (b => {
+      // @ts-ignore
+      const { key, root, type } = b.value.data
+      return (
+        b.cid.toString() + '\n' + JSON.stringify({ key, root: root.cid.toString(), type }, null, 2).replace(/"/g, "'")
+      )
+    })
   const events = new EventFetcher(blocks)
   yield 'digraph clock {'
   yield '  node [shape=point fontname="Courier"]; head;'
-  const hevents = await Promise.all(head.map((link) => events.get(link)))
+  const hevents = await Promise.all(head.map(link => events.get(link)))
   const links = []
   const nodes = new Set()
   for (const e of hevents) {
@@ -231,17 +237,18 @@ export async function findEventsToSync (blocks, head) {
   // console.time(callTag + '.findCommonAncestorWithSortedEvents')
   const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
   // console.timeEnd(callTag + '.findCommonAncestorWithSortedEvents')
-  // console.log('sorted', sorted.length)
+  // console.log('sorted', !!ancestor, sorted.length)
   // console.time(callTag + '.contains')
-  const toSync = await asyncFilter(sorted, async (uks) => !(await contains(events, ancestor, uks.cid)))
+
+  const toSync = ancestor ? await asyncFilter(sorted, async uks => !(await contains(events, ancestor, uks.cid))) : sorted
   // console.timeEnd(callTag + '.contains')
-  // console.log('toSync.contains', toSync.length)
+  console.log('toSync', !!ancestor, sorted.length - toSync.length)
 
   return { cids: events, events: toSync }
 }
 
 const asyncFilter = async (arr, predicate) =>
-  Promise.all(arr.map(predicate)).then((results) => arr.filter((_v, index) => results[index]))
+  Promise.all(arr.map(predicate)).then(results => arr.filter((_v, index) => results[index]))
 
 export async function findCommonAncestorWithSortedEvents (events, children, doFull = false) {
   // console.trace('findCommonAncestorWithSortedEvents')
@@ -252,12 +259,16 @@ export async function findCommonAncestorWithSortedEvents (events, children, doFu
   // console.timeEnd(callTag + '.findCommonAncestor')
   // console.log('ancestor', ancestor.toString())
   if (!ancestor) {
-    throw new Error('failed to find common ancestor event')
+    console.log('no common ancestor', children)
+    // throw new Error('no common ancestor')
+    const sorted = await findSortedEvents(events, children, children, doFull)
+    return { ancestor: null, sorted }
   }
   // console.time(callTag + '.findSortedEvents')
-  const sorted = await findSortedEvents(events, children, ancestor, doFull)
+  const sorted = await findSortedEvents(events, children, [ancestor], doFull)
   // console.timeEnd(callTag + '.findSortedEvents')
   // console.log('sorted', sorted.length)
+  // console.log('ancestor', JSON.stringify(ancestor, null, 2))
   return { ancestor, sorted }
 }
 
@@ -268,17 +279,58 @@ export async function findCommonAncestorWithSortedEvents (events, children, doFu
  * @param {import('./clock').EventFetcher} events
  * @param  {import('./clock').EventLink<EventData>[]} children
  */
+// async function NEWfindCommonAncestor (events, children) {
+//   if (!children.length) return
+//   if (children.length === 1) return children[0]
+
+//   const candidates = children.map(c => [c])
+//   const visited = new Set()
+
+//   while (true) {
+//     let changed = false
+//     for (const c of candidates) {
+//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
+
+//       if (!candidate) continue
+
+//       if (visited.has(candidate)) {
+//         return candidate // Common ancestor found
+//       }
+
+//       visited.add(candidate)
+//       changed = true
+//       c.push(candidate)
+//     }
+
+//     if (!changed) {
+//       // No common ancestor found, exhausted candidates
+//       return null
+//     }
+//   }
+// }
+
 async function findCommonAncestor (events, children) {
   if (!children.length) return
+  children = [...new Set(children)]
   if (children.length === 1) return children[0]
   const candidates = children.map((c) => [c])
+  // console.log(
+  //   'og candidates',
+  //   candidates.map((c) => c.toString())
+  // )
   while (true) {
     let changed = false
     for (const c of candidates) {
       const candidate = await findAncestorCandidate(events, c[c.length - 1])
       if (!candidate) continue
+
+      // Check if the candidate is already in the list, and if so, skip it.
+      if (c.includes(candidate)) continue
+
+      // if set size is all cids, then no common ancestor
       changed = true
-      c.push(candidate)
+      c.push(candidate) // make set?
+      // console.log('candidate', candidates.map((c) => c.toString()))
       const ancestor = findCommonString(candidates)
       if (ancestor) return ancestor
     }
@@ -286,12 +338,45 @@ async function findCommonAncestor (events, children) {
   }
 }
 
+// async function OGfindCommonAncestor (events, children) {
+//   if (!children.length) return
+//   if (children.length === 1) return children[0]
+//   const candidates = children.map(c => [c])
+//   console.log(
+//     'og candidates',
+//     candidates.map(c => c.toString())
+//   )
+//   while (true) {
+//     let changed = false
+//     for (const c of candidates) {
+//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
+//       if (!candidate) continue
+//       // if set size is all cids, then no common ancestor
+//       changed = true
+//       c.push(candidate) // make set?
+//       console.log(
+//         'candidate',
+//         candidates.map(c => c.toString())
+//       )
+//       const ancestor = findCommonString(candidates)
+//       if (ancestor) return ancestor
+//     }
+//     if (!changed) return
+//   }
+// }
+
 /**
  * @param {import('./clock').EventFetcher} events
  * @param {import('./clock').EventLink<EventData>} root
  */
 async function findAncestorCandidate (events, root) {
-  const { value: event } = await events.get(root)// .catch(() => ({ value: { parents: [] } }))
+  const { value: event } = await events.get(root) // .catch(() => ({ value: { parents: [] } }))
+  // console.log(
+  //   'findAncestorCandidate',
+  //   root.toString(),
+  //   'parents',
+  //   event.parents.map(p => p.toString())
+  // )
   if (!event.parents.length) return root
   return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents)
 }
@@ -302,13 +387,13 @@ async function findAncestorCandidate (events, root) {
  */
 function findCommonString (arrays) {
   // console.log('findCommonString', arrays.map((a) => a.map((i) => String(i))))
-  arrays = arrays.map((a) => [...a])
+  arrays = arrays.map(a => [...a])
   for (const arr of arrays) {
     for (const item of arr) {
       let matched = true
       for (const other of arrays) {
         if (arr === other) continue
-        matched = other.some((i) => String(i) === String(item))
+        matched = other.some(i => String(i) === String(item))
         if (!matched) break
       }
       if (matched) return item
@@ -320,19 +405,19 @@ function findCommonString (arrays) {
  * Find and sort events between the head(s) and the tail.
  * @param {import('./clock').EventFetcher} events
  * @param {any[]} head
- * @param {import('./clock').EventLink<EventData>} tail
+ * @param {import('./clock').EventLink<EventData>[]} tails
  */
-async function findSortedEvents (events, head, tail, doFull) {
+async function findSortedEvents (events, head, tails, doFull) {
   // const callTag = Math.random().toString(36).substring(7)
   // get weighted events - heavier events happened first
   // const callTag = Math.random().toString(36).substring(7)
 
   /** @type {Map<string, { event: import('./clock').EventBlockView<EventData>, weight: number }>} */
   const weights = new Map()
-  head = [...new Set([...head.map((h) => h.toString())])]
+  head = [...new Set([...head.map(h => h.toString())])]
   // console.log(callTag + '.head', head.length)
 
-  const allEvents = new Set([tail.toString(), ...head])
+  const allEvents = new Set([tails.map((t) => t.toString()).toString(), ...head])
   if (!doFull && allEvents.size === 1) {
     // console.log('head contains tail', tail.toString())
     return []
@@ -344,7 +429,8 @@ async function findSortedEvents (events, head, tail, doFull) {
   // console.log(callTag + '.head', head.length, [...head.map((h) => h.toString())], tail.toString())
 
   // console.time(callTag + '.findEvents')
-  const all = await Promise.all(head.map((h) => findEvents(events, h, tail)))
+  const all = await (await Promise.all(tails.map((t) => Promise.all(head.map(h => findEvents(events, h, t)))))).flat()
+  // console.log('all', all.length)
   // console.timeEnd(callTag + '.findEvents')
   for (const arr of all) {
     for (const { event, depth } of arr) {
@@ -392,8 +478,8 @@ async function findEvents (events, start, end, depth = 0) {
   const acc = [{ event, depth }]
   const { parents } = event.value
   // if (parents.length === 1 && String(parents[0]) === send) return acc
-  if (parents.findIndex((p) => String(p) === send) !== -1) return acc
+  if (parents.findIndex(p => String(p) === send) !== -1) return acc
   // if (parents.length === 1) return acc
-  const rest = await Promise.all(parents.map((p) => findEvents(events, p, end, depth + 1)))
+  const rest = await Promise.all(parents.map(p => findEvents(events, p, end, depth + 1)))
   return acc.concat(...rest)
 }

package/src/crypto.js

@@ -46,7 +46,7 @@ const decrypt = async function * ({ root, get, key, cache, chunker, hasher }) {
   const { result: nodes } = await cidset.getAllEntries()
   const unwrap = async (eblock) => {
     const { bytes, cid } = await codec.decrypt({ ...eblock, key }).catch(e => {
-      console.log('ekey', e)
+      // console.log('ekey', e)
       throw new Error('bad key: ' + key.toString('hex'))
     })
     const block = await createBlock(bytes, cid)

package/src/database.js

@@ -61,8 +61,8 @@ export class Database {
    * @memberof Fireproof
    * @instance
    */
-  clockToJSON () {
-    return this.clock.map(cid => cid.toString())
+  clockToJSON (clock = null) {
+    return (clock || this.clock).map(cid => cid.toString())
   }
 
   hydrate ({ clock, name, key }) {
@@ -102,21 +102,21 @@ export class Database {
    * @memberof Fireproof
    * @instance
    */
-  async changesSince (event) {
-    // console.log('events for', this.instanceId, event.constructor.name)
-    // console.log('changesSince', this.instanceId, event, this.clock)
+  async changesSince (aClock) {
+    // console.log('events for', this.instanceId, aClock?.constructor.name)
+    // console.log('changesSince', this.instanceId, this.clockToJSON(aClock), this.clockToJSON())
     let rows, dataCIDs, clockCIDs
-    // if (!event) event = []
-    if (event) {
-      event = event.map((cid) => cid.toString())
-      const eventKey = JSON.stringify([...event, ...this.clockToJSON()])
+    // if (!aClock) aClock = []
+    if (aClock && aClock.length > 0) {
+      aClock = aClock.map((cid) => cid.toString())
+      const eventKey = JSON.stringify([...this.clockToJSON(aClock), ...this.clockToJSON()])
 
       let resp
       if (this.eventsCache.has(eventKey)) {
-        console.log('events from cache')
+        // console.log('events from cache')
         resp = this.eventsCache.get(eventKey)
       } else {
-        resp = await eventsSince(this.blocks, this.clock, event)
+        resp = await eventsSince(this.blocks, this.clock, aClock)
         this.eventsCache.set(eventKey, resp)
       }
       const docsMap = new Map()
@@ -277,7 +277,9 @@ export class Database {
    */
   async putToProllyTree (decodedEvent, clock = null) {
     const event = encodeEvent(decodedEvent)
-    if (clock && JSON.stringify(clock) !== JSON.stringify(this.clockToJSON())) {
+    if (clock && JSON.stringify(this.clockToJSON(clock)) !== JSON.stringify(this.clockToJSON())) {
+      // console.log('this.clock', this.clockToJSON())
+      // console.log('that.clock', this.clockToJSON(clock))
       // we need to check and see what version of the document exists at the clock specified
       // if it is the same as the one we are trying to put, then we can proceed
       const resp = await eventsSince(this.blocks, this.clock, event.value._clock)
@@ -287,6 +289,7 @@ export class Database {
       }
     }
     const prevClock = [...this.clock]
+    // console.log('putToProllyTree', this.clockToJSON(), decodedEvent)
     const result = await doTransaction(
       'putToProllyTree',
       this.blocks,

package/src/db-index.js

@@ -351,7 +351,7 @@ export class DbIndex {
       )
       this.indexByKey = await bulkIndex(blocks, this.indexByKey, oldIndexEntries.concat(indexEntries), dbIndexOpts)
       this.dbHead = result.clock
-    })
+    }, false /* don't sync transaction -- maybe move this flag to database.indexBlocks? */)
     // todo index subscriptions
     // this.database.notifyExternal('dbIndex')
     // console.timeEnd(callTag + '.doTransactionupdateIndex')

package/src/prolly.js

@@ -19,6 +19,8 @@ import { doTransaction } from './blockstore.js'
 import { create as createBlock } from 'multiformats/block'
 const blockOpts = { cache, chunker: bf(30), codec, hasher, compare }
 
+// const SYNC_ROOT = 'fireproof' // change this if you want to break sync
+
 /**
  * @typedef {import('./blockstore.js').TransactionBlockstore} TransactionBlockstore
  */
@@ -52,13 +54,11 @@ export const makeGetBlock = blocks => {
 async function createAndSaveNewEvent ({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
   let cids
   const { key, value, del } = inEvent
+  // console.log('createAndSaveNewEvent', root.constructor.name, root.entryList)
+  // root = await root.block
   const data = {
     root: root
-      ? {
-          cid: root.cid,
-          bytes: root.bytes, // can we remove this?
-          value: root.value // can we remove this?
-        }
+      ? (await root.address)
       : null,
     key
   }
@@ -70,6 +70,29 @@ async function createAndSaveNewEvent ({ inBlocks, bigPut, root, event: inEvent,
     data.value = value
     data.type = 'put'
   }
+  // console.log('head', head)
+  // if (head.length === 0) {
+  //   // create an empty prolly root
+  //   let emptyRoot
+
+  //   for await (const node of create({ get: getBlock, list: [{ key: '_sync', value: SYNC_ROOT }], ...blockOpts })) {
+  //     emptyRoot = await node.block
+  //     bigPut(emptyRoot)
+  //   }
+  //   console.log('emptyRoot', emptyRoot)
+  //   const first = await EventBlock.create(
+  //     {
+  //       root: emptyRoot.cid,
+  //       key: null,
+  //       value: null,
+  //       type: 'del'
+  //     },
+  //     []
+  //   )
+  //   bigPut(first)
+  //   head = [first.cid]
+  // }
+
   /** @type {import('./clock').EventData} */
   // @ts-ignore
   const event = await EventBlock.create(data, head)
@@ -138,16 +161,23 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
   // console.log('prollyRootFromAncestor', ancestor)
   const event = await events.get(ancestor)
   const { root } = event.value.data
-  // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
   if (root) {
-    return load({ cid: root.cid, get: getBlock, ...blockOpts })
+    return load({ cid: root, get: getBlock, ...blockOpts })
   } else {
-    return null
+    // console.log('no root', root) // false means no common ancestor. null means empty database.
+    return root
   }
 }
 
+// async function bigMerge (events, head, getBlock) {
+//   const allRoots = await Promise.all(head.map(async h => prollyRootFromAncestor(events, h, getBlock)))
+//   console.log('allRoots', allRoots)
+//   // todo query over all roots and merge them, but how do they not have a common ancestor? they all start with the _sync root
+//   throw new Error('not implemented')
+// }
+
 const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
-  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks)
+  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks) // this is doubled with eventfetcher
   let bulkSorted = []
   let prollyRootNode = null
   const events = new EventFetcher(blocks)
@@ -155,14 +185,22 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
     if (!doFull && head.length === 1) {
       prollyRootNode = await prollyRootFromAncestor(events, head[0], getBlock)
     } else {
-    // Otherwise, we find the common ancestor and update the root and other blocks
-    // todo this is returning more events than necessary, lets define the desired semantics from the top down
-    // good semantics mean we can cache the results of this call
+      // Otherwise, we find the common ancestor and update the root and other blocks
+      // todo this is returning more events than necessary, lets define the desired semantics from the top down
+      // good semantics mean we can cache the results of this call
+      // const {cids, events : bulkSorted } = await findEventsToSync(blocks, head)
       const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head, doFull)
+
       bulkSorted = sorted
-      // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
-      prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
-    // console.log('event', event)
+      // console.log('sorted', !!ancestor, JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+      if (ancestor) {
+        prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
+        // if (!prollyRootNode) {
+        //   prollyRootNode = await bigMerge(events, head, getBlock)
+        //   // throw new Error('no common ancestor')
+        // }
+      }
+      // console.log('event', event)
     }
   }
 
@@ -170,16 +208,23 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
 
   // if prolly root node is null, we need to create a new one
   if (!prollyRootNode) {
+    // console.log('make new root', bulkOperations.length)
     let root
+    // let rootNode
     const newBlocks = []
     // if all operations are deletes, we can just return an empty root
     if (bulkOperations.every(op => op.del)) {
       return { root: null, blocks: [], clockCIDs: await events.all() }
     }
     for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
-      root = await node.block
-      newBlocks.push(root)
+      // root = await node.block
+      root = node
+      newBlocks.push(await node.block)
     }
+    // throw new Error('not root time')
+    // root.isThisOne = 'yes'
+    // console.log('made new root', root.constructor.name, root.block.cid.toString())
+
     return { root, blocks: newBlocks, clockCIDs: await events.all() }
   } else {
     const writeResp = await prollyRootNode.bulk(bulkOperations) // { root: newProllyRootNode, blocks: newBlocks }
@@ -199,7 +244,7 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
  */
 export async function put (inBlocks, head, event, options) {
   const { bigPut } = makeGetAndPutBlock(inBlocks)
-
+  // console.log('major put')
   // If the head is empty, we create a new event and return the root and addition blocks
   if (!head.length) {
     const additions = new Map()
@@ -231,7 +276,7 @@ export async function put (inBlocks, head, event, options) {
     return createAndSaveNewEvent({
       inBlocks,
       bigPut,
-      root: prollyRootBlock,
+      root: newProllyRootNode, // Block
       event,
       head,
       additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
@@ -250,20 +295,25 @@ export async function root (inBlocks, head, doFull = false) {
     throw new Error('no head')
   }
   // console.log('root', head.map(h => h.toString()))
-  const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head, null, doFull)
   // todo maybe these should go to a temp blockstore?
-  await doTransaction(
+  return await doTransaction(
     'root',
     inBlocks,
     async transactionBlocks => {
       const { bigPut } = makeGetAndPutBlock(transactionBlocks)
+      const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head, null, doFull)
+      //
+      // const rootBlock = await newProllyRootNode.block
+      // bigPut(rootBlock)
       for (const nb of newBlocks) {
         bigPut(nb)
       }
+      // console.log('root root', newProllyRootNode.constructor.name, newProllyRootNode)
+      return { clockCIDs, node: newProllyRootNode }
     },
     false
   )
-  return { clockCIDs, node: newProllyRootNode }
+  // return { clockCIDs, node: newProllyRootNode }
 }
 
 /**
@@ -279,7 +329,8 @@ export async function eventsSince (blocks, head, since) {
     return { clockCIDs: [], result: [] }
   }
   // @ts-ignore
-  const sinceHead = [...since, ...head] // ?
+  const sinceHead = [...since, ...head].map(h => h.toString()) // ?
+  // console.log('eventsSince', sinceHead.map(h => h.toString()))
   const { cids, events: unknownSorted3 } = await findEventsToSync(blocks, sinceHead)
   return { clockCIDs: cids, result: unknownSorted3.map(({ value: { data } }) => data) }
 }
@@ -318,9 +369,16 @@ async function rootOrCache (blocks, head, rootCache, doFull = false) {
     // console.log('finding root')
     // const callTag = Math.random().toString(36).substring(7)
     // console.time(callTag + '.root')
+    //
+    // const prevClock = [...this.clock]
+
     ;({ node, clockCIDs } = await root(blocks, head, doFull))
+
+    // this.applyClock(prevClock, result.head)
+    // await this.notifyListeners([decodedEvent])
+
     // console.timeEnd(callTag + '.root')
-    // console.log('found root')
+    // console.log('found root', node.entryList)
   }
   return { node, clockCIDs }
 }

package/src/sync.js

@@ -23,10 +23,15 @@ export class Sync {
       this.pushBacklogResolve = resolve
       this.pushBacklogReject = reject
     })
+    this.isReady = false
     // this.pushBacklog.then(() => {
     //   // console.log('sync backlog resolved')
     //   this.database.notifyReset()
     // })
+    // this.connected = new Promise((resolve, reject) => {
+    //   this.readyResolve = resolve
+    //   this.readyReject = reject
+    // })
   }
 
   async offer () {
@@ -75,22 +80,22 @@ export class Sync {
       // console.log('not a car', data.toString())
     }
     if (reader) {
-      console.log('got car')
+      // console.log('got car')
       this.status = 'parking car'
       const blz = new Set()
       for await (const block of reader.blocks()) {
         blz.add(block)
       }
       const roots = await reader.getRoots()
-      console.log(
-        'got car',
-        roots.map(c => c.toString()),
-        this.database.clock.map(c => c.toString())
-      )
-      console.log(
-        'got blocks',
-        [...blz].map(({ cid }) => cid.toString())
-      )
+      // console.log(
+      //   'got car',
+      //   roots.map(c => c.toString()),
+      //   this.database.clock.map(c => c.toString())
+      // )
+      // console.log(
+      //   'got blocks!',
+      //   [...blz].map(({ cid }) => cid.toString())
+      // )
       // @ts-ignore
       reader.entries = reader.blocks
       await this.database.blocks.commit(
@@ -129,7 +134,7 @@ export class Sync {
       } else if (message.clock) {
         const reqCidDiff = message
         // this might be a CID diff
-        console.log('got diff', reqCidDiff)
+        // console.log('got diff', reqCidDiff)
         const carBlock = await Sync.makeCar(this.database, null, reqCidDiff.cids)
         if (!carBlock) {
           // we are full synced
@@ -138,9 +143,10 @@ export class Sync {
           this.peer.send(JSON.stringify({ ok: true }))
           // this.pushBacklogResolve({ ok: true })
         } else {
-          console.log('do send', carBlock.bytes.length)
+          // console.log('do send diff', carBlock.bytes.length)
           this.status = 'sending diff car'
           this.peer.send(carBlock.bytes)
+          // console.log('sent diff car')
           // this.pushBacklogResolve({ ok: true })
         }
       }
@@ -154,7 +160,7 @@ export class Sync {
   }
 
   async sendUpdate (blockstore) {
-    if (!this.peer) return
+    if (!this.peer || !this.isReady) return
     // console.log('send update from', this.database.instanceId)
     // todo should send updates since last sync
     const newCar = await blocksToCarBlock(blockstore.lastCid, blockstore)
@@ -164,6 +170,7 @@ export class Sync {
 
   async startSync () {
     // console.log('start sync', this.peer.initiator)
+    this.isReady = true
     const allCIDs = await this.database.allStoredCIDs()
     // console.log('allCIDs', allCIDs)
     const reqCidDiff = {