@subsquid/batch-processor 1.0.0-portal-api.721f49 → 1.0.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@subsquid/batch-processor",
-  "version": "1.0.0-portal-api.721f49",
+  "version": "1.0.0",
   "description": "ETL processor",
   "license": "GPL-3.0-or-later",
-  "repository": "git@github.com:subsquid/squid.git",
+  "repository": "git@github.com:subsquid/squid-sdk.git",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -14,19 +14,22 @@
   ],
   "main": "lib/index.js",
   "dependencies": {
-    "@subsquid/logger": "^1.4.0",
-    "@subsquid/util-internal": "^3.2.0",
+    "@subsquid/logger": "^1.6.0",
+    "@subsquid/util-internal": "^3.3.0",
+    "@subsquid/util-internal-processor-tools": "^4.4.0",
     "@subsquid/util-internal-counters": "^1.3.2",
     "@subsquid/util-internal-prometheus-server": "^1.3.0",
     "@subsquid/util-internal-range": "^0.3.0",
-    "prom-client": "^14.2.0",
-    "@subsquid/util-internal-data-source": "0.0.1-portal-api.721f49"
+    "@subsquid/util-internal-data-source": "^0.0.0"
   },
   "devDependencies": {
-    "@types/node": "^18.18.14",
-    "typescript": "~5.5.4"
+    "@subsquid/util-internal-testing": "^0.0.0",
+    "@types/node": "^24.0.0",
+    "typescript": "5.5.4",
+    "vitest": "4.1.5"
   },
   "scripts": {
-    "build": "rm -rf lib && tsc"
+    "build": "rm -rf lib && tsc",
+    "test": "vitest --run"
   }
 }

package/src/database.ts

@@ -4,24 +4,27 @@
  */
 export type Database<S> = FinalDatabase<S> | HotDatabase<S>
 
-
 export interface FinalTxInfo {
     prevHead: HashAndHeight
     nextHead: HashAndHeight
     isOnTop: boolean
 }
 
-
 export interface FinalDatabase<S> {
     supportsHotBlocks?: false
     connect(): Promise<FinalDatabaseState>
-    getState?(): Promise<FinalDatabaseState>
-    transact(info: FinalTxInfo, cb: (store: S) => Promise<void>): Promise<void>
+    transact(info: FinalTxInfo, cb: (store: S) => Promise<DatabaseTransactResult | void>): Promise<void>
 }
 
+export interface DatabaseTransactResult {
+    templates?: TemplateMutation[]
+}
 
-export interface FinalDatabaseState extends HashAndHeight {}
-
+export interface FinalDatabaseState {
+    height: number
+    hash: string
+    templates?: TemplateMutation[]
+}
 
 export interface HotTxInfo {
     finalizedHead: HashAndHeight
@@ -29,26 +32,38 @@ export interface HotTxInfo {
     newBlocks: HashAndHeight[]
 }
 
-
 export interface HotDatabase<S> {
     supportsHotBlocks: true
     connect(): Promise<HotDatabaseState>
-    getState(): Promise<HotDatabaseState>
-    transact(info: FinalTxInfo, cb: (store: S) => Promise<void>): Promise<void>
+    transact(info: FinalTxInfo, cb: (store: S) => Promise<DatabaseTransactResult | void>): Promise<void>
 
     transactHot2(
         info: HotTxInfo,
-        cb: (store: S, blockSliceStart: number, blockSliceEnd: number) => Promise<void>
+        cb: (store: S, blockSliceStart: number, blockSliceEnd: number) => Promise<DatabaseTransactResult | void>,
     ): Promise<void>
 }
 
+export interface HotBlock extends HashAndHeight {
+    templates?: TemplateMutation[]
+}
 
 export interface HotDatabaseState extends HashAndHeight {
-    top: HashAndHeight[]
+    top: HotBlock[]
+    templates?: TemplateMutation[]
+}
+
+export interface FinalDatabaseState extends HashAndHeight {
+    templates?: TemplateMutation[]
 }
 
+export interface TemplateMutation {
+    type: 'add' | 'delete'
+    key: string
+    value: string
+    blockNumber: number
+}
 
 export interface HashAndHeight {
-    height: number
     hash: string
-}
+    height: number
+}

package/src/find-rollback-index.test.ts

@@ -0,0 +1,85 @@
+import type {BlockRef} from '@subsquid/util-internal-data-source'
+import {describe, expect, it} from 'vitest'
+import {findRollbackIndex} from './run'
+
+function ref(number: number, hash: string): BlockRef {
+    return {number, hash}
+}
+
+describe('findRollbackIndex', () => {
+    it('returns last index when chains are identical', () => {
+        const chain: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1'), ref(2, '0x2')]
+        expect(findRollbackIndex(chain, chain)).toBe(2)
+    })
+
+    it('returns the last common index when chains diverge mid-way', () => {
+        const current: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1'), ref(2, '0x2'), ref(3, '0x3')]
+        const fork: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1'), ref(2, '0x2alt'), ref(3, '0x3alt')]
+        // Common prefix is [0x0, 0x1]; divergence at index 2 (hash mismatch
+        // at number=2). Rollback target = last common index = 1.
+        expect(findRollbackIndex(current, fork)).toBe(1)
+    })
+
+    it('returns -1 when the two chains share no blocks at all', () => {
+        const current: BlockRef[] = [ref(0, '0xA0'), ref(1, '0xA1')]
+        const fork: BlockRef[] = [ref(0, '0xB0'), ref(1, '0xB1')]
+        // Same numbers, different hashes at index 0. No common prefix exists.
+        expect(findRollbackIndex(current, fork)).toBe(-1)
+    })
+
+    it('returns -1 when the current chain is empty', () => {
+        const fork: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        expect(findRollbackIndex([], fork)).toBe(-1)
+    })
+
+    it('returns -1 when the fork chain is empty', () => {
+        const current: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        expect(findRollbackIndex(current, [])).toBe(-1)
+    })
+
+    it('skips non-overlapping block numbers on either side and finds the common suffix', () => {
+        // current has 0..5, fork has 3..7 — only numbers 3, 4, 5 overlap.
+        const current: BlockRef[] = [
+            ref(0, '0x0'),
+            ref(1, '0x1'),
+            ref(2, '0x2'),
+            ref(3, '0x3'),
+            ref(4, '0x4'),
+            ref(5, '0x5'),
+        ]
+        const fork: BlockRef[] = [
+            ref(3, '0x3'),
+            ref(4, '0x4'),
+            ref(5, '0x5-alt'), // divergence starts here
+            ref(6, '0x6-alt'),
+            ref(7, '0x7-alt'),
+        ]
+        // Common prefix inside overlap: 3, 4 match. Last common index in
+        // currentChain = 4 (block #4 has hash '0x4').
+        expect(findRollbackIndex(current, fork)).toBe(4)
+    })
+
+    it('returns -1 when all fork numbers are strictly above current chain range', () => {
+        const current: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        const fork: BlockRef[] = [ref(10, '0xA'), ref(11, '0xB')]
+        expect(findRollbackIndex(current, fork)).toBe(-1)
+    })
+
+    it('returns -1 when all fork numbers are strictly below current chain range', () => {
+        const current: BlockRef[] = [ref(10, '0xA'), ref(11, '0xB')]
+        const fork: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        expect(findRollbackIndex(current, fork)).toBe(-1)
+    })
+
+    it('returns the last match when the fork is a strict prefix of the current chain', () => {
+        const current: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1'), ref(2, '0x2'), ref(3, '0x3')]
+        const fork: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        expect(findRollbackIndex(current, fork)).toBe(1)
+    })
+
+    it('returns the last match when the current chain is a strict prefix of the fork', () => {
+        const current: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1')]
+        const fork: BlockRef[] = [ref(0, '0x0'), ref(1, '0x1'), ref(2, '0x2'), ref(3, '0x3')]
+        expect(findRollbackIndex(current, fork)).toBe(1)
+    })
+})