@xyo-network/chain-services 1.16.9 → 1.16.11

package/src/Time/BaseTimeSyncService.ts

@@ -1,24 +1,15 @@
-import { assertEx } from '@xylabs/assert'
-import { creatable } from '@xylabs/creatable'
-import { asHash, Hash } from '@xylabs/hex'
-import { EmptyObject } from '@xylabs/object'
-import { Promisable } from '@xylabs/promise'
+import { creatable, EmptyObject } from '@xylabs/sdk-js'
 import { ReadArchivist } from '@xyo-network/archivist-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { TimeDomain, TimePayload } from '@xyo-network/xl1-protocol'
 import {
-  asTimePayload,
-  TimeDomain, TimePayload, TimeSchema,
-} from '@xyo-network/xl1-protocol'
-import { EventingChainBlockNumberIteratorService, TimeSyncViewer } from '@xyo-network/xl1-protocol-sdk'
+  EventingChainBlockNumberIteratorService, SimpleTimeSyncViewer, TimeSyncViewer,
+} from '@xyo-network/xl1-protocol-sdk'
 import { Provider } from 'ethers'
 
 import { BaseService } from '../BaseService.ts'
+import { blockViewerFromChainIteratorAndArchivist } from '../blockViewerFromChainIteratorAndArchivist.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
-export interface TimeProvider {
-  currentTime(): Promise<[string, number]>
-}
-
 export interface BaseTimeServiceParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {
   chainArchivist: ReadArchivist
   chainIterator: EventingChainBlockNumberIteratorService
@@ -27,88 +18,42 @@ export interface BaseTimeServiceParams<TConfig extends EmptyObject = EmptyObject
 
 @creatable()
 export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncViewer {
-  get chainArchivist() {
+  protected timeSyncViewer!: TimeSyncViewer
+
+  protected get chainArchivist() {
     return this.params.chainArchivist
   }
 
-  get chainIterator() {
+  protected get chainIterator() {
     return this.params.chainIterator
   }
 
-  get ethProvider() {
+  protected get ethProvider() {
     return this.params.ethProvider
   }
 
   async convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promise<number> {
-    switch (fromDomain) {
-      case 'xl1': {
-        const block = assertEx(await this.chainIterator.get(from), () => 'Block not found')
-        const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema)
-        const hash = timeSchemaIndex === -1 ? undefined : block.payload_hashes[timeSchemaIndex]
-        const [payload] = hash === undefined ? [] : await this.chainArchivist.get([hash])
-        const timePayload = asTimePayload(payload)
-        if (timePayload === undefined) return 0
-        switch (toDomain) {
-          case 'xl1': {
-            return timePayload.xl1 ?? 0
-          }
-          case 'epoch': {
-            return timePayload.epoch ?? 0
-          }
-          case 'ethereum': {
-            return timePayload.ethereum ?? 0
-          }
-          default: {
-            throw new Error(`Unsupported to toDomain: ${toDomain}`)
-          }
-        }
-      }
-      default: {
-        throw new Error(`Unsupported from fromDomain: ${fromDomain}`)
-      }
-    }
+    return await this.timeSyncViewer.convertTime(fromDomain, toDomain, from)
+  }
+
+  override async createHandler(): Promise<void> {
+    await super.createHandler()
+    const blockViewer = blockViewerFromChainIteratorAndArchivist(
+      this.chainIterator,
+      this.chainArchivist,
+    )
+    this.timeSyncViewer = new SimpleTimeSyncViewer(blockViewer, this.ethProvider)
   }
 
   async currentTime(domain: TimeDomain): Promise<[string, number]> {
-    switch (domain) {
-      case 'xl1': {
-        return ['xl1', (await this.chainIterator.head()).block]
-      }
-      case 'epoch': {
-        return ['epoch', Date.now()]
-      }
-      case 'ethereum': {
-        return ['ethereum', (await this.ethProvider?.getBlockNumber()) ?? 0]
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`)
-      }
-    }
+    return await this.timeSyncViewer.currentTime(domain)
   }
 
-  async currentTimeAndHash(domain: TimeDomain): Promise<[number, Hash | null]> {
-    switch (domain) {
-      case 'xl1': {
-        const head = await this.chainIterator.head()
-        return [head.block, await PayloadBuilder.hash(head)]
-      }
-      case 'epoch': {
-        return [Date.now(), null]
-      }
-      case 'ethereum': {
-        const provider = assertEx(this.ethProvider, () => 'Ethereum provider not configured')
-        const blockNumber = (await provider.getBlockNumber()) ?? 0
-        const block = await provider.getBlock(blockNumber)
-        const blockHash = asHash(assertEx(block?.hash, () => 'Block hash not found'), true)
-        return [blockNumber, blockHash]
-      }
-      default: {
-        throw new Error(`Unknown time domain: ${domain}`)
-      }
-    }
+  async currentTimeAndHash(domain: TimeDomain): Promise<[number, string | null]> {
+    return await this.timeSyncViewer.currentTimeAndHash(domain)
   }
 
-  currentTimePayload(): Promisable<TimePayload> {
-    throw new Error('Method not implemented.')
+  async currentTimePayload(): Promise<TimePayload> {
+    return await this.timeSyncViewer.currentTimePayload()
   }
 }

package/src/blockViewerFromChainIteratorAndArchivist.ts

@@ -0,0 +1,61 @@
+import type { Hash } from '@xylabs/sdk-js'
+import { isDefined } from '@xylabs/sdk-js'
+import type { ReadArchivist } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type {
+  HydratedBlock,
+  XL1BlockNumber,
+} from '@xyo-network/xl1-protocol'
+import { asBlockBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { BlockViewer, EventingChainBlockNumberIteratorService } from '@xyo-network/xl1-protocol-sdk'
+
+export function blockViewerFromChainIteratorAndArchivist(
+  chainIterator: EventingChainBlockNumberIteratorService,
+  chainArchivist: ReadArchivist,
+): BlockViewer {
+  const result = {
+    blockByHash: async function (hash: Hash): Promise<HydratedBlock | null> {
+      const [payload] = await chainArchivist.get([hash])
+      const block = asBlockBoundWitnessWithStorageMeta(payload)
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes)
+        return [block, payloads]
+      }
+      return null
+    },
+    blockByNumber: async function (blockNumber: XL1BlockNumber): Promise<HydratedBlock | null> {
+      const payload = await chainIterator.get(blockNumber)
+      const block = payload ? await PayloadBuilder.addStorageMeta(payload) : undefined
+      if (isDefined(block)) {
+        const payloads = await chainArchivist.get(block.payload_hashes)
+        return [block, payloads]
+      }
+      return null
+    },
+    blocksByHash: async function (hash: Hash, limit = 10): Promise<HydratedBlock[]> {
+      const results: HydratedBlock[] = []
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByHash(hash)
+        if (block) {
+          results.push(block)
+        } else {
+          break
+        }
+      }
+      return results
+    },
+    currentBlock: async function (): Promise<HydratedBlock> {
+      const head = await chainIterator.head()
+      return this.blockByHash(head._hash) as Promise<HydratedBlock>
+    },
+    currentBlockHash: async function (): Promise<Hash> {
+      const head = await chainIterator.head()
+      return head._hash
+    },
+    currentBlockNumber: async function (): Promise<XL1BlockNumber> {
+      const head = await chainIterator.head()
+      return head.block
+    },
+  } satisfies BlockViewer
+  return result
+}

package/src/model/Params.ts

@@ -1,5 +1,4 @@
-import type { CreatableParams } from '@xylabs/creatable'
-import type { EmptyObject } from '@xylabs/object'
+import type { CreatableParams, EmptyObject } from '@xylabs/sdk-js'
 import type { AccountInstance } from '@xyo-network/account-model'
 import type { OpenTelemetryProviders } from '@xyo-network/xl1-protocol'
 

package/dist/neutral/AccountTransfers/accountTransfersServiceFromArchivist.d.ts

@@ -1,6 +0,0 @@
-import type { ReadArchivist } from '@xyo-network/archivist-model';
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model';
-import type { ChainId } from '@xyo-network/xl1-protocol';
-import type { AccountTransfersService } from '@xyo-network/xl1-protocol-sdk';
-export declare const accountTransfersServiceFromArchivist: (chainId: ChainId, archivist: ReadArchivist<WithStorageMeta<Payload>>) => Promise<AccountTransfersService>;
-//# sourceMappingURL=accountTransfersServiceFromArchivist.d.ts.map

package/dist/neutral/AccountTransfers/accountTransfersServiceFromArchivist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"accountTransfersServiceFromArchivist.d.ts","sourceRoot":"","sources":["../../../src/AccountTransfers/accountTransfersServiceFromArchivist.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAExD,OAAO,KAAK,EAAE,uBAAuB,EAAwB,MAAM,+BAA+B,CAAA;AAMlG,eAAO,MAAM,oCAAoC,GAC/C,SAAS,OAAO,EAChB,WAAW,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,KACjD,OAAO,CAAC,uBAAuB,CAsBjC,CAAA"}

package/src/AccountTransfers/accountTransfersServiceFromArchivist.ts

@@ -1,39 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { Hash } from '@xylabs/hex'
-import type { ReadArchivist } from '@xyo-network/archivist-model'
-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 { AccountTransfersService, TransfersStepSummary } from '@xyo-network/xl1-protocol-sdk'
-import { LruCacheMap, readPayloadMapFromStore } from '@xyo-network/xl1-protocol-sdk'
-import { Semaphore } from 'async-mutex'
-
-import { BaseAccountTransfersService } from './BaseAccountTransfersService.ts'
-
-export const accountTransfersServiceFromArchivist = async (
-  chainId: ChainId,
-  archivist: ReadArchivist<WithStorageMeta<Payload>>,
-): Promise<AccountTransfersService> => {
-  const summaryMap = new LruCacheMap<string, TransfersStepSummary>({
-    max: 100_000,
-    allowStale: true,
-    noDisposeOnSet: false,
-    updateAgeOnGet: true,
-  })
-  const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(archivist)
-  const headFunc = async (): Promise<[Hash, number]> => {
-    const head = await findMostRecentBlock(archivist)
-    return [assertEx(head?._hash, () => 'No head found in chainArchivist'), assertEx(head?.block, () => 'No head found in chainArchivist')]
-  }
-  const service = await BaseAccountTransfersService.create({
-    context: {
-      chainId,
-      store: { chainMap },
-      stepSemaphores: StepSizes.map(() => new Semaphore(20)),
-      summaryMap,
-      head: headFunc,
-    },
-  })
-  return service
-}