@xyo-network/xl1-protocol-sdk 1.17.0 → 1.17.2

package/src/simple/accountBalance/SimpleAccountBalanceViewer.ts

@@ -3,6 +3,7 @@ import type {
 } from '@xylabs/sdk-js'
 import {
   AbstractCreatable,
+  asHash,
   assertEx, exists, isDefined,
 } from '@xylabs/sdk-js'
 import { spanRootAsync } from '@xylabs/telemetry'
@@ -17,9 +18,15 @@ import {
 } from '@xyo-network/xl1-protocol'
 
 import { deepCalculateFramesFromRange } from '../../block/index.ts'
-import type { BalanceStepSummaryContext, TransfersStepSummaryContext } from '../../model/index.ts'
-import type { TransfersStepSummary } from '../../payloads/index.ts'
-import { balancesSummary, transfersStepSummaryFromRange } from '../../primitives/index.ts'
+import type { Qualified } from '../../model/index.ts'
+import type {
+  BalanceStepSummaryContext, TransfersStepSummary,
+  TransfersStepSummaryContext,
+} from '../../summary/index.ts'
+import {
+  balancesSummary,
+  transfersStepSummaryFromRange,
+} from '../../summary/index.ts'
 import type {
   AccountBalanceHistoryItem, AccountBalanceViewer, BlockViewer,
 } from '../../viewers/index.ts'
@@ -52,10 +59,14 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
   }
 
   async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountsBalances([address], headOrRange)
+    const balances = await this.accountBalances([address], headOrRange)
     return balances[address] ?? AttoXL1(0n)
   }
 
+  accountBalanceHistories(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Record<Address, AccountBalanceHistoryItem[]>> {
+    throw new Error('Method [accountBalanceHistories] not implemented.')
+  }
+
   async accountBalanceHistory(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AccountBalanceHistoryItem[]> {
     const range = asRange(headOrRange)
     const startingRange = asXL1BlockRange(range ?? [0, await this.blockViewer.currentBlockNumber()], true)
@@ -84,24 +95,64 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     return result
   }
 
-  async accountsBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AttoXL1>>> {
-    return await spanRootAsync('balances', async () => {
-      const summary = await balancesSummary(
+  async accountBalances(address: Address[], _headOrRange?: XL1BlockRange | Hash): Promise<Record<Address, AttoXL1>> {
+    const [result] = (await this.qualifiedAccountBalances(address, _headOrRange))
+    return result
+  }
+
+  async qualifiedAccountBalanceHistories(
+    addresses: Address[],
+    headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<Record<Address, AccountBalanceHistoryItem[]>>> {
+    const head = asHash(headOrRange) ?? await this.blockViewer.currentBlockHash()
+    const range = asXL1BlockRange(headOrRange) ?? asXL1BlockRange([0,
+      assertEx(
+        await this.blockViewer.blockByHash(head),
+        () => `Error: Could not find block with hash ${head}`,
+      )[0].block])
+    const qualifiedEntries: [Address, Qualified<AccountBalanceHistoryItem[]>][] = await Promise.all(addresses.map(async address => ([
+      address,
+      await this.qualifiedAccountBalanceHistory(address, range),
+    ])))
+
+    const entries = qualifiedEntries.map(([address, [history]]) => {
+      return [address, history]
+    })
+    const qualifiedRange = qualifiedEntries[0][1][1]
+    const qualifiedHeadHash = qualifiedEntries[0][1][2]
+
+    // check for drift
+    for (const [_, [__, range, headHash]] of qualifiedEntries) {
+      assertEx(
+        range[0] === qualifiedRange[0] && range[1] === qualifiedRange[1],
+        () => 'Inconsistent ranges in qualifiedAccountBalanceHistories',
+      )
+      assertEx(
+        headHash === qualifiedHeadHash,
+        () => 'Inconsistent head hashes in qualifiedAccountBalanceHistories',
+      )
+    }
+
+    return [Object.fromEntries(entries), qualifiedRange, qualifiedHeadHash]
+  }
+
+  async qualifiedAccountBalances(
+    address: Address[],
+    _headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<Record<Address, AttoXL1>>> {
+    return await spanRootAsync('qualifiedAccountsBalances', async () => {
+      const qualifiedSummary = await balancesSummary(
         this.context,
       )
       const result: Record<Address, AttoXL1> = {}
       for (const addr of address) {
-        const summaryBalance = summary[addr] ?? 0n
+        const summaryBalance = qualifiedSummary[0][addr] ?? 0n
         result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
       }
-      return result
+      return [result, qualifiedSummary[1], qualifiedSummary[2]]
     })
   }
 
-  accountsBalancesHistory(_addresses: Address[], _rangeOrHash?: XL1BlockRange | Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    throw new Error('Method not implemented.')
-  }
-
   private async distillTransferHistory(address: Address, range: XL1BlockRange, max: number = 50): Promise<XL1BlockNumber[]> {
     if ((range[1] - range[0]) <= StepSizes[0] || max <= 1) {
       return Array.from({ length: range[1] - range[0] + 1 }, (_, i) => range[1] - i).slice(0, max).map(n => asXL1BlockNumber(n, true))
@@ -139,4 +190,39 @@ export class SimpleAccountBalanceViewer extends AbstractCreatable<SimpleAccountB
     }
     return [...resultBlockNumbers].toSorted((a, b) => b - a).slice(0, max)
   }
+
+  private async qualifiedAccountBalanceHistory(
+    address: Address,
+    headOrRange?: Hash | XL1BlockRange,
+  ): Promise<Qualified<AccountBalanceHistoryItem[]>> {
+    const range = asRange(headOrRange)
+    const headHash = asHash(headOrRange)
+    const [head] = assertEx(isDefined(headHash)
+      ? (await this.blockViewer.blockByHash(headHash))
+      : (await this.blockViewer.currentBlock()), () => 'Could not resolve head block')
+    const startingRange = asXL1BlockRange(range ?? [0, head.block], true)
+    const blockNumbers = await this.distillTransferHistory(address, startingRange)
+    const blocks = (await Promise.all(blockNumbers.map(async bn => await this.blockViewer.blockByNumber(bn)))).filter(exists)
+    const result: AccountBalanceHistoryItem[] = []
+    for (const block of blocks) {
+      const transferIndexes = block[0].payload_schemas.map((schema, index) => schema === TransferSchema ? index : undefined).filter(exists)
+      const transfers = transferIndexes.map((index) => {
+        const hash = block[0].payload_hashes[index]
+        return assertEx(
+          block[1].find(p => p._hash === hash) as WithStorageMeta<Transfer>,
+          () => `Error: Could not find Transfer with hash ${hash} in block ${block[0]._hash}`,
+        )
+      }).filter(exists).filter(t => ((t.from === address) || (isDefined(t.transfers[address]))))
+      if (transfers.length === 0) {
+        continue
+      }
+      const pairs: [SignedBlockBoundWitnessWithHashMeta, WithHashMeta<Transfer>][] = (transfers.map((transfer) => {
+        return [block[0], transfer]
+      }))
+      result.push(...pairs.map(([block, transfer]) => [block,
+        null,
+        transfer] satisfies AccountBalanceHistoryItem))
+    }
+    return [result, startingRange, head._hash]
+  }
 }

package/src/simple/block/SimpleBlockViewer.ts

@@ -2,30 +2,39 @@ import type { CreatableParams, Hash } from '@xylabs/sdk-js'
 import {
   AbstractCreatable,
   assertEx,
+  exists,
+  isDefined,
   spanRootAsync,
 } from '@xylabs/sdk-js'
 import type { ReadArchivist } from '@xyo-network/archivist-model'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 import {
   asSignedHydratedBlockWithHashMeta,
   asXL1BlockNumber,
-  type SignedHydratedBlockWithHashMeta, type XL1BlockNumber,
+  type SignedHydratedBlockWithHashMeta,
+  type XL1BlockNumber,
 } from '@xyo-network/xl1-protocol'
 
 import { hydrateBlock } from '../../block/index.ts'
-import type { ChainStoreRead, StakedChainContextRead } from '../../model/index.ts'
+import { LruCacheMap } from '../../driver/index.ts'
+import type {
+  ChainContextRead,
+  ChainStoreRead, PayloadMap,
+} from '../../model/index.ts'
 import { findMostRecentBlock, hydratedBlockByNumber } from '../../primitives/index.ts'
 import { HydratedCache } from '../../utils/index.ts'
 import type { BlockViewer } from '../../viewers/index.ts'
 
 export interface SimpleBlockViewerParams extends CreatableParams {
-  context: StakedChainContextRead
+  context: ChainContextRead
   finalizedArchivist?: ReadArchivist
 }
 
 export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams> implements BlockViewer {
+  private _payloadCache: PayloadMap<WithHashMeta<Payload>> | undefined
   private _signedHydratedBlockCache: HydratedCache<SignedHydratedBlockWithHashMeta> | undefined
 
-  get context(): StakedChainContextRead {
+  get context(): ChainContextRead {
     return this.params.context!
   }
 
@@ -33,6 +42,27 @@ export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams
     return this.params.finalizedArchivist!
   }
 
+  protected get hydratedBlockCache(): HydratedCache<SignedHydratedBlockWithHashMeta> {
+    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
+    const chainMap = this.context.store.chainMap
+    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
+      { chainMap }: ChainStoreRead,
+      hash: Hash,
+      maxDepth?: number,
+      minDepth?: number,
+    ) => {
+      const result = await hydrateBlock({ chainMap }, hash, maxDepth, minDepth)
+      return asSignedHydratedBlockWithHashMeta(result, true)
+    }, 200)
+    return this._signedHydratedBlockCache
+  }
+
+  protected get payloadCache(): PayloadMap<WithHashMeta<Payload>> {
+    if (this._payloadCache) return this._payloadCache
+    this._payloadCache = new LruCacheMap<Hash, WithHashMeta<Payload>>({ max: 10_000 })
+    return this._payloadCache
+  }
+
   static override async paramsHandler(params: Partial<SimpleBlockViewerParams>) {
     assertEx(params.context, () => 'context is required')
     assertEx(params.finalizedArchivist, () => 'finalizedArchivist is required')
@@ -42,7 +72,7 @@ export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams
 
   async blockByHash(hash: Hash): Promise<SignedHydratedBlockWithHashMeta | null> {
     return await spanRootAsync('blockByHash', async () => {
-      const cache = this.getHydratedBlockCache()
+      const cache = this.hydratedBlockCache
       return await cache.get(hash)
     }, this.tracer)
   }
@@ -88,7 +118,7 @@ export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams
   async currentBlock(): Promise<SignedHydratedBlockWithHashMeta> {
     return await spanRootAsync('currentBlock', async () => {
       const currentHead = assertEx(await this.getCurrentHead(), () => 'Could not find most recent block')
-      const cache = this.getHydratedBlockCache()
+      const cache = this.hydratedBlockCache
       const block = await cache.get(currentHead._hash)
       if (!block) {
         console.log(`Could not find current block with hash ${currentHead!._hash}`)
@@ -111,23 +141,32 @@ export class SimpleBlockViewer extends AbstractCreatable<SimpleBlockViewerParams
     }, this.tracer)
   }
 
+  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
+    const cachedPayload = await this.payloadCache.get(hash)
+    if (cachedPayload) {
+      return cachedPayload
+    } else {
+      const [result] = await this.finalizedArchivist.get([hash])
+      if (isDefined(result)) {
+        await this.payloadCache.set(hash, result)
+      }
+      return result ?? null
+    }
+  }
+
+  async payloadsByHash(hashes: Hash[]): Promise<WithHashMeta<Payload>[]> {
+    let remainingHashes = [...hashes]
+    const cachedPayloads = await this.payloadCache.getMany(remainingHashes)
+    const cachedHashes = new Set(cachedPayloads.map(p => p._hash))
+    remainingHashes = remainingHashes.filter(h => !cachedHashes.has(h))
+    const remainingPayloads = remainingHashes.length > 0
+      ? await this.finalizedArchivist.get(remainingHashes)
+      : []
+    return [...cachedPayloads, ...remainingPayloads.filter(exists)]
+  }
+
   protected async getCurrentHead() {
     const chainArchivist = this.finalizedArchivist
     return await findMostRecentBlock(chainArchivist)
   }
-
-  protected getHydratedBlockCache(): HydratedCache<SignedHydratedBlockWithHashMeta> {
-    if (this._signedHydratedBlockCache) return this._signedHydratedBlockCache
-    const chainMap = this.context.store.chainMap
-    this._signedHydratedBlockCache = new HydratedCache<SignedHydratedBlockWithHashMeta>(chainMap, async (
-      { chainMap }: ChainStoreRead,
-      hash: Hash,
-      maxDepth?: number,
-      minDepth?: number,
-    ) => {
-      const result = await hydrateBlock({ chainMap }, hash, maxDepth, minDepth)
-      return asSignedHydratedBlockWithHashMeta(result, true)
-    }, 200)
-    return this._signedHydratedBlockCache
-  }
 }

package/src/simple/blockReward/SimpleBlockRewardViewer.ts

@@ -0,0 +1,34 @@
+import {
+  AbstractCreatable,
+  creatable, CreatableParams, Promisable,
+} from '@xylabs/sdk-js'
+import { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
+
+import { rewardFromBlockNumber } from '../../primitives/index.ts'
+import { BlockRewardViewer } from '../../viewers/index.ts'
+
+export interface SimpleBlockRewardViewerParams extends CreatableParams {
+  creatorReward: AttoXL1
+  initialReward: AttoXL1
+  minRewardPerBlock: AttoXL1
+  stepFactorDenominator: bigint
+  stepFactorNumerator: bigint
+  stepSize: XL1BlockNumber
+}
+
+@creatable()
+export class SimpleBlockRewardViewer extends AbstractCreatable<SimpleBlockRewardViewerParams> implements BlockRewardViewer {
+  protected rewardFromBlockNumber = rewardFromBlockNumber(18)
+
+  allowedRewardForBlock(block: XL1BlockNumber): Promisable<AttoXL1> {
+    return this.rewardFromBlockNumber(
+      block,
+      this.params.initialReward,
+      this.params.stepSize,
+      this.params.stepFactorNumerator,
+      this.params.stepFactorDenominator,
+      this.params.minRewardPerBlock,
+      this.params.creatorReward,
+    )
+  }
+}

package/src/simple/blockReward/index.ts

@@ -0,0 +1 @@
+export * from './SimpleBlockRewardViewer.ts'

package/src/simple/chain/SimpleChainViewer.ts

@@ -0,0 +1,25 @@
+import {
+  type Address, asHex, Promisable,
+} from '@xylabs/sdk-js'
+import {
+  AbstractCreatable,
+  creatable, CreatableParams,
+} from '@xylabs/sdk-js'
+import { ChainId } from '@xyo-network/xl1-protocol'
+
+import { ChainViewer } from '../../viewers/index.ts'
+
+export interface SimpleChainParams extends CreatableParams {
+  chainId: Address
+}
+
+@creatable()
+export class SimpleChainViewer extends AbstractCreatable<SimpleChainParams> implements ChainViewer {
+  static override async paramsHandler(params?: Partial<SimpleChainParams>) {
+    return ({ ...await super.paramsHandler(params), chainId: asHex(params?.chainId, () => 'chainId not set') }) as SimpleChainParams
+  }
+
+  chainId(): Promisable<ChainId> {
+    return this.params.chainId
+  }
+}

package/src/simple/chain/index.ts

@@ -0,0 +1 @@
+export * from './SimpleChainViewer.ts'

package/src/simple/gateway/SimpleXyoGatewayRunner.ts

@@ -43,7 +43,7 @@ export class SimpleXyoGatewayRunner implements XyoGatewayRunner {
   }
 
   get dataLakes(): DataLakeRunner[] {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [dataLakes] not implemented.')
   }
 
   get signerInstance(): XyoSigner {

package/src/simple/index.ts

@@ -1,9 +1,11 @@
 export * from './accountBalance/index.ts'
 export * from './block/index.ts'
+export * from './blockReward/index.ts'
 export * from './chainStake/index.ts'
 export * from './client/index.ts'
 export * from './datalake/index.ts'
 export * from './gateway/index.ts'
+export * from './mempool/index.ts'
 export * from './network/index.ts'
 export * from './permissions/index.ts'
 export * from './runner/index.ts'

package/src/simple/mempool/SimpleMempoolRunner.ts

@@ -0,0 +1,47 @@
+import {
+  AbstractCreatable, creatable, CreatableParams, type Hash,
+} from '@xylabs/sdk-js'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { type SignedHydratedBlock, type SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
+
+import { hydratedBlockToPayloadBundle, hydratedTransactionToPayloadBundle } from '../../model/index.ts'
+import type { MempoolRunner } from '../../runners/index.ts'
+
+export interface SimpleMempoolRunnerParams extends CreatableParams {
+  pendingBlocksArchivist: ArchivistInstance
+  pendingTransactionsArchivist: ArchivistInstance
+}
+
+@creatable()
+export class SimpleMempoolRunner extends AbstractCreatable<SimpleMempoolRunnerParams> implements MempoolRunner {
+  protected get pendingBlocksArchivist() {
+    return this.params.pendingBlocksArchivist
+  }
+
+  protected get pendingTransactionsArchivist() {
+    return this.params.pendingTransactionsArchivist
+  }
+
+  async submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]> {
+    const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
+      return hydratedBlockToPayloadBundle([
+        await PayloadBuilder.addHashMeta(bw),
+        await PayloadBuilder.addHashMeta(payloads),
+      ])
+    }))
+    const inserted = await this.pendingBlocksArchivist.insert(bundles)
+    return inserted.map(p => p._hash)
+  }
+
+  async submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]> {
+    const bundles = await Promise.all(transactions.map(async ([tx, payloads]) => {
+      return hydratedTransactionToPayloadBundle([
+        await PayloadBuilder.addHashMeta(tx),
+        await PayloadBuilder.addHashMeta(payloads),
+      ])
+    }))
+    const inserted = await this.pendingBlocksArchivist.insert(bundles)
+    return inserted.map(p => p._hash)
+  }
+}

package/src/simple/mempool/SimpleMempoolViewer.ts

@@ -1,34 +1,60 @@
 import {
+  AbstractCreatable,
+  creatable,
+  CreatableParams,
   exists, isDefined, isHash,
 } from '@xylabs/sdk-js'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
   isHashMeta, isPayloadBundle, type Sequence,
 } from '@xyo-network/payload-model'
-import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedBlockWithHashMeta, SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol'
 
-import { bundledPayloadToHydratedTransaction } from '../../model/index.ts'
+import { bundledPayloadToHydratedBlock, bundledPayloadToHydratedTransaction } from '../../model/index.ts'
 import type {
   MempoolViewer,
   PendingTransactionsOptions,
 } from '../../viewers/index.ts'
 
-export class SimpleMempoolViewer implements MempoolViewer {
-  protected readonly archivist: ArchivistInstance
+export interface SimpleMempoolViewerParams extends CreatableParams {
+  pendingBlocksArchivist: ArchivistInstance
+  pendingTransactionsArchivist: ArchivistInstance
+}
+
+@creatable()
+export class SimpleMempoolViewer extends AbstractCreatable<SimpleMempoolViewerParams> implements MempoolViewer {
+  protected get pendingBlocksArchivist() {
+    return this.params.pendingBlocksArchivist
+  }
 
-  constructor(archivist: ArchivistInstance) {
-    this.archivist = archivist
+  protected get pendingTransactionsArchivist() {
+    return this.params.pendingTransactionsArchivist
+  }
+
+  async pendingBlocks({ cursor: providedCursor }: PendingTransactionsOptions = {}): Promise<SignedHydratedBlockWithHashMeta[]> {
+    let cursor: Sequence | undefined = undefined
+    if (isHash(providedCursor)) {
+      const [p] = await this.pendingBlocksArchivist.get([providedCursor])
+      if (isDefined(p)) {
+        cursor = p._sequence
+      }
+    }
+    const bundles = await this.pendingBlocksArchivist.next({
+      order: 'asc', limit: 100, cursor,
+    })
+    const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta)
+    return (await Promise.all(filteredBundles.map(async bundle => await bundledPayloadToHydratedBlock(bundle)))).filter(exists)
   }
 
   async pendingTransactions({ cursor: providedCursor }: PendingTransactionsOptions = {}): Promise<SignedHydratedTransactionWithHashMeta[]> {
     let cursor: Sequence | undefined = undefined
     if (isHash(providedCursor)) {
-      const [p] = await this.archivist.get([providedCursor])
+      const [p] = await this.pendingTransactionsArchivist.get([providedCursor])
       if (isDefined(p)) {
         cursor = p._sequence
       }
     }
-    const bundles = await this.archivist.next({
+    const bundles = await this.pendingTransactionsArchivist.next({
       order: 'asc', limit: 100, cursor,
     })
     const filteredBundles = bundles.filter(isPayloadBundle).filter(isHashMeta)

package/src/simple/mempool/index.ts

@@ -1 +1,2 @@
+export * from './SimpleMempoolRunner.ts'
 export * from './SimpleMempoolViewer.ts'

package/src/simple/timesync/SimpleTimeSyncViewer.ts

@@ -88,6 +88,6 @@ export class SimpleTimeSyncViewer implements TimeSyncViewer {
   }
 
   currentTimePayload(): Promisable<TimePayload> {
-    throw new Error('Method not implemented.')
+    throw new Error('Method [currentTimePayload] not implemented.')
   }
 }

package/src/summary/index.ts

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

package/src/{payloads/summary → summary/model}/index.ts

@@ -1,4 +1,5 @@
 export * from './BalancesStepSummary.ts'
 export * from './SchemasStepSummary.ts'
 export * from './StepSummary.ts'
+export * from './summary.ts'
 export * from './TransfersSummary.ts'

package/src/{model → summary/model}/summary.ts

@@ -1,10 +1,11 @@
 import type { Payload } from '@xyo-network/payload-model'
 import type { Semaphore } from 'async-mutex'
 
-import type { MapTypeRead, MapTypeWrite } from '../map/index.ts'
-import type { SchemasStepSummary } from '../payloads/index.ts'
-import type { BalancesStepSummary, TransfersStepSummary } from '../payloads/summary/index.ts'
-import type { BaseContext, ChainContextRead } from './index.ts'
+import type { MapTypeRead, MapTypeWrite } from '../../map/index.ts'
+import type { BaseContext, ChainContextRead } from '../../model/index.ts'
+import type {
+  BalancesStepSummary, SchemasStepSummary, TransfersStepSummary,
+} from './index.ts'
 
 export interface ChainSummaryContextBase<TPayload extends Payload,
   T extends (MapTypeRead<string, TPayload> | MapTypeWrite<string, TPayload>)> extends BaseContext {

package/src/{primitives/summary → summary/primitives}/balances/balancesStepSummaryFromRange.ts

@@ -11,12 +11,13 @@ import {
   deepCalculateFramesFromRange, hashFromBlockNumber,
   hydrateBlock,
 } from '../../../block/index.ts'
-import type { BalanceStepSummaryContext } from '../../../model/index.ts'
-import type { BalancesStepSummary } from '../../../payloads/index.ts'
-import { BalancesStepSummarySchema, netBalancesForPayloads } from '../../../payloads/index.ts'
+import { netBalancesForPayloads } from '../../../payloads/index.ts'
 import {
   parseSignedBigInt, type SignedBigInt, toSignedBigInt,
 } from '../../../SignedBigInt.ts'
+import {
+  type BalancesStepSummary, BalancesStepSummarySchema, type BalanceStepSummaryContext,
+} from '../../model/index.ts'
 
 export async function balancesStepSummaryFromRange(
   context: BalanceStepSummaryContext,

package/src/{primitives/summary → summary/primitives}/balances/balancesSummary.ts

@@ -6,30 +6,31 @@ import {
 } from '@xyo-network/xl1-protocol'
 
 import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import type { BalanceStepSummaryContext } from '../../../model/index.ts'
+import type { Qualified } from '../../../model/index.ts'
 import { parseSignedBigInt } from '../../../SignedBigInt.ts'
+import type { BalanceStepSummaryContext } from '../../model/index.ts'
 import { balancesStepSummaryFromRange } from './balancesStepSummaryFromRange.ts'
 
 export async function balancesSummary(
   context: BalanceStepSummaryContext,
-): Promise<Partial<Record<Address, bigint>>> {
+): Promise<Qualified<Record<Address, bigint>>> {
   return await spanRootAsync('balancesSummary', async () => {
     const [headHash] = await context.head()
     const headResult = await context.store.chainMap.get(headHash)
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`)
-    const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0)
+    const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true)
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
       [rangeStart, headBoundWitness.block],
       { name: 'balancesSummary' },
     ))
     const summaries = await Promise.all(ranges.map(range => balancesStepSummaryFromRange(context, range)))
-    const balances: Partial<Record<Address, bigint>> = {}
+    const balances: Record<Address, bigint> = {}
     for (let summary of summaries) {
       for (const [address, balance] of Object.entries(summary.balances)) {
         const validAddress = asAddress(address, () => `Invalid address: ${address}`)
         balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance)
       }
     }
-    return balances
+    return [balances, [rangeStart, headBoundWitness.block], headHash]
   })
 }

package/src/{primitives/summary → summary/primitives}/schemas/schemasStepSummaryFromRange.ts

@@ -12,9 +12,9 @@ import {
   deepCalculateFramesFromRange, hashFromBlockNumber,
   hydrateBlock,
 } from '../../../block/index.ts'
-import type { SchemasStepSummaryContext } from '../../../model/index.ts'
-import type { SchemasStepSummary } from '../../../payloads/index.ts'
-import { SchemasStepSummarySchema } from '../../../payloads/index.ts'
+import {
+  type SchemasStepSummary, type SchemasStepSummaryContext, SchemasStepSummarySchema,
+} from '../../model/index.ts'
 
 export async function schemasStepSummaryFromRange(
   context: SchemasStepSummaryContext,

package/src/{primitives/summary → summary/primitives}/schemas/schemasSummary.ts

@@ -6,28 +6,29 @@ import {
 } from '@xyo-network/xl1-protocol'
 
 import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import type { SchemasStepSummaryContext } from '../../../model/index.ts'
+import type { Qualified } from '../../../model/index.ts'
+import type { SchemasStepSummaryContext } from '../../model/index.ts'
 import { schemasStepSummaryFromRange } from './schemasStepSummaryFromRange.ts'
 
 export async function schemasSummary(
   context: SchemasStepSummaryContext,
-): Promise<Partial<Record<Schema, number>>> {
+): Promise<Qualified<Record<Schema, number>>> {
   return await spanRootAsync('schemasSummary', async () => {
     const [headHash] = await context.head()
     const headResult = await context.store.chainMap.get(headHash)
     const headBoundWitness = asBlockBoundWitnessWithStorageMeta(headResult, () => `Head block not found for hash: ${headHash}`)
-    const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0)
+    const rangeStart = asXL1BlockNumber(isDefined(context.windowSize) ? Math.max(headBoundWitness.block - context.windowSize + 1, 0) : 0, true)
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
       [rangeStart, headBoundWitness.block],
       { name: 'schemasSummary' },
     ))
     const summaries = await Promise.all(ranges.map(range => schemasStepSummaryFromRange(context, range)))
-    const schemas: Partial<Record<Schema, number>> = {}
+    const results: Record<Schema, number> = {}
     for (let summary of summaries) {
       for (const [schema, count] of Object.entries(summary.schemas)) {
-        schemas[schema] = (schemas[schema] ?? 0) + count
+        results[schema] = (results[schema] ?? 0) + count
       }
     }
-    return schemas
+    return [results, [rangeStart, headBoundWitness.block], headHash]
   })
 }