@xyo-network/react-chain-blockchain 1.17.0 → 1.17.1

package/src/hooks/chain-iterator/ChainIteratorStore.ts

@@ -1,87 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { XyoChainIteratorParams } from '@xyo-network/chain-services'
-import { ChainBlockNumberIterationService } from '@xyo-network/chain-services'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol'
-import type { EventingChainBlockNumberIteratorService, HeadEventArgs } from '@xyo-network/xl1-protocol-sdk'
-import { hydrateBlock } from '@xyo-network/xl1-protocol-sdk'
-
-export type Listener = (...args: Array<unknown>) => void
-
-export type ChainIteratorStoreValues = { chainIterator: ChainBlockNumberIterationService; error?: Error; head: HydratedBlock }
-
-export class ChainIteratorStore {
-  private _chainIterator: EventingChainBlockNumberIteratorService | undefined
-  private _externalListeners: Listener[] = []
-  private _internalUnsubscribes: WeakRef<() => void>[] = []
-  private _values: ChainIteratorStoreValues | undefined
-
-  get chainIterator(): EventingChainBlockNumberIteratorService {
-    return assertEx(this._chainIterator, () => 'ChainIteratorStore has not been initialized')
-  }
-
-  get values(): ChainIteratorStoreValues {
-    return assertEx(this._values, () => 'ChainIteratorStore values have not been initialized')
-  }
-
-  static async create(params: XyoChainIteratorParams): Promise<ChainIteratorStore> {
-    // create the classes
-    const instance = new ChainIteratorStore()
-    const chainIterator = await ChainBlockNumberIterationService.create(params)
-
-    // set the chainIterator
-    instance._chainIterator = chainIterator
-
-    const head = await chainIterator.head()
-    const hydratedHead = await hydrateBlock({ chainMap: params.chainMap }, await PayloadBuilder.hash(head))
-
-    // set the initial values
-    instance._values = {
-      chainIterator,
-      head: hydratedHead,
-    }
-
-    // set the internal listeners
-    const headUpdatedListener = async ({ blocks }: HeadEventArgs) => {
-      const hydratedBlock = await hydrateBlock({ chainMap: params.chainMap }, await PayloadBuilder.hash(blocks?.[0]))
-      instance._values = {
-        chainIterator,
-        head: hydratedBlock,
-      }
-      instance.emitChange()
-    }
-
-    // Add listener to the chainIterator
-    const unsubscribe = chainIterator.on('headUpdated', headUpdatedListener)
-
-    // track the internal listener
-    const weakRefListener = new WeakRef(unsubscribe)
-    instance._internalUnsubscribes.push(weakRefListener)
-
-    return instance
-  }
-
-  cleanup() {
-    for (const unsubscribeRef of this._internalUnsubscribes) {
-      const unsubscribe = unsubscribeRef.deref()
-      unsubscribe?.()
-    }
-  }
-
-  getSnapshot(): Partial<ChainIteratorStoreValues> {
-    return this.values
-  }
-
-  subscribe(onStoreChange: Listener) {
-    this._externalListeners.push(onStoreChange)
-    return () => {
-      this._externalListeners = this._externalListeners.filter(l => l !== onStoreChange)
-    }
-  }
-
-  private emitChange() {
-    for (const listener of this._externalListeners) {
-      listener()
-    }
-  }
-}

package/src/hooks/chain-iterator/useChainIteratorUpdatingHead.ts

@@ -1,56 +0,0 @@
-import { toHex } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { type ChainBlockNumberIteratorService, findMostRecentBlock } from '@xyo-network/xl1-protocol-sdk'
-import { useEffect, useState } from 'react'
-
-export interface ChainIteratorUpdatingHeadParams {
-  chainArchivist?: ArchivistInstance
-  chainIterator?: ChainBlockNumberIteratorService
-  interval?: number
-  maxBlocks?: number
-}
-
-// Polls the chain archivist for new blocks and updates the chain iterator head
-export const useChainIteratorUpdatingHead = ({
-  chainIterator, interval = 500, maxBlocks, chainArchivist,
-}: ChainIteratorUpdatingHeadParams): Error | undefined => {
-  const [error, setError] = useState<Error>()
-
-  useEffect(() => {
-    let pollArchivistTimeout: NodeJS.Timeout | undefined
-
-    const pollingFunction = async () => {
-      if (chainIterator && chainArchivist) {
-        try {
-          const currentHead = await chainIterator.head()
-          const mostRecentBlock = await findMostRecentBlock(chainArchivist)
-          if (mostRecentBlock) {
-            const currentBlockNumber = currentHead?.block ?? -1
-            const nextBlockNumber = mostRecentBlock.block
-            if (nextBlockNumber > currentBlockNumber) {
-              console.debug('Found more recent head:', toHex(nextBlockNumber))
-              console.debug('Updating head:', `${toHex(nextBlockNumber)}`)
-              await chainIterator.updateHead(mostRecentBlock)
-              console.debug('Updated head:', `${toHex(nextBlockNumber)}`)
-            }
-          }
-        } catch (e) {
-          setError(e as Error)
-          console.error(e)
-        }
-      }
-
-      // Schedule the next polling function
-      // disabling because it looks like a false positive
-      // eslint-disable-next-line react-web-api/no-leaked-timeout
-      pollArchivistTimeout = setTimeout(() => void pollingFunction(), interval)
-    }
-
-    // Start the polling function
-    void pollingFunction()
-
-    return () => clearInterval(pollArchivistTimeout)
-  }, [interval, chainIterator, chainArchivist, maxBlocks])
-
-  return error
-}