@xyo-network/chain-services 1.16.22 → 1.16.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.16.22",
+  "version": "1.16.24",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -40,38 +40,39 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
-    "@xylabs/sdk-js": "~5.0.37",
-    "@xylabs/telemetry": "~5.0.37",
+    "@xylabs/sdk-js": "~5.0.39",
+    "@xylabs/telemetry": "~5.0.39",
     "@xyo-network/account-model": "~5.1.24",
     "@xyo-network/archivist-memory": "~5.1.24",
     "@xyo-network/archivist-model": "~5.1.24",
     "@xyo-network/boundwitness-model": "~5.1.24",
     "@xyo-network/boundwitness-validator": "~5.1.24",
     "@xyo-network/boundwitness-wrapper": "~5.1.24",
-    "@xyo-network/chain-analyze": "~1.16.22",
-    "@xyo-network/chain-modules": "~1.16.22",
-    "@xyo-network/chain-protocol": "~1.16.22",
-    "@xyo-network/chain-utils": "~1.16.22",
+    "@xyo-network/chain-analyze": "~1.16.24",
+    "@xyo-network/chain-modules": "~1.16.24",
+    "@xyo-network/chain-protocol": "~1.16.24",
+    "@xyo-network/chain-utils": "~1.16.24",
     "@xyo-network/payload-builder": "~5.1.24",
     "@xyo-network/payload-model": "~5.1.24",
     "@xyo-network/typechain": "~4.0.10",
-    "@xyo-network/xl1-protocol": "~1.13.11",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.22",
-    "@xyo-network/xl1-validation": "~1.16.22",
-    "@xyo-network/xl1-wrappers": "~1.16.22",
+    "@xyo-network/xl1-protocol": "~1.13.13",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.24",
+    "@xyo-network/xl1-validation": "~1.16.24",
+    "@xyo-network/xl1-wrappers": "~1.16.24",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
-    "lru-cache": "~11.2.2"
+    "lru-cache": "~11.2.2",
+    "zod": "~4.1.12"
   },
   "devDependencies": {
     "@types/node": "~24.10.1",
-    "@xylabs/sdk-js": "~5.0.37",
+    "@xylabs/sdk-js": "~5.0.39",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.37",
+    "@xylabs/vitest-extended": "~5.0.39",
     "@xyo-network/account": "~5.1.24",
     "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/chain-validation": "~1.16.22",
+    "@xyo-network/chain-validation": "~1.16.24",
     "@xyo-network/wallet": "~5.1.24",
     "eslint": "^9.39.1",
     "tslib": "~2.8.1",

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,12 +1,12 @@
 import {
-  Address, creatable, Hash,
+  Address, assertEx, creatable, Hash,
 } from '@xylabs/sdk-js'
 import { spanRootAsync } from '@xylabs/telemetry'
 import { ReadArchivist } from '@xyo-network/archivist-model'
 import { AttoXL1, XL1BlockRange } from '@xyo-network/xl1-protocol'
 import {
   AccountBalanceHistoryItem,
-  AccountBalanceService,
+  AccountBalanceViewer,
   balancesSummary,
   BalanceStepSummaryContext,
   BlockViewer,
@@ -14,11 +14,19 @@ import {
   SimpleAccountBalanceViewer,
   TransfersStepSummaryContext,
 } from '@xyo-network/xl1-protocol-sdk'
+import z from 'zod'
 
 import { BaseService } from '../BaseService.ts'
 import { blockViewerFromChainIteratorAndArchivist } from '../blockViewerFromChainIteratorAndArchivist.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
+export const BaseAccountBalanceServiceParamsZod = z.object({
+  chainArchivist: z.object().loose(),
+  chainIterator: z.object().loose(),
+  context: z.object().loose(),
+  transferContext: z.object().loose(),
+})
+
 export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
   chainArchivist: ReadArchivist
   chainIterator: EventingChainBlockNumberIteratorService
@@ -27,26 +35,40 @@ export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
 }
 
 @creatable()
-export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceService {
-  protected accountBalanceViewer!: AccountBalanceService
+export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceViewer {
+  protected accountBalanceViewer!: AccountBalanceViewer
   protected blockViewer!: BlockViewer
 
+  static override async paramsHandler(params?: Partial<BaseAccountBalanceServiceParams> | undefined): Promise<BaseAccountBalanceServiceParams> {
+    // TODO: Use a real zod and move the zod check to the AbstractCreatable class
+    BaseAccountBalanceServiceParamsZod.parse(params)
+    assertEx(params?.context?.head, () => 'BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams')
+    return { ...(await super.paramsHandler(params)), ...params } as BaseAccountBalanceServiceParams
+  }
+
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountBalances([address], headOrRange)
+    const balances = await this.accountsBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
   async accountBalanceHistory(address: Address): Promise<AccountBalanceHistoryItem[]>
   async accountBalanceHistory(address: Address, head: Hash): Promise<AccountBalanceHistoryItem[]>
   async accountBalanceHistory(address: Address, range: XL1BlockRange): Promise<AccountBalanceHistoryItem[]>
-  async accountBalanceHistory(address: Address, headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
-    return await this.accountBalanceViewer.accountBalanceHistory(address, headOrRange)
+  accountBalanceHistory(_address: Address, _headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
+    throw new Error('Method not implemented.')
   }
 
-  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
+  async accountsBalances(address: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
     return await spanRootAsync('balances', async () => {
+      const context = {
+        head: this.params.context.head,
+        stepSemaphores: this.params.context.stepSemaphores,
+        store: this.params.context.store,
+        chainId: this.params.context.chainId,
+        summaryMap: this.params.context.summaryMap,
+      } satisfies BalanceStepSummaryContext
       const summary = await balancesSummary(
-        this.params.context,
+        context,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {
@@ -57,11 +79,11 @@ export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceSer
     })
   }
 
-  async accountBalancesHistories(addresses: Address[]): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountBalancesHistories(addresses: Address[], head: Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountBalancesHistories(addresses: Address[], range: XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountBalancesHistories(addresses: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    return await this.accountBalanceViewer.accountBalancesHistories(addresses, headOrRange)
+  async accountsBalancesHistory(addresses: Address[]): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  async accountsBalancesHistory(addresses: Address[], head: Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  async accountsBalancesHistory(addresses: Address[], range: XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
+  accountsBalancesHistory(_addresses: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+    throw new Error('Method not implemented.')
   }
 
   override createHandler() {

package/src/AccountBalance/accountBalanceServiceFromArchivist.ts

@@ -5,7 +5,7 @@ import { findMostRecentBlock } from '@xyo-network/chain-protocol'
 import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 import type { ChainId } from '@xyo-network/xl1-protocol'
 import { StepSizes } from '@xyo-network/xl1-protocol'
-import type { AccountBalanceService, BalancesStepSummary } from '@xyo-network/xl1-protocol-sdk'
+import type { AccountBalanceViewer, BalancesStepSummary } from '@xyo-network/xl1-protocol-sdk'
 import { LruCacheMap, readPayloadMapFromStore } from '@xyo-network/xl1-protocol-sdk'
 import { Semaphore } from 'async-mutex'
 
@@ -15,7 +15,7 @@ import { BaseAccountBalanceService } from './BaseAccountBalanceService.ts'
 export const accountBalancesServiceFromArchivist = async (
   chainId: ChainId,
   archivist: ReadArchivist<WithStorageMeta<Payload>>,
-): Promise<AccountBalanceService> => {
+): Promise<AccountBalanceViewer> => {
   const summaryMap = new LruCacheMap<string, BalancesStepSummary>({
     max: 100_000,
     allowStale: true,

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-statements */
 import {
-  Address, asHash, assertEx, creatable,
+  Address, AddressZod, asHash, assertEx, creatable,
   exists,
   Hex,
   hexToBigInt,
@@ -21,8 +21,9 @@ import {
   Transfer, XYO_STEP_REWARD_ADDRESS,
 } from '@xyo-network/xl1-protocol'
 import {
-  AccountBalanceService, BlockProducerService, Config, PendingTransactionsService, StakeIntentService, TimeSyncViewer,
+  AccountBalanceViewer, BlockProducerService, Config, PendingTransactionsService, StakeIntentService, TimeSyncViewer,
 } from '@xyo-network/xl1-protocol-sdk'
+import z from 'zod'
 
 import { BaseService } from '../BaseService.ts'
 import { XyoValidatorParams } from '../ChainValidator/index.ts'
@@ -44,8 +45,16 @@ export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
  */
 export const XYO_PRODUCER_REDECLARATION_WINDOW = 500
 
+export const BaseBlockProducerServiceParamsZod = z.object({
+  balanceService: z.object().loose(),
+  pendingTransactionsService: z.object().loose(),
+  rejectedTransactionsArchivist: z.object().loose(),
+  rewardAddress: AddressZod,
+  time: z.object().loose(),
+})
+
 export interface BaseBlockProducerServiceParams extends XyoValidatorParams<Pick<Config, 'producer'>> {
-  balanceService: AccountBalanceService
+  balanceService: AccountBalanceViewer
   pendingTransactionsService: PendingTransactionsService
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
@@ -131,6 +140,12 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
   }
 
+  static override async paramsHandler(params?: Partial<BaseBlockProducerServiceParams> | undefined): Promise<BaseBlockProducerServiceParams> {
+    // TODO: Use a real zod and move the zod check to the AbstractCreatable class
+    BaseBlockProducerServiceParamsZod.parse(params)
+    return { ...(await super.paramsHandler(params)), ...params } as BaseBlockProducerServiceParams
+  }
+
   async next(head: WithStorageMeta<BlockBoundWitness>): Promise<HydratedBlock | undefined> {
     // If the block is for another chain, ignore
     if (head.chain !== this.chainId) return
@@ -228,7 +243,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       // Build the block
       this.logger?.info(`Building block ${head.block + 1}`)
       const startBuild = Date.now()
-      const stepRewardPoolBalance = (await this.balanceService.accountBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
+      const stepRewardPoolBalance = (await this.balanceService.accountsBalances([XYO_STEP_REWARD_ADDRESS]))[XYO_STEP_REWARD_ADDRESS]
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account], XYO_STEP_REWARD_ADDRESS, stepRewardPoolBalance)
 
       this.logger?.info(
@@ -263,7 +278,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       if (!transfer) return
       const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? '00' as Hex), 0n)
       if (validateBalances) {
-        const balance = (await this.balanceService.accountBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n)
+        const balance = (await this.balanceService.accountsBalances([transfer.from]))[transfer.from] ?? AttoXL1(0n)
         if (balance >= totalTransferCost) {
           fundedTransfers.push(transfer)
           return tx

package/src/ChainService/Memory/Memory.ts

@@ -1,20 +1,25 @@
 import type { Address } from '@xylabs/sdk-js'
-import { ZERO_ADDRESS } from '@xylabs/sdk-js'
+import {
+  assertEx, toAddress, ZERO_ADDRESS,
+} from '@xylabs/sdk-js'
 import type { ChainService, Config } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../../BaseService.ts'
 import type { BaseServiceParams } from '../../model/index.ts'
 
-export interface MemoryChainServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {}
+export interface MemoryChainServiceParams extends BaseServiceParams<Pick<Config, 'producer'>> {
+  chainId: Address
+}
 
 /**
  * A class that represents a chain stake as backed in memory
  */
 export class MemoryChainService extends BaseService<MemoryChainServiceParams> implements ChainService {
+  protected _chainId: Address | undefined
   protected _simulatedStake: bigint = 1n
 
   get chainId(): Address {
-    return ZERO_ADDRESS
+    return assertEx(this._chainId, () => 'Chain ID not set')
   }
 
   async active(): Promise<bigint> {
@@ -34,7 +39,7 @@ export class MemoryChainService extends BaseService<MemoryChainServiceParams> im
   }
 
   override createHandler(): void {
-    const { minStake } = this.params.config.producer
+    const { minStake = 1 } = this.params.config.producer ?? {}
     this._simulatedStake = BigInt(minStake)
   }
 
@@ -85,4 +90,9 @@ export class MemoryChainService extends BaseService<MemoryChainServiceParams> im
   async withdrawnByStaker(_staker: string): Promise<bigint> {
     return await Promise.resolve(0n)
   }
+
+  protected override async startHandler(): Promise<void> {
+    await super.startHandler()
+    this._chainId = this.params.chainId ?? toAddress(1n)
+  }
 }

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -186,10 +186,22 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
             { chainId: this.chainId },
             this.additionalPendingTransactionValidators,
           )])))
+
           const validTransactions = txValidationResults.filter((
             [, errors],
           ) => errors.length === 0).map(([tx]) => tx) as SignedHydratedTransactionWithStorageMeta[]
 
+          const invalidTransactions = txValidationResults.filter((
+            [, errors],
+          ) => errors.length > 0).map(([tx]) => tx) as SignedHydratedTransactionWithStorageMeta[]
+
+          if (invalidTransactions.length > 0) {
+            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`)
+            for (const tx of invalidTransactions) {
+              this.logger?.warn(tx[0]._hash)
+            }
+          }
+
           // Add the valid hydrated transactions to the result set.
           foundPendingTransactions.push(...validTransactions)
         }

package/src/Schemas/BaseSchemasService.ts

@@ -0,0 +1,34 @@
+import { creatable, Hash } from '@xylabs/sdk-js'
+import { spanRootAsync } from '@xylabs/telemetry'
+import { Schema } from '@xyo-network/payload-model'
+import {
+  SchemasService,
+  SchemasStepSummaryContext,
+  schemasSummary,
+} from '@xyo-network/xl1-protocol-sdk'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseSchemasServiceParams extends BaseServiceParams {
+  context: SchemasStepSummaryContext
+}
+
+@creatable()
+export class BaseSchemasService extends BaseService<BaseSchemasServiceParams> implements SchemasService {
+  async schema(head: Hash, schema: Schema): Promise<number> {
+    return (await this.schemas(head, [schema]))[schema] ?? 0
+  }
+
+  async schemas(head: Hash, schemas: Schema[]): Promise<Partial<Record<Schema, number>>> {
+    return await spanRootAsync('transfers', async () => {
+      const summary = await schemasSummary(this.params.context)
+      const result: Record<Schema, number> = {}
+      for (const schema of schemas) {
+        const count = summary[schema] ?? 0
+        result[schema] = count
+      }
+      return result
+    })
+  }
+}

package/src/Schemas/index.ts

@@ -0,0 +1 @@
+export * from './BaseSchemasService.ts'

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -25,6 +25,7 @@ import {
   isChainIndexingServiceState,
   readPayloadMapFromStore,
   StakeIntentService,
+  timeBudget,
 } from '@xyo-network/xl1-protocol-sdk'
 import { Mutex } from 'async-mutex'
 import { LRUCache } from 'lru-cache'
@@ -169,34 +170,36 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
   }
 
   private async recoverState(current: Hash): Promise<void> {
-    const currentBlock = assertEx(asBlockBoundWitness((await this.chainArchivist.get([current]))?.[0]), () => `Block ${current} not found`)
-    const currentBlockNum = currentBlock.block
-    // Find last state before current head (in case of rollback, we indexed past it on an uncle chain, etc.)
-    const opts: ArchivistNextOptions = { ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS }
-    while (true) {
-      const predicate = (p: WithStorageMeta<Payload>) => {
-        const state = asChainIndexingServiceStateWithStorageMeta(p)
-        return state ? true : false
-      }
-      const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts)
-      if (isChainIndexingServiceState<SerializedIntervalMap>(state)) {
-        const indexed = (await this.chainArchivist.get([state.endBlockHash]))?.[0]
-        const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed)
-        if (indexedBlock) {
-          const indexedBlockNum = indexedBlock.block
-          if (indexedBlockNum <= currentBlockNum) {
-            const data = state.state as SerializedIntervalMap
-            this._producers = new IntervalMap(data)
-            this._lastIndexedBlockHash = indexedBlock._hash
-            break
-          }
+    return await timeBudget('XyoStakeIntentService.recoverState', console, async () => {
+      const currentBlock = assertEx(asBlockBoundWitness((await this.chainArchivist.get([current]))?.[0]), () => `Block ${current} not found`)
+      const currentBlockNum = currentBlock.block
+      // Find last state before current head (in case of rollback, we indexed past it on an uncle chain, etc.)
+      const opts: ArchivistNextOptions = { ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS }
+      while (true) {
+        const predicate = (p: WithStorageMeta<Payload>) => {
+          const state = asChainIndexingServiceStateWithStorageMeta(p)
+          return state ? true : false
         }
-      } else {
+        const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts)
+        if (isChainIndexingServiceState<SerializedIntervalMap>(state)) {
+          const indexed = (await this.chainArchivist.get([state.endBlockHash]))?.[0]
+          const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed)
+          if (indexedBlock) {
+            const indexedBlockNum = indexedBlock.block
+            if (indexedBlockNum <= currentBlockNum) {
+              const data = state.state as SerializedIntervalMap
+              this._producers = new IntervalMap(data)
+              this._lastIndexedBlockHash = indexedBlock._hash
+              break
+            }
+          }
+        } else {
         // No state found, start from genesis
-        break
+          break
+        }
+        opts.open = true
       }
-      opts.open = true
-    }
+    }, 2000, true)
   }
 
   private async updateIndex(displayProgress = false): Promise<void> {
@@ -207,29 +210,31 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
       return await this.spanAsync('updateIndex', async () => {
         const currentHead = await this.chainIterator.head()
         if (isUndefined(currentHead)) return
-        const currentHeadHash = await PayloadBuilder.hash(currentHead)
-        const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(this.chainArchivist)
-        const result = await analyzeChain({ chainMap }, [new ChainStakeIntentAnalyzer('producer')], currentHeadHash, this._lastIndexedBlockHash)
-        const signedDeclarations = filterAs(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent)
-        if (currentHead.block === undefined) return
-        const currentHeadBlockNum = currentHead.block
-        if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`)
-        for (const signedDeclaration of signedDeclarations) {
-          const { exp, nbf } = signedDeclaration
-          const start = nbf
-          const stop = exp
-          const address = asAddress(signedDeclaration?.from)
-          if (start !== undefined && stop !== undefined && address !== undefined) {
-            this._producers.insert(address, start, stop)
+        return await timeBudget('XyoStakeIntentService.updateIndex', console, async () => {
+          const currentHeadHash = currentHead._hash
+          const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(this.chainArchivist)
+          const result = await analyzeChain({ chainMap }, [new ChainStakeIntentAnalyzer('producer')], currentHeadHash, this._lastIndexedBlockHash)
+          const signedDeclarations = filterAs(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent)
+          if (currentHead.block === undefined) return
+          const currentHeadBlockNum = currentHead.block
+          if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`)
+          for (const signedDeclaration of signedDeclarations) {
+            const { exp, nbf } = signedDeclaration
+            const start = nbf
+            const stop = exp
+            const address = asAddress(signedDeclaration?.from)
+            if (start !== undefined && stop !== undefined && address !== undefined) {
+              this._producers.insert(address, start, stop)
+            }
           }
-        }
-        /*
+          /*
       if (index % STATE_PERSISTENCE_INTERVAL === 0n) {
         if (displayProgress) this.logger?.info(`Persisting state at block ${index}`)
         await this.persistState(await PayloadBuilder.hash(block))
       }
         */
-        this._lastIndexedBlockHash = currentHeadHash
+          this._lastIndexedBlockHash = currentHeadHash
+        }, 2000, true)
       })
     })
   }

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './Election/index.ts'
 export * from './model/index.ts'
 export * from './NetworkStakeStepReward/index.ts'
 export * from './PendingTransactions/index.ts'
+export * from './Schemas/index.ts'
 export * from './StakeIntent/index.ts'
 export * from './StepStake/index.ts'
 export * from './Time/index.ts'