@fireproof/core 0.0.5 → 0.0.7

package/test/clock.test.js

@@ -1,19 +1,18 @@
 /* global describe, it */
 // import { describe, it } from 'mocha'
 import assert from 'node:assert'
-import {
-  advance,
-  EventBlock,
-  findCommonAncestorWithSortedEvents,
-  findUnknownSortedEvents,
-  decodeEventBlock,
-  findEventsToSync
-} from '../src/clock.js'
+import { advance, EventBlock, decodeEventBlock, findEventsToSync as findEventsWithProofToSync } from '../src/clock.js'
 // import { vis } from '../src/clock.js'
 import { Blockstore, seqEventData, setSeq } from './helpers.js'
 
+const testAdvance = async (blocks, oldHead, event) => {
+  const { head } = await advance(blocks, oldHead, event)
+  return head
+}
+
+const testFindEventsToSync = async (blocks, head) => (await findEventsWithProofToSync(blocks, head)).events
+
 async function visHead (blocks, head) {
-  // const values =
   head.map(async (cid) => {
     const block = await blocks.get(cid)
     return (await decodeEventBlock(block.bytes)).value?.data?.value
@@ -24,7 +23,7 @@ async function visHead (blocks, head) {
 async function makeNext (blocks, parent, eventData) {
   const event = await EventBlock.create(eventData, parent)
   await blocks.put(event.cid, event.bytes)
-  const head = await advance(blocks, parent, event.cid)
+  const head = await testAdvance(blocks, parent, event.cid)
   return { event, head }
 }
 
@@ -35,18 +34,14 @@ describe('Clock', () => {
     const event = await EventBlock.create({})
 
     await blocks.put(event.cid, event.bytes)
-    const head = await advance(blocks, [], event.cid)
+    const head = await testAdvance(blocks, [], event.cid)
 
     // for await (const line of vis(blocks, head)) console.log(line)
     assert.equal(head.length, 1)
     assert.equal(head[0].toString(), event.cid.toString())
 
     const sinceHead = head
-    const toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    const toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 0)
   })
 
@@ -70,7 +65,7 @@ describe('Clock', () => {
     assert.equal(head1.length, 1)
     assert.equal(head1[0].toString(), event1.cid.toString())
 
-    const toSync1 = await findEventsToSync(blocks, head1)
+    const toSync1 = await testFindEventsToSync(blocks, head1)
 
     assert.equal(toSync1.length, 0)
 
@@ -82,10 +77,10 @@ describe('Clock', () => {
     assert.equal(head2.length, 1)
     assert.equal(head2[0].toString(), event2.cid.toString())
 
-    const toSync2 = await findEventsToSync(blocks, head2)
+    const toSync2 = await testFindEventsToSync(blocks, head2)
     assert.equal(toSync2.length, 0)
 
-    const toSync1b = await findEventsToSync(blocks, [...head2, ...head0])
+    const toSync1b = await testFindEventsToSync(blocks, [...head2, ...head0])
 
     assert.equal(toSync1b.length, 2)
     assert.equal(toSync1b[0].value.data.value, 'event1bob')
@@ -100,13 +95,13 @@ describe('Clock', () => {
     assert.equal(head3.length, 1)
     assert.equal(head3[0].toString(), event3.cid.toString())
 
-    const toSync3 = await findEventsToSync(blocks, [...head3, ...head0])
+    const toSync3 = await testFindEventsToSync(blocks, [...head3, ...head0])
     assert.equal(toSync3.length, 3)
     assert.equal(toSync3[0].value.data.value, 'event1bob')
     assert.equal(toSync3[1].value.data.value, 'event2carol')
     assert.equal(toSync3[2].value.data.value, 'event3dave')
 
-    const toSync3B = await findEventsToSync(blocks, [...head3, ...head1])
+    const toSync3B = await testFindEventsToSync(blocks, [...head3, ...head1])
     assert.equal(toSync3B.length, 2)
     assert.equal(toSync3B[0].value.data.value, 'event2carol')
     assert.equal(toSync3B[1].value.data.value, 'event3dave')
@@ -119,28 +114,28 @@ describe('Clock', () => {
     assert.equal(head4.length, 1)
     assert.equal(head4[0].toString(), event4.cid.toString())
 
-    const toSync4 = await findEventsToSync(blocks, [...head4, ...head0])
+    const toSync4 = await testFindEventsToSync(blocks, [...head4, ...head0])
     assert.equal(toSync4.length, 4)
     assert.equal(toSync4[0].value.data.value, 'event1bob')
     assert.equal(toSync4[1].value.data.value, 'event2carol')
     assert.equal(toSync4[2].value.data.value, 'event3dave')
     assert.equal(toSync4[3].value.data.value, 'event4eve')
 
-    const toSync4B = await findEventsToSync(blocks, [...head4, ...head1])
+    const toSync4B = await testFindEventsToSync(blocks, [...head4, ...head1])
 
     assert.equal(toSync4B.length, 3)
     assert.equal(toSync4B[0].value.data.value, 'event2carol')
     assert.equal(toSync4B[1].value.data.value, 'event3dave')
     assert.equal(toSync4B[2].value.data.value, 'event4eve')
 
-    const toSync4C = await findEventsToSync(blocks, [...head4, ...head2])
+    const toSync4C = await testFindEventsToSync(blocks, [...head4, ...head2])
 
     assert.equal(toSync4C.length, 2)
     assert.equal(toSync4C[0].value.data.value, 'event3dave')
     assert.equal(toSync4C[1].value.data.value, 'event4eve')
 
     // don't ask if you already know
-    // const toSync4D = await findEventsToSync(blocks, [...head4, ...head3])
+    // const toSync4D = await testFindEventsToSync(blocks, [...head4, ...head3])
     // assert.equal(toSync4D.length, 0)
 
     /*
@@ -150,7 +145,7 @@ describe('Clock', () => {
 
     assert.equal(head5.length, 1)
     assert.equal(head5[0].toString(), event5.cid.toString())
-    const toSync5 = await findEventsToSync(blocks, [...head5, ...head0])
+    const toSync5 = await testFindEventsToSync(blocks, [...head5, ...head0])
     assert.equal(toSync5.length, 5)
     assert.equal(toSync5[0].value.data.value, 'event1bob')
     assert.equal(toSync5[1].value.data.value, 'event2carol')
@@ -158,7 +153,7 @@ describe('Clock', () => {
     assert.equal(toSync5[3].value.data.value, 'event4eve')
     assert.equal(toSync5[4].value.data.value, 'event5frank')
 
-    const toSync5B = await findEventsToSync(blocks, [...head5, ...head1])
+    const toSync5B = await testFindEventsToSync(blocks, [...head5, ...head1])
 
     assert.equal(toSync5B.length, 4)
     assert.equal(toSync5B[0].value.data.value, 'event2carol')
@@ -166,18 +161,18 @@ describe('Clock', () => {
     assert.equal(toSync5B[2].value.data.value, 'event4eve')
     assert.equal(toSync5B[3].value.data.value, 'event5frank')
 
-    const toSync5C = await findEventsToSync(blocks, [...head5, ...head2])
+    const toSync5C = await testFindEventsToSync(blocks, [...head5, ...head2])
     assert(toSync5C.length > 0, 'should have 3 events, has ' + toSync5C.length)
     assert.equal(toSync5C[0].value.data.value, 'event3dave')
     assert.equal(toSync5C[1].value.data.value, 'event4eve')
     assert.equal(toSync5C[2].value.data.value, 'event5frank')
 
-    const toSync5D = await findEventsToSync(blocks, [...head5, ...head3])
+    const toSync5D = await testFindEventsToSync(blocks, [...head5, ...head3])
     assert.equal(toSync5D.length, 2) // 4
     assert.equal(toSync5D[0].value.data.value, 'event4eve')
     assert.equal(toSync5D[1].value.data.value, 'event5frank')
 
-    const toSync5E = await findEventsToSync(blocks, [...head5, ...head4])
+    const toSync5E = await testFindEventsToSync(blocks, [...head5, ...head4])
     assert.equal(toSync5E.length, 1) // 5
     assert.equal(toSync5E[0].value.data.value, 'event5frank')
 
@@ -189,7 +184,7 @@ describe('Clock', () => {
     assert.equal(head6.length, 1)
     assert.equal(head6[0].toString(), event6.cid.toString())
 
-    const toSync6 = await findEventsToSync(blocks, [...head6, ...head0])
+    const toSync6 = await testFindEventsToSync(blocks, [...head6, ...head0])
     assert.equal(toSync6.length, 6) // 1
     assert.equal(toSync6[0].value.data.value, 'event1bob')
     assert.equal(toSync6[1].value.data.value, 'event2carol')
@@ -198,7 +193,7 @@ describe('Clock', () => {
     assert.equal(toSync6[4].value.data.value, 'event5frank')
     assert.equal(toSync6[5].value.data.value, 'event6grace')
 
-    const toSync6B = await findEventsToSync(blocks, [...head6, ...head1])
+    const toSync6B = await testFindEventsToSync(blocks, [...head6, ...head1])
     assert.equal(toSync6B.length, 5) // 2
     assert.equal(toSync6B[0].value.data.value, 'event2carol')
     assert.equal(toSync6B[1].value.data.value, 'event3dave')
@@ -206,25 +201,25 @@ describe('Clock', () => {
     assert.equal(toSync6B[3].value.data.value, 'event5frank')
     assert.equal(toSync6B[4].value.data.value, 'event6grace')
 
-    const toSync6C = await findEventsToSync(blocks, [...head6, ...head2])
+    const toSync6C = await testFindEventsToSync(blocks, [...head6, ...head2])
     assert.equal(toSync6C.length, 4) // 3
     assert.equal(toSync6C[0].value.data.value, 'event3dave')
     assert.equal(toSync6C[1].value.data.value, 'event4eve')
     assert.equal(toSync6C[2].value.data.value, 'event5frank')
     assert.equal(toSync6C[3].value.data.value, 'event6grace')
 
-    const toSync6D = await findEventsToSync(blocks, [...head6, ...head3])
+    const toSync6D = await testFindEventsToSync(blocks, [...head6, ...head3])
     assert.equal(toSync6D.length, 3) // 4
     assert.equal(toSync6D[0].value.data.value, 'event4eve')
     assert.equal(toSync6D[1].value.data.value, 'event5frank')
     assert.equal(toSync6D[2].value.data.value, 'event6grace')
 
-    const toSync6E = await findEventsToSync(blocks, [...head6, ...head4])
+    const toSync6E = await testFindEventsToSync(blocks, [...head6, ...head4])
     assert.equal(toSync6E.length, 2) // 5
     assert.equal(toSync6E[0].value.data.value, 'event5frank')
     assert.equal(toSync6E[1].value.data.value, 'event6grace')
 
-    const toSync6F = await findEventsToSync(blocks, [...head6, ...head5])
+    const toSync6F = await testFindEventsToSync(blocks, [...head6, ...head5])
     assert.equal(toSync6F.length, 1)
     assert.equal(toSync6F[0].value.data.value, 'event6grace')
 
@@ -236,7 +231,7 @@ describe('Clock', () => {
     assert.equal(head7.length, 1)
     assert.equal(head7[0].toString(), event7.cid.toString())
 
-    const toSync7 = await findEventsToSync(blocks, [...head7, ...head0])
+    const toSync7 = await testFindEventsToSync(blocks, [...head7, ...head0])
     assert.equal(toSync7.length, 7)
     assert.equal(toSync7[0].value.data.value, 'event1bob')
     assert.equal(toSync7[1].value.data.value, 'event2carol')
@@ -246,7 +241,7 @@ describe('Clock', () => {
     assert.equal(toSync7[5].value.data.value, 'event6grace')
     assert.equal(toSync7[6].value.data.value, 'event7holly')
 
-    const toSync7B = await findEventsToSync(blocks, [...head7, ...head1])
+    const toSync7B = await testFindEventsToSync(blocks, [...head7, ...head1])
     assert.equal(toSync7B.length, 6)
     assert.equal(toSync7B[0].value.data.value, 'event2carol')
     assert.equal(toSync7B[1].value.data.value, 'event3dave')
@@ -254,7 +249,7 @@ describe('Clock', () => {
     assert.equal(toSync7B[3].value.data.value, 'event5frank')
     assert.equal(toSync7B[4].value.data.value, 'event6grace')
 
-    const toSync7C = await findEventsToSync(blocks, [...head7, ...head2])
+    const toSync7C = await testFindEventsToSync(blocks, [...head7, ...head2])
     assert.equal(toSync7C.length, 5)
     assert.equal(toSync7C[0].value.data.value, 'event3dave')
     assert.equal(toSync7C[1].value.data.value, 'event4eve')
@@ -262,20 +257,20 @@ describe('Clock', () => {
     assert.equal(toSync7C[3].value.data.value, 'event6grace')
     assert.equal(toSync7C[4].value.data.value, 'event7holly')
 
-    const toSync7D = await findEventsToSync(blocks, [...head7, ...head3])
+    const toSync7D = await testFindEventsToSync(blocks, [...head7, ...head3])
     assert.equal(toSync7D.length, 4)
     assert.equal(toSync7D[0].value.data.value, 'event4eve')
     assert.equal(toSync7D[1].value.data.value, 'event5frank')
     assert.equal(toSync7D[2].value.data.value, 'event6grace')
     assert.equal(toSync7D[3].value.data.value, 'event7holly')
 
-    const toSync7E = await findEventsToSync(blocks, [...head7, ...head4])
+    const toSync7E = await testFindEventsToSync(blocks, [...head7, ...head4])
     assert.equal(toSync7E.length, 3)
     assert.equal(toSync7E[0].value.data.value, 'event5frank')
     assert.equal(toSync7E[1].value.data.value, 'event6grace')
     assert.equal(toSync7E[2].value.data.value, 'event7holly')
 
-    const toSync7F = await findEventsToSync(blocks, [...head7, ...head5])
+    const toSync7F = await testFindEventsToSync(blocks, [...head7, ...head5])
     assert.equal(toSync7F.length, 2)
     assert.equal(toSync7F[0].value.data.value, 'event6grace')
     assert.equal(toSync7F[1].value.data.value, 'event7holly')
@@ -288,7 +283,7 @@ describe('Clock', () => {
     assert.equal(head8.length, 1)
     assert.equal(head8[0].toString(), event8.cid.toString())
 
-    const toSync8 = await findEventsToSync(blocks, [...head8, ...head0])
+    const toSync8 = await testFindEventsToSync(blocks, [...head8, ...head0])
     assert.equal(toSync8.length, 8)
     assert.equal(toSync8[0].value.data.value, 'event1bob')
     assert.equal(toSync8[1].value.data.value, 'event2carol')
@@ -299,7 +294,7 @@ describe('Clock', () => {
     assert.equal(toSync8[6].value.data.value, 'event7holly')
     assert.equal(toSync8[7].value.data.value, 'event8isaac')
 
-    const toSync8B = await findEventsToSync(blocks, [...head8, ...head1])
+    const toSync8B = await testFindEventsToSync(blocks, [...head8, ...head1])
     assert.equal(toSync8B.length, 7)
     assert.equal(toSync8B[0].value.data.value, 'event2carol')
     assert.equal(toSync8B[1].value.data.value, 'event3dave')
@@ -309,7 +304,7 @@ describe('Clock', () => {
     assert.equal(toSync8B[5].value.data.value, 'event7holly')
     assert.equal(toSync8B[6].value.data.value, 'event8isaac')
 
-    const toSync8C = await findEventsToSync(blocks, [...head8, ...head2])
+    const toSync8C = await testFindEventsToSync(blocks, [...head8, ...head2])
     assert.equal(toSync8C.length, 6) // 3
     assert.equal(toSync8C[0].value.data.value, 'event3dave')
     assert.equal(toSync8C[1].value.data.value, 'event4eve')
@@ -318,7 +313,7 @@ describe('Clock', () => {
     assert.equal(toSync8C[4].value.data.value, 'event7holly')
     assert.equal(toSync8C[5].value.data.value, 'event8isaac')
 
-    const toSync8D = await findEventsToSync(blocks, [...head8, ...head3])
+    const toSync8D = await testFindEventsToSync(blocks, [...head8, ...head3])
     assert.equal(toSync8D.length, 5) // 4
     assert.equal(toSync8D[0].value.data.value, 'event4eve')
     assert.equal(toSync8D[1].value.data.value, 'event5frank')
@@ -326,14 +321,14 @@ describe('Clock', () => {
     assert.equal(toSync8D[3].value.data.value, 'event7holly')
     assert.equal(toSync8D[4].value.data.value, 'event8isaac')
 
-    const toSync8E = await findEventsToSync(blocks, [...head8, ...head4])
+    const toSync8E = await testFindEventsToSync(blocks, [...head8, ...head4])
     assert.equal(toSync8E.length, 4) // 5
     assert.equal(toSync8E[0].value.data.value, 'event5frank')
     assert.equal(toSync8E[1].value.data.value, 'event6grace')
     assert.equal(toSync8E[2].value.data.value, 'event7holly')
     assert.equal(toSync8E[3].value.data.value, 'event8isaac')
 
-    const toSync8F = await findEventsToSync(blocks, [...head8, ...head5])
+    const toSync8F = await testFindEventsToSync(blocks, [...head8, ...head5])
     assert.equal(toSync8F.length, 3) // 6
     assert.equal(toSync8F[0].value.data.value, 'event6grace')
     assert.equal(toSync8F[1].value.data.value, 'event7holly')
@@ -347,7 +342,7 @@ describe('Clock', () => {
     assert.equal(head9.length, 1)
     assert.equal(head9[0].toString(), event9.cid.toString())
 
-    const toSync9 = await findEventsToSync(blocks, [...head9, ...head0])
+    const toSync9 = await testFindEventsToSync(blocks, [...head9, ...head0])
     assert.equal(toSync9.length, 9)
     assert.equal(toSync9[0].value.data.value, 'event1bob')
     assert.equal(toSync9[1].value.data.value, 'event2carol')
@@ -359,7 +354,7 @@ describe('Clock', () => {
     assert.equal(toSync9[7].value.data.value, 'event8isaac')
     assert.equal(toSync9[8].value.data.value, 'event9jen')
 
-    const toSync9B = await findEventsToSync(blocks, [...head9, ...head1])
+    const toSync9B = await testFindEventsToSync(blocks, [...head9, ...head1])
     assert.equal(toSync9B.length, 8)
     assert.equal(toSync9B[0].value.data.value, 'event2carol')
     assert.equal(toSync9B[1].value.data.value, 'event3dave')
@@ -370,7 +365,7 @@ describe('Clock', () => {
     assert.equal(toSync9B[6].value.data.value, 'event8isaac')
     assert.equal(toSync9B[7].value.data.value, 'event9jen')
 
-    const toSync9C = await findEventsToSync(blocks, [...head9, ...head2])
+    const toSync9C = await testFindEventsToSync(blocks, [...head9, ...head2])
     assert.equal(toSync9C.length, 7)
     assert.equal(toSync9C[0].value.data.value, 'event3dave')
     assert.equal(toSync9C[1].value.data.value, 'event4eve')
@@ -380,7 +375,7 @@ describe('Clock', () => {
     assert.equal(toSync9C[5].value.data.value, 'event8isaac')
     assert.equal(toSync9C[6].value.data.value, 'event9jen')
 
-    const toSync9D = await findEventsToSync(blocks, [...head9, ...head3])
+    const toSync9D = await testFindEventsToSync(blocks, [...head9, ...head3])
     assert.equal(toSync9D.length, 6)
     assert.equal(toSync9D[0].value.data.value, 'event4eve')
     assert.equal(toSync9D[1].value.data.value, 'event5frank')
@@ -389,7 +384,7 @@ describe('Clock', () => {
     assert.equal(toSync9D[4].value.data.value, 'event8isaac')
     assert.equal(toSync9D[5].value.data.value, 'event9jen')
 
-    const toSync9E = await findEventsToSync(blocks, [...head9, ...head4])
+    const toSync9E = await testFindEventsToSync(blocks, [...head9, ...head4])
     assert.equal(toSync9E.length, 5)
     assert.equal(toSync9E[0].value.data.value, 'event5frank')
     assert.equal(toSync9E[1].value.data.value, 'event6grace')
@@ -407,7 +402,7 @@ describe('Clock', () => {
     await blocks.put(root.cid, root.bytes)
 
     /** @type {import('../src/clock').EventLink<any>[]} */
-    let head = await advance(blocks, [], root.cid)
+    let head = await testAdvance(blocks, [], root.cid)
     assert.equal(head.length, 1)
     assert.equal(head[0], root.cid)
 
@@ -416,12 +411,12 @@ describe('Clock', () => {
     const event0 = await EventBlock.create(seqEventData(), parents)
     await blocks.put(event0.cid, event0.bytes)
 
-    head = await advance(blocks, parents, event0.cid)
+    head = await testAdvance(blocks, parents, event0.cid)
     const head0 = head
 
     const event1 = await EventBlock.create(seqEventData(), parents)
     await blocks.put(event1.cid, event1.bytes)
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
     const head1 = head
 
     // for await (const line of vis(blocks, head)) console.log(line)
@@ -430,40 +425,23 @@ describe('Clock', () => {
     assert.equal(head[1].toString(), event1.cid.toString())
 
     let sinceHead = head1
-    let toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    let toSync = await testFindEventsToSync(blocks, sinceHead)
     // assert.equal(toSync.length, 1) // 0
     // assert.equal(toSync[0].cid.toString(), event0.cid.toString())
 
     const event2 = await EventBlock.create(seqEventData(), head1)
     await blocks.put(event2.cid, event2.bytes)
-    head = await advance(blocks, head, event2.cid)
+    head = await testAdvance(blocks, head, event2.cid)
     const head2 = head
 
     assert.equal(head.length, 1)
 
     sinceHead = head2
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 0)
 
-    // todo do these since heads make sense?
     sinceHead = [...head0, ...head2]
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
-    // console.log('need', toSync.map(b => b.value.data))
-    // assert.equal(toSync.length, 2) // 0
-    // assert.equal(toSync[0].cid.toString(), event1.cid.toString())
-    // assert.equal(toSync[1].cid.toString(), event2.cid.toString())
+    toSync = await testFindEventsToSync(blocks, sinceHead)
   })
 
   it('add two events with some shared parents', async () => {
@@ -477,36 +455,30 @@ describe('Clock', () => {
 
     const event0 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event0.cid, event0.bytes)
-    head = await advance(blocks, head, event0.cid)
+    head = await testAdvance(blocks, head, event0.cid)
 
     const event1 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event1.cid, event1.bytes)
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
 
     const event2 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event2.cid, event2.bytes)
-    head = await advance(blocks, head, event2.cid)
+    head = await testAdvance(blocks, head, event2.cid)
 
     const event3 = await EventBlock.create(seqEventData(), [event0.cid, event1.cid])
     await blocks.put(event3.cid, event3.bytes)
-    head = await advance(blocks, head, event3.cid)
+    head = await testAdvance(blocks, head, event3.cid)
     // const parentz = head
 
     const event4 = await EventBlock.create(seqEventData(), [event2.cid])
     await blocks.put(event4.cid, event4.bytes)
-    head = await advance(blocks, head, event4.cid)
+    head = await testAdvance(blocks, head, event4.cid)
 
     // console.log('add two events with some shared parents')
     // for await (const line of vis(blocks, head)) console.log(line)
     assert.equal(head.length, 2)
     assert.equal(head[0].toString(), event3.cid.toString())
     assert.equal(head[1].toString(), event4.cid.toString())
-    // console.log('since', parentz)
-    // for await (const block of since(blocks, parentz)) {
-    //   if (block?.value) console.log(block.value.data)
-    // }
-    // const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(blocks, parentz)
-    // console.log('findCommonAncestorWithSortedEvents', ancestor, sorted.map(b => b.value.data))
   })
 
   it('converge when multi-root', async () => {
@@ -521,63 +493,63 @@ describe('Clock', () => {
 
     const event0 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event0.cid, event0.bytes)
-    head = await advance(blocks, head, event0.cid)
+    head = await testAdvance(blocks, head, event0.cid)
 
     const event1 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event1.cid, event1.bytes)
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
 
     const event1head = head
 
     const event2 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event2.cid, event2.bytes)
-    head = await advance(blocks, head, event2.cid)
+    head = await testAdvance(blocks, head, event2.cid)
 
     const event3 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event3.cid, event3.bytes)
-    head = await advance(blocks, head, event3.cid)
+    head = await testAdvance(blocks, head, event3.cid)
 
     const event3head = head
 
     const event4 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event4.cid, event4.bytes)
-    head = await advance(blocks, head, event4.cid)
+    head = await testAdvance(blocks, head, event4.cid)
     const event4head = head
     await visHead(blocks, event4head)
 
     const event5 = await EventBlock.create(seqEventData(), event3head)
     await blocks.put(event5.cid, event5.bytes)
-    head = await advance(blocks, head, event5.cid)
+    head = await testAdvance(blocks, head, event5.cid)
     const event5head = head
     await visHead(blocks, event5head)
 
     const event6 = await EventBlock.create(seqEventData(), event5head)
     await blocks.put(event6.cid, event6.bytes)
-    head = await advance(blocks, head, event6.cid)
+    head = await testAdvance(blocks, head, event6.cid)
     const event6head = head
     await visHead(blocks, event6head)
 
     const event7 = await EventBlock.create(seqEventData(), event6head)
     await blocks.put(event7.cid, event7.bytes)
-    head = await advance(blocks, head, event7.cid)
+    head = await testAdvance(blocks, head, event7.cid)
     const event7head = head
     await visHead(blocks, event7head)
 
     const event8 = await EventBlock.create(seqEventData(), event7head)
     await blocks.put(event8.cid, event8.bytes)
-    head = await advance(blocks, head, event8.cid)
+    head = await testAdvance(blocks, head, event8.cid)
     const event8head = head
     await visHead(blocks, event8head)
 
     const event9 = await EventBlock.create(seqEventData(), event7head)
     await blocks.put(event9.cid, event9.bytes)
-    head = await advance(blocks, head, event9.cid)
+    head = await testAdvance(blocks, head, event9.cid)
     const event9head = head
     await visHead(blocks, event9head)
 
     const event10 = await EventBlock.create(seqEventData(), event9head)
     await blocks.put(event10.cid, event10.bytes)
-    head = await advance(blocks, head, event10.cid)
+    head = await testAdvance(blocks, head, event10.cid)
     const event10head = head
     await visHead(blocks, event10head)
 
@@ -587,26 +559,7 @@ describe('Clock', () => {
     assert.equal(event10head.length, 1)
     assert.equal(event10head[0].toString(), event10.cid.toString())
 
-    // todo do these roots make sense?
-    // const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(blocks, [event5.cid, event2.cid])
-    // const toSync = await findUnknownSortedEvents(blocks, [event5.cid, event2.cid], { ancestor, sorted })
-    // assert.equal(toSync.length, 0)
-    // assert.equal(toSync[0].value.data.value, 'event3')
-    // assert.equal(toSync[1].value.data.value, 'event5')
-
-    // todo do these roots make sense?
-    // const ancestorWithSorted = await findCommonAncestorWithSortedEvents(blocks, [event6.cid, event2.cid])
-    // const toSync2 = await findUnknownSortedEvents(blocks, [event6.cid, event2.cid], ancestorWithSorted)
-    // assert.equal(toSync2.length, 0)
-
-    // assert.equal(toSync2[0].value.data.value, 'event3')
-    // assert.equal(toSync2[1].value.data.value, 'event5')
-    // assert.equal(toSync2[2].value.data.value, 'event4')
-    // assert.equal(toSync2[3].value.data.value, 'event6')
-    // const ancestorBlock = await blocks.get(ancestor)
-    // const ancestorDecoded = await decodeEventBlock(ancestorBlock.bytes)
-    const ancestorWithSorted2 = await findCommonAncestorWithSortedEvents(blocks, [event7.cid, event10.cid])
-    const toSync3 = await findUnknownSortedEvents(blocks, [event7.cid, event10.cid], ancestorWithSorted2)
+    const toSync3 = await testFindEventsToSync(blocks, [event7.cid, event10.cid])
     assert.equal(toSync3[0].value.data.value, 'event9')
     assert.equal(toSync3[1].value.data.value, 'event8')
     assert.equal(toSync3[2].value.data.value, 'event10')
@@ -623,36 +576,36 @@ describe('Clock', () => {
 
     const event0 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event0.cid, event0.bytes)
-    head = await advance(blocks, head, event0.cid)
+    head = await testAdvance(blocks, head, event0.cid)
 
     const event1 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event1.cid, event1.bytes)
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
 
     const event1head = head
 
     const event2 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event2.cid, event2.bytes)
-    head = await advance(blocks, head, event2.cid)
+    head = await testAdvance(blocks, head, event2.cid)
 
     const event3 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event3.cid, event3.bytes)
-    head = await advance(blocks, head, event3.cid)
+    head = await testAdvance(blocks, head, event3.cid)
 
     const event4 = await EventBlock.create(seqEventData(), event1head)
     await blocks.put(event4.cid, event4.bytes)
-    head = await advance(blocks, head, event4.cid)
+    head = await testAdvance(blocks, head, event4.cid)
 
     const parents2 = head
 
     const event5 = await EventBlock.create(seqEventData(), parents2)
     await blocks.put(event5.cid, event5.bytes)
-    head = await advance(blocks, head, event5.cid)
+    head = await testAdvance(blocks, head, event5.cid)
 
     // now very old one
     const event6 = await EventBlock.create(seqEventData(), parents0)
     await blocks.put(event6.cid, event6.bytes)
-    head = await advance(blocks, head, event6.cid)
+    head = await testAdvance(blocks, head, event6.cid)
 
     // for await (const line of vis(blocks, head)) console.log(line)
     assert.equal(head.length, 2)
@@ -675,7 +628,7 @@ describe('Clock', () => {
     const event1 = await EventBlock.create(seqEventData(), [event0.cid])
     await blocks.put(event1.cid, event1.bytes)
 
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
 
     // for await (const line of vis(blocks, head)) console.log(line)
     assert.equal(head.length, 1)
@@ -688,15 +641,11 @@ describe('Clock', () => {
     // alice
     const root = await EventBlock.create(seqEventData('alice'))
     await blocks.put(root.cid, root.bytes)
-    let head = await advance(blocks, [], root.cid)
+    let head = await testAdvance(blocks, [], root.cid)
     const roothead = head
     // db root
     let sinceHead = [...roothead]
-    let toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    let toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 0) // we use all docs for first query in Fireproof
 
     // create bob
@@ -704,70 +653,42 @@ describe('Clock', () => {
     await blocks.put(event0.cid, event0.bytes)
     // console.log('new event0', event0.cid)
 
-    head = await advance(blocks, head, event0.cid)
+    head = await testAdvance(blocks, head, event0.cid)
 
     const event0head = head
     sinceHead = event0head
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 0)
 
     sinceHead = [...roothead, ...event0head]
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 1)
 
     // create carol
     const event1 = await EventBlock.create(seqEventData('carol'), head)
     await blocks.put(event1.cid, event1.bytes)
-    head = await advance(blocks, head, event1.cid)
+    head = await testAdvance(blocks, head, event1.cid)
     const event1head = head
 
     sinceHead = [...event0head, ...event1head]
-    // sinceHead = event0head
-    const sigil = await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    // console.log('ancestor', (await decodeEventBlock((await blocks.get(sigil.ancestor)).bytes)).value)
-
-    toSync = await findUnknownSortedEvents(blocks, sinceHead, sigil)
-
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 1)
-
-    // for await (const line of vis(blocks, head)) console.log(line)
-
     sinceHead = [...event1head, ...roothead]
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
 
     assert.equal(toSync.length, 2)
 
     const event2 = await EventBlock.create(seqEventData('xxx'), head)
     await blocks.put(event2.cid, event2.bytes)
-    head = await advance(blocks, head, event2.cid)
+    head = await testAdvance(blocks, head, event2.cid)
     const event2head = head
 
     sinceHead = [...event2head, ...event0head]
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 2)
 
     sinceHead = [...event2head, ...event1head]
-    toSync = await findUnknownSortedEvents(
-      blocks,
-      sinceHead,
-      await findCommonAncestorWithSortedEvents(blocks, sinceHead)
-    )
+    toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 1)
   })
 })