@xyo-network/chain-services 1.16.9 → 1.16.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.16.9",
+  "version": "1.16.10",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -37,53 +37,53 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
-    "@xylabs/array": "~5.0.24",
-    "@xylabs/assert": "~5.0.24",
-    "@xylabs/creatable": "~5.0.24",
-    "@xylabs/decimal-precision": "~5.0.24",
-    "@xylabs/events": "~5.0.24",
-    "@xylabs/exists": "~5.0.24",
-    "@xylabs/forget": "~5.0.24",
-    "@xylabs/hex": "~5.0.24",
-    "@xylabs/object": "~5.0.24",
-    "@xylabs/promise": "~5.0.24",
-    "@xylabs/telemetry": "~5.0.24",
-    "@xylabs/typeof": "~5.0.24",
+    "@xylabs/array": "~5.0.25",
+    "@xylabs/assert": "~5.0.25",
+    "@xylabs/creatable": "~5.0.25",
+    "@xylabs/decimal-precision": "~5.0.25",
+    "@xylabs/events": "~5.0.25",
+    "@xylabs/exists": "~5.0.25",
+    "@xylabs/forget": "~5.0.25",
+    "@xylabs/hex": "~5.0.25",
+    "@xylabs/object": "~5.0.25",
+    "@xylabs/promise": "~5.0.25",
+    "@xylabs/telemetry": "~5.0.25",
+    "@xylabs/typeof": "~5.0.25",
     "@xyo-network/account-model": "~5.1.21",
     "@xyo-network/archivist-memory": "~5.1.21",
     "@xyo-network/archivist-model": "~5.1.21",
     "@xyo-network/boundwitness-model": "~5.1.21",
     "@xyo-network/boundwitness-validator": "~5.1.21",
     "@xyo-network/boundwitness-wrapper": "~5.1.21",
-    "@xyo-network/chain-analyze": "~1.16.9",
-    "@xyo-network/chain-modules": "~1.16.9",
-    "@xyo-network/chain-protocol": "~1.16.9",
-    "@xyo-network/chain-utils": "~1.16.9",
+    "@xyo-network/chain-analyze": "~1.16.10",
+    "@xyo-network/chain-modules": "~1.16.10",
+    "@xyo-network/chain-protocol": "~1.16.10",
+    "@xyo-network/chain-utils": "~1.16.10",
     "@xyo-network/payload-builder": "~5.1.21",
     "@xyo-network/payload-model": "~5.1.21",
     "@xyo-network/typechain": "~4.0.10",
-    "@xyo-network/xl1-protocol": "~1.13.6",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.9",
-    "@xyo-network/xl1-validation": "~1.16.9",
-    "@xyo-network/xl1-wrappers": "~1.16.9",
+    "@xyo-network/xl1-protocol": "~1.13.11",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.10",
+    "@xyo-network/xl1-validation": "~1.16.10",
+    "@xyo-network/xl1-wrappers": "~1.16.10",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "~11.2.2"
   },
   "devDependencies": {
     "@types/node": "~24.10.1",
-    "@xylabs/delay": "~5.0.24",
+    "@xylabs/delay": "~5.0.25",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.24",
+    "@xylabs/vitest-extended": "~5.0.25",
     "@xyo-network/account": "~5.1.21",
     "@xyo-network/account-model": "~5.1.21",
-    "@xyo-network/chain-validation": "~1.16.9",
+    "@xyo-network/chain-validation": "~1.16.10",
     "@xyo-network/wallet": "~5.1.21",
     "eslint": "^9.39.1",
     "tslib": "~2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.8",
+    "vitest": "~4.0.9",
     "vitest-mock-extended": "~3.1.0",
     "web3-types": "~1.10.0"
   },

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,31 +1,45 @@
 import { creatable } from '@xylabs/creatable'
 import { Address, Hash } from '@xylabs/hex'
-import { Promisable } from '@xylabs/promise'
 import { spanRootAsync } from '@xylabs/telemetry'
+import { ReadArchivist } from '@xyo-network/archivist-model'
 import { AttoXL1, XL1BlockRange } from '@xyo-network/xl1-protocol'
 import {
   AccountBalanceHistoryItem,
   AccountBalanceService,
   balancesSummary,
   BalanceStepSummaryContext,
+  BlockViewer,
+  EventingChainBlockNumberIteratorService,
+  SimpleAccountBalanceViewer,
+  TransfersStepSummaryContext,
 } from '@xyo-network/xl1-protocol-sdk'
 
 import { BaseService } from '../BaseService.ts'
+import { blockViewerFromChainIteratorAndArchivist } from '../blockViewerFromChainIteratorAndArchivist.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
 export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
+  chainArchivist: ReadArchivist
+  chainIterator: EventingChainBlockNumberIteratorService
   context: BalanceStepSummaryContext
+  transferContext: TransfersStepSummaryContext
 }
 
 @creatable()
 export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceService {
+  protected accountBalanceViewer!: AccountBalanceService
+  protected blockViewer!: BlockViewer
+
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
     const balances = await this.accountBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
-  accountBalanceHistory(_address: Address, _headOrRange?: XL1BlockRange | Hash): Promisable<AccountBalanceHistoryItem[]> {
-    throw new Error('Method not implemented.')
+  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)
   }
 
   async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
@@ -42,7 +56,19 @@ export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceSer
     })
   }
 
-  accountBalancesHistories(_address: Address[], _headOrRange?: XL1BlockRange | Hash): Promisable<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    throw new Error('Method not implemented.')
+  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)
+  }
+
+  override createHandler() {
+    this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist)
+    this.accountBalanceViewer = new SimpleAccountBalanceViewer(
+      this.params.context,
+      this.params.transferContext,
+      this.blockViewer,
+    )
   }
 }

package/src/AccountTransfers/index.ts

@@ -1,2 +1 @@
-export * from './accountTransfersServiceFromArchivist.ts'
 export * from './BaseAccountTransfersService.ts'

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -3,7 +3,7 @@ import { assertEx } from '@xylabs/assert'
 import { creatable } from '@xylabs/creatable'
 import { exists } from '@xylabs/exists'
 import {
-  Address, Hex, hexToBigInt, toHex,
+  Address, asHash, Hex, hexToBigInt, toHex,
 } from '@xylabs/hex'
 import { isDefined } from '@xylabs/typeof'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
@@ -277,7 +277,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
 
   private async generateTimePayload(head: WithStorageMeta<BlockBoundWitness>) {
     const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash('ethereum')
-    const ethereumHash = assertEx(ethHashOrNull, () => 'No ethereum hash available from time sync service')
+    const ethereumHash = asHash(ethHashOrNull, () => 'No ethereum hash available from time sync service')
     const timePayload: TimePayload = {
       schema: TimeSchema,
       // note, this is for the previous block

package/src/BlockProducer/spec/BaseBlockProducerService.spec.ts

@@ -1,4 +1,3 @@
-/* eslint-disable max-statements */
 import '@xylabs/vitest-extended'
 
 import { filterAs } from '@xylabs/array'
@@ -287,10 +286,8 @@ describe('XyoBlockProducer', () => {
             expect(blockRewardTransfer).toBeDefined()
             let totalTransfer = 0n
             for (const value of Object.values(blockRewardTransfer?.transfers ?? {})) {
-              if (value) {
-                const bigIntValue = hexToBigInt(value)
-                totalTransfer += bigIntValue
-              }
+              const bigIntValue = hexToBigInt(value)
+              totalTransfer += bigIntValue
             }
             expect(totalTransfer).toEqual(3_000_000_000_000_000_000_000n)
           }

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -94,14 +94,14 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
 
   async getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>> {
     await Promise.resolve()
-    assertEx(intent === 'producer', () => `Error: Support not yet added for intent ${intent}`)
+    assertEx(intent === 'producer', () => `Support not yet added for intent ${intent}`)
     const results = this._producers.get(address)
     return results ?? []
   }
 
   async getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]> {
     return await this.spanAsync('getDeclaredCandidatesForBlock', async () => {
-      assertEx(intent === 'producer', () => `Error: Support not yet added for intent ${intent}`)
+      assertEx(intent === 'producer', () => `Support not yet added for intent ${intent}`)
       const results = this._producers.findAllContaining(block)
       const candidates = [...results]
       const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent)

package/src/Time/BaseTimeSyncService.ts

@@ -1,24 +1,16 @@
-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 { 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 +19,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/hex'
+import { isDefined } from '@xylabs/typeof'
+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/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
-}