@xyo-network/chain-services 1.16.23 → 1.16.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.16.23",
+  "version": "1.16.25",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -40,43 +40,44 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
-    "@xylabs/sdk-js": "~5.0.39",
-    "@xylabs/telemetry": "~5.0.39",
-    "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/archivist-memory": "~5.1.24",
-    "@xyo-network/archivist-model": "~5.1.24",
-    "@xyo-network/boundwitness-model": "~5.1.24",
-    "@xyo-network/boundwitness-validator": "~5.1.24",
-    "@xyo-network/boundwitness-wrapper": "~5.1.24",
-    "@xyo-network/chain-analyze": "~1.16.23",
-    "@xyo-network/chain-modules": "~1.16.23",
-    "@xyo-network/chain-protocol": "~1.16.23",
-    "@xyo-network/chain-utils": "~1.16.23",
-    "@xyo-network/payload-builder": "~5.1.24",
-    "@xyo-network/payload-model": "~5.1.24",
+    "@xylabs/sdk-js": "~5.0.42",
+    "@xylabs/telemetry": "~5.0.42",
+    "@xyo-network/account-model": "~5.2.10",
+    "@xyo-network/archivist-memory": "~5.2.10",
+    "@xyo-network/archivist-model": "~5.2.10",
+    "@xyo-network/boundwitness-model": "~5.2.10",
+    "@xyo-network/boundwitness-validator": "~5.2.10",
+    "@xyo-network/boundwitness-wrapper": "~5.2.10",
+    "@xyo-network/chain-analyze": "~1.16.25",
+    "@xyo-network/chain-modules": "~1.16.25",
+    "@xyo-network/chain-protocol": "~1.16.25",
+    "@xyo-network/chain-utils": "~1.16.25",
+    "@xyo-network/payload-builder": "~5.2.10",
+    "@xyo-network/payload-model": "~5.2.10",
     "@xyo-network/typechain": "~4.0.10",
-    "@xyo-network/xl1-protocol": "~1.13.13",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.23",
-    "@xyo-network/xl1-validation": "~1.16.23",
-    "@xyo-network/xl1-wrappers": "~1.16.23",
+    "@xyo-network/xl1-protocol": "~1.14.13",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.25",
+    "@xyo-network/xl1-validation": "~1.16.25",
+    "@xyo-network/xl1-wrappers": "~1.16.25",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
-    "lru-cache": "~11.2.2"
+    "lru-cache": "~11.2.2",
+    "zod": "~4.1.12"
   },
   "devDependencies": {
     "@types/node": "~24.10.1",
-    "@xylabs/sdk-js": "~5.0.39",
+    "@xylabs/sdk-js": "~5.0.42",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.39",
-    "@xyo-network/account": "~5.1.24",
-    "@xyo-network/account-model": "~5.1.24",
-    "@xyo-network/chain-validation": "~1.16.23",
-    "@xyo-network/wallet": "~5.1.24",
+    "@xylabs/vitest-extended": "~5.0.42",
+    "@xyo-network/account": "~5.2.10",
+    "@xyo-network/account-model": "~5.2.10",
+    "@xyo-network/chain-validation": "~1.16.25",
+    "@xyo-network/wallet": "~5.2.10",
     "eslint": "^9.39.1",
     "tslib": "~2.8.1",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.10",
+    "vitest": "~4.0.13",
     "vitest-mock-extended": "~3.1.0",
     "web3-types": "~1.10.0"
   },

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,6 +1,5 @@
 import {
-  Address, creatable, Hash,
-  Promisable,
+  Address, assertEx, creatable, Hash,
 } from '@xylabs/sdk-js'
 import { spanRootAsync } from '@xylabs/telemetry'
 import { ReadArchivist } from '@xyo-network/archivist-model'
@@ -15,12 +14,21 @@ import {
   SimpleAccountBalanceViewer,
   TransfersStepSummaryContext,
 } from '@xyo-network/xl1-protocol-sdk'
+import z from 'zod'
 
 import { BaseService } from '../BaseService.ts'
-import { blockViewerFromChainIteratorAndArchivist } from '../blockViewerFromChainIteratorAndArchivist.ts'
 import { BaseServiceParams } from '../model/index.ts'
 
+export const BaseAccountBalanceServiceParamsZod = z.object({
+  blockViewer: z.object().loose(),
+  chainArchivist: z.object().loose(),
+  chainIterator: z.object().loose(),
+  context: z.object().loose(),
+  transferContext: z.object().loose(),
+})
+
 export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
+  blockViewer: BlockViewer
   chainArchivist: ReadArchivist
   chainIterator: EventingChainBlockNumberIteratorService
   context: BalanceStepSummaryContext
@@ -30,24 +38,41 @@ export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
 @creatable()
 export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceViewer {
   protected accountBalanceViewer!: AccountBalanceViewer
-  protected blockViewer!: BlockViewer
+
+  protected get blockViewer() {
+    return assertEx(this.params.blockViewer, () => 'BlockViewer has not been initialized yet')
+  }
+
+  static override async paramsHandler(params?: Partial<BaseAccountBalanceServiceParams> | undefined): Promise<BaseAccountBalanceServiceParams> {
+    // TODO: Use a real zod and move the zod check to the AbstractCreatable class
+    BaseAccountBalanceServiceParamsZod.parse(params)
+    assertEx(params?.context?.head, () => 'BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams')
+    return { ...(await super.paramsHandler(params)), ...params } as BaseAccountBalanceServiceParams
+  }
 
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountBalances([address], headOrRange)
+    const balances = await this.accountsBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
   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)
+  accountBalanceHistory(_address: Address, _headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
+    throw new Error('Method not implemented.')
   }
 
-  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
+  async accountsBalances(address: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
     return await spanRootAsync('balances', async () => {
+      const context = {
+        head: this.params.context.head,
+        stepSemaphores: this.params.context.stepSemaphores,
+        store: this.params.context.store,
+        chainId: this.params.context.chainId,
+        summaryMap: this.params.context.summaryMap,
+      } satisfies BalanceStepSummaryContext
       const summary = await balancesSummary(
-        this.params.context,
+        context,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {
@@ -58,23 +83,18 @@ export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceSer
     })
   }
 
-  accountsBalances(address: Address[], headOrRange?: Hash | XL1BlockRange): Promisable<Partial<Record<Address, AttoXL1>>> {
-    throw new Error('Method not implemented.')
-  }
-
   async accountsBalancesHistory(addresses: Address[]): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
   async accountsBalancesHistory(addresses: Address[], head: Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
   async accountsBalancesHistory(addresses: Address[], range: XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountsBalancesHistory(addresses: Address[], headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    return await this.accountBalanceViewer.accountsBalancesHistory(addresses, headOrRange)
+  accountsBalancesHistory(_addresses: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
+    throw new Error('Method not implemented.')
   }
 
-  override createHandler() {
-    this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist)
-    this.accountBalanceViewer = new SimpleAccountBalanceViewer(
-      this.params.context,
-      this.params.transferContext,
-      this.blockViewer,
-    )
+  override async createHandler() {
+    this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
+      context: this.params.context,
+      transferContext: this.params.transferContext,
+      blockViewer: this.blockViewer,
+    })
   }
 }

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -1,11 +1,6 @@
 /* eslint-disable max-statements */
 import {
-  Address, asHash, assertEx, creatable,
-  exists,
-  Hex,
-  hexToBigInt,
-  isDefined,
-  toHex,
+  Address, AddressZod, asHash, assertEx, creatable, exists, Hex, hexToBigInt, isDefined, toHex,
 } from '@xylabs/sdk-js'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
@@ -13,16 +8,16 @@ import {
 } from '@xyo-network/chain-modules'
 import { buildNextBlock, createDeclarationIntent } from '@xyo-network/chain-protocol'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { WithStorageMeta } from '@xyo-network/payload-model'
+import { WithHashMeta } from '@xyo-network/payload-model'
 import {
-  AllowedBlockPayload,
-  asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumberPayload, BlockNumberSchema,
-  ChainStakeIntent, defaultRewardRatio, HydratedBlock, SignedHydratedTransaction, TimePayload, TimeSchema,
+  AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumberPayload, BlockNumberSchema,
+  ChainStakeIntent, defaultRewardRatio, HydratedBlockWithHashMeta, SignedHydratedTransaction, TimePayload, TimeSchema,
   Transfer, XYO_STEP_REWARD_ADDRESS,
 } from '@xyo-network/xl1-protocol'
 import {
   AccountBalanceViewer, BlockProducerService, Config, PendingTransactionsService, StakeIntentService, TimeSyncViewer,
 } from '@xyo-network/xl1-protocol-sdk'
+import z from 'zod'
 
 import { BaseService } from '../BaseService.ts'
 import { XyoValidatorParams } from '../ChainValidator/index.ts'
@@ -44,6 +39,14 @@ export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
  */
 export const XYO_PRODUCER_REDECLARATION_WINDOW = 500
 
+export const BaseBlockProducerServiceParamsZod = z.object({
+  balanceService: z.object().loose(),
+  pendingTransactionsService: z.object().loose(),
+  rejectedTransactionsArchivist: z.object().loose(),
+  rewardAddress: AddressZod,
+  time: z.object().loose(),
+})
+
 export interface BaseBlockProducerServiceParams extends XyoValidatorParams<Pick<Config, 'producer'>> {
   balanceService: AccountBalanceViewer
   pendingTransactionsService: PendingTransactionsService
@@ -131,7 +134,13 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
   }
 
-  async next(head: WithStorageMeta<BlockBoundWitness>): Promise<HydratedBlock | undefined> {
+  static override async paramsHandler(params?: Partial<BaseBlockProducerServiceParams> | undefined): Promise<BaseBlockProducerServiceParams> {
+    // TODO: Use a real zod and move the zod check to the AbstractCreatable class
+    BaseBlockProducerServiceParamsZod.parse(params)
+    return { ...(await super.paramsHandler(params)), ...params } as BaseBlockProducerServiceParams
+  }
+
+  async next(head: WithHashMeta<BlockBoundWitness>): Promise<HydratedBlockWithHashMeta | undefined> {
     // If the block is for another chain, ignore
     if (head.chain !== this.chainId) return
     const leadersStart = Date.now()
@@ -171,7 +180,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
    * @param head The current head block
    * @returns chain stake intent for the producer redeclaration, or undefined if no redeclaration is needed
    */
-  protected async getProducerRedeclaration(head: WithStorageMeta<BlockBoundWitness>): Promise<ChainStakeIntent | undefined> {
+  protected async getProducerRedeclaration(head: WithHashMeta<BlockBoundWitness>): Promise<ChainStakeIntent | undefined> {
     // Decide if we should redeclare intent
     if (this.params.config.producer.disableIntentRedeclaration) return
     // Decide if we need to redeclare intent
@@ -188,7 +197,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return createDeclarationIntent(this.address, 'producer', currentBlock, currentBlock + BaseBlockProducerService.RedeclarationDuration)
   }
 
-  protected async proposeNextValidBlock(head: WithStorageMeta<BlockBoundWitness>, validateBalances = false): Promise<HydratedBlock | undefined> {
+  protected async proposeNextValidBlock(head: WithHashMeta<BlockBoundWitness>, validateBalances = false): Promise<HydratedBlockWithHashMeta | undefined> {
     return await this.spanAsync('proposeNextValidBlock', async () => {
       // Calculate the next block components
       const { block: previousBlock } = assertEx(asBlockBoundWitness(head), () => 'Invalid head block')
@@ -252,7 +261,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
 
   // remove unfunded transactions and block transfers
   private async filterByFunded(
-    head: WithStorageMeta<BlockBoundWitness>,
+    head: WithHashMeta<BlockBoundWitness>,
     txs: SignedHydratedTransaction[],
     transfers: Transfer[],
     validateBalances = false,
@@ -276,7 +285,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return [fundedTransactions, fundedTransfers]
   }
 
-  private async generateTimePayload(head: WithStorageMeta<BlockBoundWitness>) {
+  private async generateTimePayload(head: WithHashMeta<BlockBoundWitness>) {
     const [ethereum, ethHashOrNull] = await this.time.currentTimeAndHash('ethereum')
     const ethereumHash = asHash(ethHashOrNull, () => 'No ethereum hash available from time sync service')
     const timePayload: TimePayload = {
@@ -297,7 +306,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
    * @param head The current head block
    * @returns True if a heartbeat is required, false otherwise
    */
-  private heartbeatRequired(head: WithStorageMeta<BlockBoundWitness>): boolean {
+  private heartbeatRequired(head: WithHashMeta<BlockBoundWitness>): boolean {
     const epoch = head.$epoch
     if (isDefined(epoch)) {
       const { heartbeatInterval } = this.params.config.producer

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -12,8 +12,10 @@ import {
   Payload, PayloadBundle, Sequence, WithStorageMeta,
 } from '@xyo-network/payload-model'
 import {
-  asBlockBoundWitnessWithHashMeta, ChainId, HydratedTransactionValidationFunction, isTransactionBoundWitnessWithStorageMeta,
+  asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, ChainId, HydratedTransactionValidationFunction, isTransactionBoundWitnessWithStorageMeta,
+  SignedHydratedTransactionWithHashMeta,
   SignedHydratedTransactionWithStorageMeta,
+  XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
 import { PendingTransactionsService } from '@xyo-network/xl1-protocol-sdk'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
@@ -145,7 +147,7 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
     // Acquires an exclusive mutex to ensure no race conditions while accessing pending transactions.
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
         // Find the supplied head
-        let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashMeta)
+        let [lastHead] = filterAs(await this.chainArchivist.get([head]), x => asBlockBoundWitnessWithHashMeta(x))
         if (isUndefined(lastHead)) return []
 
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)
@@ -179,7 +181,7 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
 
           // Filter transactions to only include those that are active for the next
           // potential block based on the last supplied head.
-          const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1))
+          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)))
 
           const txValidationResults = await Promise.all(activeTransactions.map(async tx => ([tx, await validateTransaction(
             tx,
@@ -287,7 +289,7 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
       const foundPendingTransactionsToDeleteHashes: Hash[] = []
 
       let cursor: Sequence | undefined
-      let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashMeta)
+      let [lastHead] = filterAs(await this.chainArchivist.get([head]), x => asBlockBoundWitnessWithHashMeta(x))
 
       // Continue fetching until the desired number of transactions is reached.
       while (isDefined(lastHead)) {
@@ -325,7 +327,7 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
         )).filter(exists)
 
         // Find expired transactions based on the last supplied head
-        const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1))
+        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)))
         // Find the corresponding bundle hashes for the expired transactions
         const expiredBundleHashes = expiredTransactions
           .map(expiredHydratedTx =>
@@ -359,8 +361,8 @@ export class BasePendingTransactionsService extends BaseService<BasePendingTrans
  * @param block The block number to check against the transaction's validity period.
  * @returns True if the transaction is expired for the given block, false otherwise.
  */
-const isTransactionExpired = (block: number) =>
-  ([txBw]: SignedHydratedTransactionWithStorageMeta): boolean =>
+const isTransactionExpired = (block: XL1BlockNumber) =>
+  ([txBw]: SignedHydratedTransactionWithHashMeta): boolean =>
     txBw.exp < block
 
 /**
@@ -368,6 +370,6 @@ const isTransactionExpired = (block: number) =>
  * @param block The block number to check against the transaction's validity period.
  * @returns True if the transaction is active for the given block, false otherwise.
  */
-const isTransactionActive = (block: number) =>
-  ([txBw]: SignedHydratedTransactionWithStorageMeta): boolean =>
+const isTransactionActive = (block: XL1BlockNumber) =>
+  ([txBw]: SignedHydratedTransactionWithHashMeta): boolean =>
     txBw.nbf <= block && txBw.exp >= block

package/src/PendingTransactions/bundledPayloadToHydratedTransaction.ts

@@ -1,14 +1,14 @@
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { PayloadBundle, WithStorageMeta } from '@xyo-network/payload-model'
-import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
-import { asTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
+import { asSignedTransactionBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol'
 
 export const bundledPayloadToHydratedTransaction = async (
   payload: WithStorageMeta<PayloadBundle>,
-): Promise<SignedHydratedTransactionWithStorageMeta | undefined> => {
-  const withStorageMeta = await PayloadBuilder.addStorageMeta(payload.payloads)
-  const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find(p => p._hash === payload.root))
+): Promise<SignedHydratedTransactionWithHashMeta | undefined> => {
+  const withHashMeta = await PayloadBuilder.addHashMeta(payload.payloads)
+  const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find(p => p._hash === payload.root))
   if (tx) {
-    return [tx, withStorageMeta.filter(p => p._hash !== payload.root)]
+    return [tx, withHashMeta.filter(p => p._hash !== payload.root)]
   }
 }

package/src/PendingTransactions/hydratedTransactionToPayloadBundle.ts

@@ -2,15 +2,15 @@ import type { Hash } from '@xylabs/sdk-js'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { PayloadBundle } from '@xyo-network/payload-model'
 import { PayloadBundleSchema } from '@xyo-network/payload-model'
-import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
 import { flattenHydratedTransaction } from '@xyo-network/xl1-protocol-sdk'
 
-export const hydratedTransactionToPayloadBundle = (transaction: SignedHydratedTransactionWithStorageMeta): PayloadBundle => {
+export const hydratedTransactionToPayloadBundle = (transaction: SignedHydratedTransactionWithHashMeta): PayloadBundle => {
   const root = transaction[0]._hash
   return bundle(root, transaction)
 }
 
-const bundle = (root: Hash, transaction: SignedHydratedTransactionWithStorageMeta) => {
+const bundle = (root: Hash, transaction: SignedHydratedTransactionWithHashMeta) => {
   const payloads = flattenHydratedTransaction(transaction).flatMap(p => PayloadBuilder.omitStorageMeta(p))
   return new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema })
     .fields({ payloads, root })

package/src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts

@@ -2,7 +2,7 @@ import type { Hash } from '@xylabs/sdk-js'
 import { exists, filterAs } from '@xylabs/sdk-js'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import { asOptionalBoundWitness } from '@xyo-network/boundwitness-model'
+import { isBoundWitness } from '@xyo-network/boundwitness-model'
 import { payloadSchemasContains } from '@xyo-network/boundwitness-validator'
 import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
 import type {
@@ -14,7 +14,7 @@ export const getBlockSignedStakeDeclarations = async (block: BlockBoundWitness,
   // Get payloads in block
   const blockData = await archivist.get(block.payload_hashes)
   // Filter Payloads in block to BoundWitnesses
-  const bwsFromBlock = filterAs(blockData, asOptionalBoundWitness)
+  const bwsFromBlock = blockData.filter(x => isBoundWitness(x))
   // Filter to BoundWitnesses with StakeIntent payloads
   const bwsFromBlockWithDeclarations = bwsFromBlock.filter(bw => payloadSchemasContains(bw, ChainStakeIntentSchema))
   // Filter to only valid signed BWs

package/src/blockViewerFromChainIteratorAndArchivist.ts

@@ -3,10 +3,10 @@ import { isDefined } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type {
-  HydratedBlock,
+  SignedHydratedBlockWithHashMeta,
   XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
-import { asBlockBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { asSignedBlockBoundWitness, asSignedBlockBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 import type { BlockViewer, EventingChainBlockNumberIteratorService } from '@xyo-network/xl1-protocol-sdk'
 
 export function blockViewerFromChainIteratorAndArchivist(
@@ -14,26 +14,26 @@ export function blockViewerFromChainIteratorAndArchivist(
   chainArchivist: ReadArchivist,
 ): BlockViewer {
   const result = {
-    blockByHash: async function (hash: Hash): Promise<HydratedBlock | null> {
+    blockByHash: async function (hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
       const [payload] = await chainArchivist.get([hash])
-      const block = asBlockBoundWitnessWithStorageMeta(payload)
+      const block = asSignedBlockBoundWitnessWithStorageMeta(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
+    blockByNumber: async function (blockNumber: XL1BlockNumber): Promise<SignedHydratedBlockWithHashMeta | null> {
+      const payload = asSignedBlockBoundWitness(await chainIterator.get(blockNumber))
+      const block = payload ? await PayloadBuilder.addHashMeta(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[] = []
+    blocksByHash: async function (hash: Hash, limit = 10): Promise<SignedHydratedBlockWithHashMeta[]> {
+      const results: SignedHydratedBlockWithHashMeta[] = []
       for (let i = 0; i < limit; i++) {
         const block = await this.blockByHash(hash)
         if (block) {
@@ -44,9 +44,9 @@ export function blockViewerFromChainIteratorAndArchivist(
       }
       return results
     },
-    currentBlock: async function (): Promise<HydratedBlock> {
+    currentBlock: async function (): Promise<SignedHydratedBlockWithHashMeta> {
       const head = await chainIterator.head()
-      return this.blockByHash(head._hash) as Promise<HydratedBlock>
+      return this.blockByHash(head._hash) as Promise<SignedHydratedBlockWithHashMeta>
     },
     currentBlockHash: async function (): Promise<Hash> {
       const head = await chainIterator.head()

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './AccountTransfers/index.ts'
 export * from './BaseService.ts'
 export * from './BlockProducer/index.ts'
 export * from './BlockReward/index.ts'
+export * from './blockViewerFromChainIteratorAndArchivist.ts'
 export * from './ChainBlockNumberIteration/index.ts'
 export * from './ChainService/index.ts'
 export * from './ChainValidator/index.ts'