Use safeHeight in MultiIndexer

packages/uif/src/indexers/multi/MultiIndexer.test.ts

@@ -87,6 +87,49 @@ describe(MultiIndexer.name, () => {
         saved('c', 300, null, 300),
       ])
     })
+
+    it('calls getters in order', async () => {
+      const calls: string[] = []
+      const testIndexer = new TestMultiIndexer([], [])
+      testIndexer.multiInitialize = mockFn(async () => {
+        calls.push('multiInitialize')
+        return []
+      })
+      testIndexer.getInitialConfigurations = mockFn(() => {
+        calls.push('getInitialConfigurations')
+        return []
+      })
+      testIndexer.getSafeHeight = mockFn(() => {
+        calls.push('getSafeHeight')
+        return Promise.resolve(undefined)
+      })
+
+      await testIndexer.initialize()
+
+      expect(calls).toEqual([
+        'multiInitialize',
+        'getInitialConfigurations',
+        'getSafeHeight',
+      ])
+    })
+
+    it('getSafeHeight lower than saved configs', async () => {
+      const testIndexer = new TestMultiIndexer(
+        [actual('a', 100, 200)],
+        [saved('a', 100, 200, 150)],
+      )
+      testIndexer.getSafeHeight.resolvesTo(130)
+      expect(await testIndexer.initialize()).toEqual(130)
+    })
+
+    it('getSafeHeight higher than saved configs', async () => {
+      const testIndexer = new TestMultiIndexer(
+        [actual('a', 100, 200)],
+        [saved('a', 100, 200, 150)],
+      )
+      testIndexer.getSafeHeight.resolvesTo(160)
+      expect(await testIndexer.initialize()).toEqual(150)
+    })
   })
 
   describe(MultiIndexer.prototype.update.name, () => {
@@ -405,6 +448,12 @@ class TestMultiIndexer extends MultiIndexer<null> {
     super(Logger.SILENT, [], configurations)
   }
 
+  getSafeHeight =
+    mockFn<MultiIndexer<null>['getSafeHeight']>().resolvesTo(undefined)
+
+  setSafeHeight =
+    mockFn<MultiIndexer<null>['setSafeHeight']>().resolvesTo(undefined)
+
   override multiInitialize(): Promise<SavedConfiguration<null>[]> {
     return Promise.resolve(this._saved)
   }

packages/uif/src/indexers/multi/MultiIndexer.ts

@@ -109,23 +109,36 @@ export abstract class MultiIndexer<T> extends ChildIndexer {
     configurations: SavedConfiguration<T>[],
   ): Promise<void>
 
+  /**
+   * It should return a height that the indexer has synced up to. If the indexer
+   * has not synced any data, it should return `undefined`.
+   *
+   * This method is expected to read the height that was saved previously with
+   * `setSafeHeight`. It shouldn't call `setSafeHeight` itself.
+   *
+   * @returns The height that the indexer has synced up to.
+   */
+  abstract getSafeHeight(): Promise<number | undefined>
+
   async initialize(): Promise<number> {
+    const saved = await this.multiInitialize()
+
     this.configurations = await this.getInitialConfigurations()
     this.ranges = toRanges(this.configurations)
 
-    const saved = await this.multiInitialize()
-
     const { toRemove, toSave, safeHeight } = diffConfigurations(
       this.configurations,
       saved,
     )
+    const oldSafeHeight = (await this.getSafeHeight()) ?? safeHeight
 
     this.saved = toSave
     if (toRemove.length > 0) {
       await this.removeData(toRemove)
     }
     await this.saveConfigurations(toSave)
-    return safeHeight
+
+    return Math.min(safeHeight, oldSafeHeight)
   }
 
   async update(from: number, to: number): Promise<number> {
@@ -179,10 +192,6 @@ export abstract class MultiIndexer<T> extends ChildIndexer {
   async invalidate(targetHeight: number): Promise<number> {
     return Promise.resolve(targetHeight)
   }
-
-  async setSafeHeight(): Promise<void> {
-    return Promise.resolve()
-  }
 }
 
 function findRange<T>(