@xyo-network/chain-services 1.15.1 → 1.15.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.15.1",
+  "version": "1.15.2",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -48,26 +48,26 @@
     "@xylabs/promise": "~5.0.11",
     "@xylabs/telemetry": "~5.0.11",
     "@xylabs/typeof": "~5.0.11",
-    "@xyo-network/account-model": "~5.1.2",
-    "@xyo-network/archivist-memory": "~5.1.2",
-    "@xyo-network/archivist-model": "~5.1.2",
-    "@xyo-network/boundwitness-model": "~5.1.2",
-    "@xyo-network/boundwitness-validator": "~5.1.2",
-    "@xyo-network/boundwitness-wrapper": "~5.1.2",
-    "@xyo-network/chain-analyze": "~1.15.1",
-    "@xyo-network/chain-modules": "~1.15.1",
-    "@xyo-network/chain-protocol": "~1.15.1",
-    "@xyo-network/chain-utils": "~1.15.1",
-    "@xyo-network/payload-builder": "~5.1.2",
-    "@xyo-network/payload-model": "~5.1.2",
+    "@xyo-network/account-model": "~5.1.3",
+    "@xyo-network/archivist-memory": "~5.1.3",
+    "@xyo-network/archivist-model": "~5.1.3",
+    "@xyo-network/boundwitness-model": "~5.1.3",
+    "@xyo-network/boundwitness-validator": "~5.1.3",
+    "@xyo-network/boundwitness-wrapper": "~5.1.3",
+    "@xyo-network/chain-analyze": "~1.15.2",
+    "@xyo-network/chain-modules": "~1.15.2",
+    "@xyo-network/chain-protocol": "~1.15.2",
+    "@xyo-network/chain-utils": "~1.15.2",
+    "@xyo-network/payload-builder": "~5.1.3",
+    "@xyo-network/payload-model": "~5.1.3",
     "@xyo-network/typechain": "~4.0.8",
-    "@xyo-network/xl1-protocol": "~1.12.33",
-    "@xyo-network/xl1-protocol-sdk": "~1.15.1",
-    "@xyo-network/xl1-validation": "~1.15.1",
-    "@xyo-network/xl1-wrappers": "~1.15.1",
+    "@xyo-network/xl1-protocol": "~1.12.40",
+    "@xyo-network/xl1-protocol-sdk": "~1.15.2",
+    "@xyo-network/xl1-validation": "~1.15.2",
+    "@xyo-network/xl1-wrappers": "~1.15.2",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
-    "lru-cache": "~11.2.1"
+    "lru-cache": "~11.2.2"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
@@ -75,10 +75,10 @@
     "@xylabs/ts-scripts-yarn3": "~7.1.7",
     "@xylabs/tsconfig": "~7.1.7",
     "@xylabs/vitest-extended": "~5.0.11",
-    "@xyo-network/account": "~5.1.2",
-    "@xyo-network/account-model": "~5.1.2",
-    "@xyo-network/chain-validation": "~1.15.1",
-    "@xyo-network/wallet": "~5.1.2",
+    "@xyo-network/account": "~5.1.3",
+    "@xyo-network/account-model": "~5.1.3",
+    "@xyo-network/chain-validation": "~1.15.2",
+    "@xyo-network/wallet": "~5.1.3",
     "eslint": "^9.36.0",
     "tslib": "~2.8.1",
     "typescript": "~5.9.2",

package/src/AccountTransfers/BaseAccountTransfersService.ts

@@ -1,6 +1,5 @@
 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 {

package/src/ChainBlockIteration/ChainBlockNumberIterationService.ts

@@ -0,0 +1,108 @@
+import { assertEx } from '@xylabs/assert'
+import type { Hex } from '@xylabs/hex'
+import {
+  isDefined, isNull, isUndefined,
+} from '@xylabs/typeof'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
+import type {
+  BlockBoundWitness,
+  ChainIteratorServiceEventData,
+  EventingChainBlockNumberIteratorService,
+} from '@xyo-network/xl1-protocol'
+import {
+  asBlockBoundWitness,
+  asBlockBoundWitnessWithStorageMeta,
+  isBlockBoundWitness,
+} from '@xyo-network/xl1-protocol'
+import { LRUCache } from 'lru-cache'
+
+import { BaseService } from '../BaseService.ts'
+import type { XyoChainIteratorParams } from './model/index.ts'
+
+export class ChainBlockNumberIterationService extends BaseService<XyoChainIteratorParams, ChainIteratorServiceEventData>
+  implements EventingChainBlockNumberIteratorService {
+  protected _blocksByBlockNumber = new LRUCache<number, WithStorageMeta<BlockBoundWitness>>({ max: 10_000 })
+  protected _currentHead: WithStorageMeta<BlockBoundWitness> | undefined
+
+  get chainArchivist(): ArchivistInstance { return assertEx(this.params.chainArchivist) }
+
+  get chainId(): Hex { return assertEx(this._currentHead?.chain ?? this.params?.head?.chain, () => 'Current head is not set') }
+
+  async get(block: number): Promise<WithStorageMeta<BlockBoundWitness>> {
+    const head = await this.head()
+    // if(isUndefined(head)) return undefined
+    // Bail early if the block requested is newer than the current head
+    assertEx(head.block >= block, () => `Block requested is newer than the current head [${block}]`)
+    const cached = this._blocksByBlockNumber.get(block)
+    if (cached) return cached
+    // Start at the current head and traverse backwards until the requested block is found
+    const startingBlock = head
+    const currentBlockHash = await PayloadBuilder.hash(startingBlock)
+    let currentBlock = (await this.chainArchivist.get([currentBlockHash])).at(0)
+    while (isDefined(currentBlock)) {
+      assertEx(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`)
+      if (isBlockBoundWitness(currentBlock)) {
+        this._blocksByBlockNumber.set(currentBlock.block, currentBlock)
+        if (currentBlock.block === block) {
+          return currentBlock
+        }
+        const { previous } = currentBlock
+        if (isNull(previous)) break
+        currentBlock = (await this.chainArchivist.get([previous])).at(0)
+      }
+    }
+    throw new Error(`Block not found: ${block}`)
+  }
+
+  async head(): Promise<WithStorageMeta<BlockBoundWitness>> {
+    if (isDefined(this._currentHead)) return this._currentHead
+    if (isDefined(this.params.head)) {
+      const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head)
+      this._currentHead = newHead
+      return newHead
+    }
+    throw new Error('Head is not set')
+  }
+
+  async next(block: number): Promise<WithStorageMeta<BlockBoundWitness> | undefined> {
+    const currentBlock = block
+    const nextBlockNumber = currentBlock + 1
+    return await this.get(nextBlockNumber)
+  }
+
+  // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
+  // and then communicate via method name and documentation
+  async previous(block: number | undefined = undefined, count: number = 1): Promise<WithStorageMeta<BlockBoundWitness>[]> {
+    const results: WithStorageMeta<BlockBoundWitness>[] = []
+    let currentBlock: WithStorageMeta<BlockBoundWitness> | undefined = isDefined(block) ? (await this.get(block)) : await this.head()
+    while (currentBlock && results.length < count) {
+      if (isBlockBoundWitness(currentBlock)) {
+        results.push(currentBlock)
+        const { previous } = currentBlock
+        if (isNull(previous)) break
+        const nextBlock = await this.chainArchivist.get([previous])
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock[0])
+      } else {
+        const hash = PayloadBuilder.hash(currentBlock)
+        assertEx(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`)
+      }
+    }
+    return results
+  }
+
+  async updateHead(head: BlockBoundWitness): Promise<void> {
+    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head)
+    this._currentHead = newHead
+    void this.emit('headUpdated', { blocks: [newHead] })
+  }
+
+  private async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head: BlockBoundWitness): Promise<WithStorageMeta<BlockBoundWitness>> {
+    const hash = await PayloadBuilder.hash(head)
+    const stored = (await this.chainArchivist.get([hash])).at(-1)
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored)
+    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`)
+    return newHead
+  }
+}

package/src/ChainBlockIteration/index.ts

@@ -0,0 +1,2 @@
+export * from './ChainBlockNumberIterationService.ts'
+export * from './model/index.ts'

package/src/ChainBlockIteration/model/BlockNumberIteration.ts

@@ -0,0 +1,7 @@
+import type { Promisable } from '@xylabs/promise'
+import type { BlockBoundWitness, SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
+
+export interface BlockNumberIteration {
+  validatePendingBlock(block: BlockBoundWitness): Promisable<Error[]>
+  validatePendingTransaction(tx: SignedHydratedTransactionWithStorageMeta): Promise<boolean>
+}

package/src/ChainBlockIteration/model/Params.ts

@@ -0,0 +1,9 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
+
+import type { BaseServiceParams } from '../../model/index.ts'
+
+export interface XyoChainIteratorParams extends BaseServiceParams {
+  chainArchivist: ArchivistInstance
+  head: BlockBoundWitness
+}

package/src/ChainBlockIteration/model/index.ts

@@ -0,0 +1,2 @@
+export * from './BlockNumberIteration.ts'
+export * from './Params.ts'

package/src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts

@@ -1,16 +1,16 @@
 import { assertEx } from '@xylabs/assert'
 import type { Hex } from '@xylabs/hex'
-import { isDefined, isNull } from '@xylabs/typeof'
+import {
+  isDefined, isNull, isUndefined,
+} from '@xylabs/typeof'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { WithStorageMeta } from '@xyo-network/payload-model'
 import type {
-  BlockBoundWitness,
-  ChainIteratorServiceEventData,
-  EventingChainBlockNumberIteratorService,
+  BlockBoundWitness, ChainIteratorServiceEventData, EventingChainBlockNumberIteratorService,
 } from '@xyo-network/xl1-protocol'
 import {
-  asBlockBoundWitness,
-  isBlockBoundWitness,
+  asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashStorageMeta,
 } from '@xyo-network/xl1-protocol'
 import { LRUCache } from 'lru-cache'
 
@@ -19,13 +19,14 @@ import type { XyoChainIteratorParams } from './model/index.ts'
 
 export class ChainBlockNumberIterationService extends BaseService<XyoChainIteratorParams, ChainIteratorServiceEventData>
   implements EventingChainBlockNumberIteratorService {
-  protected _blocksByBlockNumber = new LRUCache<number, BlockBoundWitness>({ max: 10_000 })
+  protected _blocksByBlockNumber = new LRUCache<number, WithStorageMeta<BlockBoundWitness>>({ max: 10_000 })
+  protected _currentHead: WithStorageMeta<BlockBoundWitness> | undefined
 
   get chainArchivist(): ArchivistInstance { return assertEx(this.params.chainArchivist) }
 
-  get chainId(): Hex { return assertEx(this.params.head?.chain) }
+  get chainId(): Hex { return assertEx(this._currentHead?.chain ?? this.params?.head?.chain, () => 'Current head is not set') }
 
-  async get(block: number): Promise<BlockBoundWitness> {
+  async get(block: number): Promise<WithStorageMeta<BlockBoundWitness>> {
     const head = await this.head()
     // if(isUndefined(head)) return undefined
     // Bail early if the block requested is newer than the current head
@@ -38,7 +39,7 @@ export class ChainBlockNumberIterationService extends BaseService<XyoChainIterat
     let currentBlock = (await this.chainArchivist.get([currentBlockHash])).at(0)
     while (isDefined(currentBlock)) {
       assertEx(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${currentBlock?._hash}]`)
-      if (isBlockBoundWitness(currentBlock)) {
+      if (isBlockBoundWitnessWithHashStorageMeta(currentBlock)) {
         this._blocksByBlockNumber.set(currentBlock.block, currentBlock)
         if (currentBlock.block === block) {
           return currentBlock
@@ -51,11 +52,17 @@ export class ChainBlockNumberIterationService extends BaseService<XyoChainIterat
     throw new Error(`Block not found: ${block}`)
   }
 
-  async head(): Promise<BlockBoundWitness> {
-    return await Promise.resolve(assertEx(this.params.head))
+  async head(): Promise<WithStorageMeta<BlockBoundWitness>> {
+    if (isDefined(this._currentHead)) return this._currentHead
+    if (isDefined(this.params.head)) {
+      const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(this.params.head)
+      this._currentHead = newHead
+      return newHead
+    }
+    throw new Error('Head is not set')
   }
 
-  async next(block: number): Promise<BlockBoundWitness | undefined> {
+  async next(block: number): Promise<WithStorageMeta<BlockBoundWitness> | undefined> {
     const currentBlock = block
     const nextBlockNumber = currentBlock + 1
     return await this.get(nextBlockNumber)
@@ -63,28 +70,35 @@ export class ChainBlockNumberIterationService extends BaseService<XyoChainIterat
 
   // TODO: Decide on inclusive/exclusive (probably need inclusive to account for chain head)
   // and then communicate via method name and documentation
-  async previous(block: number | undefined = undefined, count: number = 1): Promise<BlockBoundWitness[]> {
-    const results: BlockBoundWitness[] = []
-    let currentBlock: BlockBoundWitness | undefined = isDefined(block) ? (await this.get(block)) : await this.head()
+  async previous(block: number | undefined = undefined, count: number = 1): Promise<WithStorageMeta<BlockBoundWitness>[]> {
+    const results: WithStorageMeta<BlockBoundWitness>[] = []
+    let currentBlock: WithStorageMeta<BlockBoundWitness> | undefined = isDefined(block) ? (await this.get(block)) : await this.head()
     while (currentBlock && results.length < count) {
-      if (isBlockBoundWitness(currentBlock)) {
+      if (isBlockBoundWitnessWithHashStorageMeta(currentBlock)) {
         results.push(currentBlock)
         const { previous } = currentBlock
         if (isNull(previous)) break
         const nextBlock = await this.chainArchivist.get([previous])
-        currentBlock = asBlockBoundWitness(nextBlock[0])
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock[0])
       } else {
         const hash = PayloadBuilder.hash(currentBlock)
-        assertEx(asBlockBoundWitness(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`)
+        assertEx(asBlockBoundWitnessWithStorageMeta(currentBlock), () => `Expected hash to be a block bound witness [${hash}]`)
       }
     }
     return results
   }
 
   async updateHead(head: BlockBoundWitness): Promise<void> {
-    // Async to allow for re-indexing, etc.
-    await Promise.resolve()
-    this.params.head = head
-    void this.emit('headUpdated', { blocks: [head] })
+    const newHead = await this.getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head)
+    this._currentHead = newHead
+    void this.emit('headUpdated', { blocks: [newHead] })
+  }
+
+  private async getBoundWitnessAsBlockBoundWitnessWithStorageMeta(head: BlockBoundWitness): Promise<WithStorageMeta<BlockBoundWitness>> {
+    const hash = await PayloadBuilder.hash(head)
+    const stored = (await this.chainArchivist.get([hash])).at(-1)
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored)
+    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`)
+    return newHead
   }
 }

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -16,55 +16,55 @@ export interface BaseNetworkStakeStepRewardServiceParams extends BaseServicePara
 
 @creatable()
 export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
-  claimedRewards(address: Address): Promisable<bigint> {
+  claimedRewards(_address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepAddressReward(address: Address, step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepAddressReward(_address: Address, _step: number, _block: number): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewardShares(step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepPoolRewardShares(_step: number, _block: number): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewards(step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepPoolRewards(_step: number, _block: number): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressHistory(address: Address): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressShare(address: Address, step: number, block: number): Promisable<[bigint, bigint]> {
+  networkStakeStepRewardAddressShare(_address: Address, _step: number, _block: number): Promisable<[bigint, bigint]> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardForStep(step: number): Promisable<bigint> {
+  networkStakeStepRewardForStep(_step: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPositionWeight(position: bigint, step: number): Promisable<number> {
+  networkStakeStepRewardPositionWeight(_position: bigint, _step: number): Promisable<number> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPotentialPositionLoss(position: bigint, step: number): Promisable<bigint> {
+  networkStakeStepRewardPotentialPositionLoss(_position: bigint, _step: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardRandomizer(step: number, block: number): Promisable<bigint> {
+  networkStakeStepRewardRandomizer(_step: number, _block: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardStakerCount(step: number, block: number): Promisable<number> {
+  networkStakeStepRewardStakerCount(_step: number, _block: number): Promisable<number> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardWeightForAddress(address: Address, step: number): Promisable<bigint> {
+  networkStakeStepRewardWeightForAddress(_address: Address, _step: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  unclaimedRewards(address: Address): Promisable<bigint> {
+  unclaimedRewards(_address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 }