@xyo-network/chain-services 1.15.1 → 1.15.3

package/src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts

@@ -1,17 +1,17 @@
 import { assertEx } from '@xylabs/assert'
 import type { Hex } from '@xylabs/hex'
-import { isDefined, isNull } from '@xylabs/typeof'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import {
+  isDefined, isNull, isUndefined,
+} from '@xylabs/typeof'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, 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 type { PayloadMapRead } from '@xyo-network/xl1-protocol-sdk'
 import { LRUCache } from 'lru-cache'
 
 import { BaseService } from '../BaseService.ts'
@@ -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._currentHead?.chain ?? this.params?.head?.chain, () => 'Current head is not set') }
 
-  get chainId(): Hex { return assertEx(this.params.head?.chain) }
+  get chainMap(): PayloadMapRead<WithStorageMeta<Payload>> { return assertEx(this.params.chainMap) }
 
-  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
@@ -35,27 +36,33 @@ export class ChainBlockNumberIterationService extends BaseService<XyoChainIterat
     // 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)
+    let currentBlock = (await this.chainMap.get(currentBlockHash))
     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
         }
         const { previous } = currentBlock
         if (isNull(previous)) break
-        currentBlock = (await this.chainArchivist.get([previous])).at(0)
+        currentBlock = (await this.chainMap.get(previous))
       }
     }
     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()
-    while (currentBlock && results.length < count) {
-      if (isBlockBoundWitness(currentBlock)) {
+  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 (isDefined(currentBlock) && (results.length < count)) {
+      if (isBlockBoundWitnessWithHashStorageMeta(currentBlock)) {
         results.push(currentBlock)
-        const { previous } = currentBlock
+        const { previous } = currentBlock as BlockBoundWitness
         if (isNull(previous)) break
-        const nextBlock = await this.chainArchivist.get([previous])
-        currentBlock = asBlockBoundWitness(nextBlock[0])
+        const nextBlock = await this.chainMap.get(previous)
+        currentBlock = asBlockBoundWitnessWithStorageMeta(nextBlock)
       } 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.chainMap.get(hash))
+    const newHead = asBlockBoundWitnessWithStorageMeta(stored)
+    if (isUndefined(newHead)) throw new Error(`Head block not found in archivist [${hash}]`)
+    return newHead
   }
 }

package/src/ChainBlockNumberIteration/model/Params.ts

@@ -1,9 +1,10 @@
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
+import type { PayloadMapRead } from '@xyo-network/xl1-protocol-sdk'
 
 import type { BaseServiceParams } from '../../model/index.ts'
 
 export interface XyoChainIteratorParams extends BaseServiceParams {
-  chainArchivist: ArchivistInstance
+  chainMap: PayloadMapRead<WithStorageMeta<Payload>>
   head: BlockBoundWitness
 }

package/src/ChainValidator/XyoValidator.ts

@@ -6,7 +6,7 @@ import { ArchivistInstance, ReadArchivist } from '@xyo-network/archivist-model'
 import {
   BlockBoundWitness,
   BlockRewardService,
-  Chain,
+  ChainId,
   ElectionService,
   HydratedBlockStateValidationFunctionV2,
   SignedHydratedTransactionWithStorageMeta,
@@ -20,7 +20,7 @@ import { Validator } from './model/index.ts'
 export interface XyoValidatorParams extends BaseServiceParams {
   account: AccountInstance
   chainArchivist: ReadArchivist
-  chainId: Chain
+  chainId: ChainId
   electionService: ElectionService
   pendingBundledTransactionsArchivist: ArchivistInstance
   rewardService: BlockRewardService

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -2,7 +2,9 @@ import { creatable } from '@xylabs/creatable'
 import { Address } from '@xylabs/hex'
 import { Promisable } from '@xylabs/promise'
 import { ReadArchivist } from '@xyo-network/archivist-model'
-import { EventingChainBlockNumberIteratorService, NetworkStakeStepRewardService } from '@xyo-network/xl1-protocol'
+import {
+  EventingChainBlockNumberIteratorService, NetworkStakeStepRewardService, StepContext,
+} from '@xyo-network/xl1-protocol'
 import { Provider } from 'ethers'
 
 import { BaseService } from '../BaseService.ts'
@@ -16,55 +18,59 @@ export interface BaseNetworkStakeStepRewardServiceParams extends BaseServicePara
 
 @creatable()
 export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
-  claimedRewards(address: Address): Promisable<bigint> {
+  networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepAddressReward(address: Address, step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardAddressReward(_context: StepContext, _address: Address): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewardShares(step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardAddressShare(_context: StepContext, _address: Address): Promisable<[bigint, bigint]> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewards(step: number, block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardClaimedByAddress(_address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressHistory(address: Address): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardForStep(_context: StepContext): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressShare(address: Address, step: number, block: number): Promisable<[bigint, bigint]> {
+  networkStakeStepRewardForStepForPosition(_context: StepContext, _position: number): Promisable<[bigint, bigint]> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardForStep(step: number): Promisable<bigint> {
+  networkStakeStepRewardPoolRewards(_context: StepContext): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPositionWeight(position: bigint, step: number): Promisable<number> {
+  networkStakeStepRewardPoolShares(_context: StepContext): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPotentialPositionLoss(position: bigint, step: number): Promisable<bigint> {
+  networkStakeStepRewardPositionWeight(_context: StepContext, _position: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardRandomizer(step: number, block: number): Promisable<bigint> {
+  networkStakeStepRewardPotentialPositionLoss(_context: StepContext, _position: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardStakerCount(step: number, block: number): Promisable<number> {
+  networkStakeStepRewardRandomizer(_context: StepContext): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardWeightForAddress(address: Address, step: number): Promisable<bigint> {
+  networkStakeStepRewardStakerCount(_context: StepContext): Promisable<number> {
     throw new Error('Method not implemented.')
   }
 
-  unclaimedRewards(address: Address): Promisable<bigint> {
+  networkStakeStepRewardUnclaimedByAddress(_address: Address): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardWeightForAddress(_context: StepContext, _address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 }

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -13,7 +13,7 @@ import {
   Payload, PayloadBundle, Sequence, WithStorageMeta,
 } from '@xyo-network/payload-model'
 import {
-  asBlockBoundWitnessWithHashStorageMeta, Chain, isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
+  asBlockBoundWitnessWithHashStorageMeta, ChainId, isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
   SignedHydratedTransactionWithStorageMeta,
 } from '@xyo-network/xl1-protocol'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
@@ -26,7 +26,7 @@ import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPaylo
 
 export interface BasePendingTransactionsServiceParams extends BaseServiceParams {
   chainArchivist?: ArchivistInstance
-  chainId?: Chain
+  chainId?: ChainId
   pendingBundledTransactionsArchivist?: ArchivistInstance
   rejectedTransactionsArchivist?: ArchivistInstance
 }

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -25,6 +25,7 @@ import {
   isChainIndexingServiceState,
   StakeIntentService,
 } from '@xyo-network/xl1-protocol'
+import { readPayloadMapFromStore } from '@xyo-network/xl1-protocol-sdk'
 import { Mutex } from 'async-mutex'
 import { LRUCache } from 'lru-cache'
 
@@ -206,7 +207,8 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
         const currentHead = await this.chainIterator.head()
         if (isUndefined(currentHead)) return
         const currentHeadHash = await PayloadBuilder.hash(currentHead)
-        const result = await analyzeChain(this.chainArchivist, [new ChainStakeIntentAnalyzer('producer')], currentHeadHash, this._lastIndexedBlockHash)
+        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