@xyo-network/xl1-protocol-sdk 1.18.0-rc.1 → 1.18.1

package/src/actor/Actor.ts

@@ -0,0 +1,209 @@
+import type {
+  CreatableInstance, CreatableParams, EmptyObject,
+  Promisable,
+} from '@xylabs/sdk-js'
+import {
+  AbstractCreatable,
+  assertEx,
+  Base, creatable, delay, IdLogger,
+} from '@xylabs/sdk-js'
+import { AccountInstance } from '@xyo-network/account-model'
+import { Semaphore } from 'async-mutex'
+
+import { Config, getDefaultConfig } from '../config/index.ts'
+import { ProviderFactoryLocator, ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
+import { BaseContext } from '../model/index.ts'
+
+export type ActorContext = BaseContext & {
+  config: Config
+  locator?: ProviderFactoryLocatorInstance
+  singletons: Record<string, unknown>
+}
+
+export type ActorParams<T extends EmptyObject | void = void> = CreatableParams & {
+  account: AccountInstance
+  context?: ActorContext
+  displayName?: string
+  id: string
+} & (T extends void ? EmptyObject : T)
+
+export type ActorInstance<T extends ActorParams = ActorParams> = CreatableInstance<T>
+
+@creatable()
+export class Actor<TParams extends ActorParams = ActorParams> extends AbstractCreatable<TParams> {
+  protected readonly _intervals: Map<string, ReturnType<typeof setInterval>> = new Map()
+  protected readonly _semaphores: Map<string, Semaphore> = new Map()
+  protected readonly _timeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
+  private _active = false
+
+  get displayName() {
+    return this.params.displayName ?? this.params.name ?? 'UnnamedActor'
+  }
+
+  get id() {
+    return this.params.id
+  }
+
+  protected get account() {
+    return this.params.account!
+  }
+
+  protected get config() {
+    return this.context.config
+  }
+
+  protected get context() {
+    return this.params.context!
+  }
+
+  protected get locator() {
+    return this.context.locator
+  }
+
+  protected get logPrefix() {
+    return `[${this.displayName} (${this.id})] `
+  }
+
+  static override async paramsHandler<T extends ActorInstance>(params?: Partial<T['params']>) {
+    const baseParams = await super.paramsHandler(params)
+    const id = params?.id ?? baseParams.name ?? 'UnnamedActor'
+    const displayName = params?.displayName ?? baseParams.name
+    const account = assertEx(params?.account, () => `Account is required for actor ${id}.`)
+    const context = await this.initContext({
+      ...params, account, id, displayName,
+    })
+    const logger = context?.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `)
+    return {
+      ...baseParams, account, context, displayName, id, logger,
+    } satisfies ActorParams
+  }
+
+  protected static initContext<T extends ActorInstance>(
+    params: T['params'],
+  ): Promisable<T['params']['context']> {
+    const logger = params?.context?.logger
+    const config: Config = params?.context?.config ?? getDefaultConfig()
+    const singletons = params?.context?.singletons ?? {}
+
+    const context: ActorContext = {
+      ...params?.context,
+      config,
+      logger,
+      singletons,
+    }
+
+    const locator = params?.context?.locator ?? new ProviderFactoryLocator(context)
+    return locator.context
+  }
+
+  /**
+   * The timer runs until the actor is deactivated (or you manually stop it).
+   */
+  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number) {
+    if (!this._active) {
+      this.logger?.warn(
+        `Cannot register timer '${timerName}' because actor is not active.`,
+      )
+      return
+    }
+
+    let running = false
+
+    this._semaphores.set(timerName, new Semaphore(1))
+
+    const timeoutId = setTimeout(() => {
+      const intervalId = setInterval(() => {
+        const semaphore = this._semaphores.get(timerName)
+        if (!this._active || !this._intervals.has(timerName) || !semaphore || running) return
+        if (semaphore.isLocked()) {
+          this.logger?.warn(
+            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`,
+          )
+          return
+        }
+        semaphore.acquire().then(([, release]) => {
+          const startTime = Date.now()
+          running = true
+          callback()
+            .then(() => {
+              const duration = Date.now() - startTime
+              if (duration > periodMs) {
+                this.logger?.warn(
+                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`,
+                )
+              } else if (duration > 5000) {
+                this.logger?.warn(
+                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`,
+                )
+              }
+            })
+            .catch((error) => {
+              this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
+              this.logger?.error(error.stack)
+            })
+            .finally(() => {
+              release()
+              running = false
+            })
+        }).catch((error) => {
+          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`)
+        })
+      }, periodMs)
+
+      // store interval so we can clear it on stop()
+      this._intervals.set(timerName, intervalId)
+    }, dueTimeMs)
+
+    // store timeout so we can clear it on stop() if interval hasn't started yet
+    this._timeouts.set(timerName, timeoutId)
+
+    this.logger?.log(
+      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
+    )
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is activated.
+   */
+  override async startHandler() {
+    await super.startHandler()
+    this._active = true
+    this.logger?.log('Started.')
+  }
+
+  /**
+   * Called by the Orchestrator when the actor is deactivated.
+   * Stop all running timers.
+   */
+  override async stopHandler() {
+    await super.stopHandler()
+    this._active = false
+    this.logger?.log('Stopping all timers...')
+
+    // wait for all semaphores to be free and acquire them to prevent new tasks from starting
+    await Promise.all(
+      [...this._semaphores.values()].map(async (semaphore) => {
+        // Wait for any running tasks to complete
+        while (semaphore.isLocked()) {
+          this.logger?.log('Waiting for running timer task to complete...')
+          await delay(500)
+        }
+        await semaphore.acquire()
+      }),
+    )
+
+    this._semaphores.clear()
+
+    for (const [, timeoutRef] of this._timeouts.entries()) {
+      clearTimeout(timeoutRef)
+    }
+    this._timeouts.clear()
+
+    for (const [, intervalRef] of this._intervals.entries()) {
+      clearInterval(intervalRef)
+    }
+    this._intervals.clear()
+
+    this.logger?.log('Stopped.')
+  }
+}

package/src/actor/index.ts

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

package/src/block/hydrate/allHashesPresent.ts

@@ -1,7 +1,7 @@
 import type { Hash } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 
-export function allHashesPresent(hashes: Hash[], payloads: WithStorageMeta<Payload>[]): boolean {
+export function allHashesPresent(hashes: Hash[], payloads: WithHashMeta<Payload>[]): boolean {
   const payloadHashes = new Set(payloads.map(p => p._hash))
   return hashes.every(hash => payloadHashes.has(hash))
 }

package/src/block/hydrate/hydrateBlock.ts

@@ -1,6 +1,6 @@
 import type { Hash } from '@xylabs/sdk-js'
 import { assertEx } from '@xylabs/sdk-js'
-import type { HydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+import type { HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol'
 import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
 import type { ChainStoreRead } from '../../model/index.ts'
@@ -11,7 +11,7 @@ export const hydrateBlock = async (
   hash: Hash,
   maxDepth: number = 1,
   minDepth = maxDepth,
-): Promise<HydratedBlockWithHashMeta> => {
+): Promise<HydratedBlockWithStorageMeta> => {
   assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
   assertEx(minDepth >= 0, () => 'minDepth must be greater than or equal to 0')
   assertEx(maxDepth >= minDepth, () => 'maxDepth must be greater than or equal to minDepth')

package/src/config/Api.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Bridge.ts

@@ -3,8 +3,7 @@ import {
 } from '@xylabs/hex'
 import type { ChainId } from '@xyo-network/xl1-protocol'
 import { AttoXL1ConvertFactor, XL1 } from '@xyo-network/xl1-protocol'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Chain.ts

@@ -1,6 +1,5 @@
 import { AddressZod, HexZod } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ChainConfigZod = z.object({
   id: HexZod.optional()

package/src/config/Config.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod'
+import { z } from 'zod'
 
 import { ApiConfigZod } from './Api.ts'
 import { BridgeConfigZod } from './Bridge.ts'

package/src/config/Evm.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const EvmInfuraConfigZod = z.object({
   projectId: z.string().optional().register(globalRegistry, {

package/src/config/Log.ts

@@ -1,7 +1,6 @@
 import type { LogLevelKey } from '@xylabs/sdk-js'
 import { LogLevel } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 const LogLevels = Object.keys(LogLevel) as [LogLevelKey, ...LogLevelKey[]]
 
 export const LogConfigZod = z.object({

package/src/config/Mempool.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Producer.ts

@@ -1,6 +1,5 @@
 import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/RewardRedemptionApi.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MnemonicStringZod } from '../validation/index.ts'
 

package/src/config/Services.ts

@@ -1,13 +1,14 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ServicesConfigZod = z.object({
-  accountBalanceViewerEndpoint: z.string().optional().register(globalRegistry, {
+  accountBalanceViewerEndpoint: z.string().default('http://localhost:8080/rpc').register(globalRegistry, {
+    default: 'http://localhost:8080/rpc',
     description: 'Endpoint of the API to use for instantiating an external AccountBalanceViewer',
     title: 'services.accountBalanceViewerEndpoint',
     type: 'string',
   }),
-  apiEndpoint: z.string().optional().register(globalRegistry, {
+  apiEndpoint: z.string().default('http://localhost:8080/rpc').register(globalRegistry, {
+    default: 'http://localhost:8080/rpc',
     description: 'Endpoint of the API to use for instantiating an external Viewers',
     title: 'services.apiEndpoint',
     type: 'string',

package/src/config/Telemetry.ts

@@ -1,5 +1,12 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
+
+export const DefaultMetricsScrapePorts = {
+  api: 9465,
+  bridge: 9468,
+  mempool: 9466,
+  producer: 9464,
+  rewardRedemptionApi: 9467,
+}
 
 export const MetricsScrapeConfigZod = z.object({
   path: z.string().default('/metrics').register(globalRegistry, {
@@ -8,8 +15,7 @@ export const MetricsScrapeConfigZod = z.object({
     title: 'telemetry.metrics.scrape.path',
     type: 'string',
   }),
-  port: z.coerce.number().default(9464).register(globalRegistry, {
-    default: 9464,
+  port: z.coerce.number().int().positive().optional().register(globalRegistry, {
     description: 'Port for the metrics scrape endpoint',
     title: 'telemetry.metrics.scrape.port',
     type: 'number',

package/src/config/UsageMeta.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod'
+import { z } from 'zod'
 
 const DescriptionSchema = z.string()
 const TitleSchema = z.string()

package/src/config/Validation.ts

@@ -1,6 +1,5 @@
 import { AddressZod, asAddress } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 export const ValidationConfigZod = z.object({
   allowedRewardRedeemers: z.preprocess((val) => {

package/src/config/index.ts

@@ -1,4 +1,5 @@
 export * from './Bridge.ts'
 export * from './Config.ts'
 export { hasMongoConfig } from './storage/index.ts'
+export { DefaultMetricsScrapePorts } from './Telemetry.ts'
 export * from './UsageMeta.ts'

package/src/config/storage/Storage.ts

@@ -1,5 +1,4 @@
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 import { MongoConfigZod } from './driver/index.ts'
 

package/src/config/storage/driver/Mongo.ts

@@ -1,6 +1,5 @@
 import { isDefined, isUndefined } from '@xylabs/sdk-js'
-import { globalRegistry } from 'zod'
-import * as z from 'zod'
+import { globalRegistry, z } from 'zod'
 
 /**
  * Checks if the provided MongoDB configuration contains all necessary fields

package/src/eip-712/Payloads/EIP712Data.ts

@@ -1,6 +1,6 @@
 import { AsObjectFactory } from '@xylabs/sdk-js'
 import { isPayloadOfZodType, type Payload } from '@xyo-network/payload-model'
-import z from 'zod'
+import { z } from 'zod'
 
 import {
   TypedDataDomainZod, TypedDataTypesZod, TypedDataValueZod,

package/src/eip-712/Payloads/EIP712Signature.ts

@@ -1,6 +1,6 @@
 import { AsObjectFactory, HashZod } from '@xylabs/sdk-js'
 import { isPayloadOfZodType, type Payload } from '@xyo-network/payload-model'
-import z from 'zod'
+import { z } from 'zod'
 
 export const EIP712SignaturePayloadFieldsZod = z.object({
   address: z.string(),

package/src/eip-712/Types.ts

@@ -1,5 +1,5 @@
 // import type { Signer } from 'ethers/providers'
-import z from 'zod'
+import { z } from 'zod'
 
 /**
  * Typed Data Types

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './actor/index.ts'
 export * from './block/index.ts'
 export * from './ChainServiceCollectionV2.ts'
 export * from './config/index.ts'

package/src/model/ChainQualification.ts

@@ -0,0 +1,33 @@
+import { HashZod } from '@xylabs/hex'
+import { zodIsFactory } from '@xylabs/zod'
+import { XL1BlockRangeZod } from '@xyo-network/xl1-protocol'
+import { z } from 'zod'
+
+export const ChainQualificationZod = z.object({ head: HashZod, range: XL1BlockRangeZod })
+export type ChainQualification = z.infer<typeof ChainQualificationZod>
+export const isChainQualification = zodIsFactory(ChainQualificationZod)
+
+export const ChainQualifiedRangeConfigZod = z.object({ range: XL1BlockRangeZod })
+export type ChainQualifiedRangeConfig = z.infer<typeof ChainQualifiedRangeConfigZod>
+export const isChainQualifiedRangeConfig = zodIsFactory(ChainQualifiedRangeConfigZod)
+
+export const ChainQualifiedHeadConfigZod = z.object({ head: HashZod })
+export type ChainQualifiedHeadConfig = z.infer<typeof ChainQualifiedHeadConfigZod>
+export const isChainQualifiedHeadConfig = zodIsFactory(ChainQualifiedHeadConfigZod)
+
+export const ChainQualifiedConfigZod = z.union([ChainQualifiedRangeConfigZod, ChainQualifiedHeadConfigZod, z.object({})])
+export type ChainQualifiedConfig = z.infer<typeof ChainQualifiedConfigZod>
+export const isChainQualifiedConfig = zodIsFactory(ChainQualifiedConfigZod)
+
+export const ExtendChainQualifiedConfigZod = (<T>(zodType: z.ZodType<T>) => {
+  return z.union([
+    ChainQualifiedRangeConfigZod.extend(zodType),
+    ChainQualifiedHeadConfigZod.extend(zodType),
+    zodType,
+  ])
+}) as <T>(zodType: z.ZodType<T>) => z.ZodType<T & ChainQualifiedConfig>
+
+export type ChainQualified<T> = [T, ChainQualification]
+export const ChainQualifiedZod = <T>(zodType: z.ZodType<T>) => {
+  return z.tuple([zodType, ChainQualificationZod])
+}

package/src/model/index.ts

@@ -1,10 +1,10 @@
 export * from './ChainContext/index.ts'
 export * from './ChainFork/index.ts'
 export * from './ChainIdentity.ts'
+export * from './ChainQualification.ts'
 export * from './ChainStore.ts'
 export * from './PayloadBundle/index.ts'
 export * from './PayloadMap.ts'
 export * from './Position.ts'
 export * from './Provider.ts'
-export * from './Qualified.ts'
 export * from './RecordKeyType.ts'

package/src/primitives/chain/getWindowedChain.ts

@@ -0,0 +1,42 @@
+import {
+  assertEx, type Hash, isDefined, isNull,
+} from '@xylabs/sdk-js'
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import type { BlockViewer } from '../../viewers/index.ts'
+
+/**
+ * Constructs a bounded, contiguous canonical chain ending at the current head.
+ * @param blockViewer The BlockViewer to fetch blocks from
+ * @param maxWindowSize The maximum size of the windowed chain
+ * @param previousChain An optional previous chain to build upon
+ * @returns A promise that resolves to the windowed chain of blocks
+ */
+export async function getWindowedChain(blockViewer: BlockViewer, maxWindowSize: number, previousChain: SignedHydratedBlockWithHashMeta[] = []):
+Promise<SignedHydratedBlockWithHashMeta[]> {
+  const newChain: SignedHydratedBlockWithHashMeta[] = []
+  const previousChainByHash = new Map<Hash, SignedHydratedBlockWithHashMeta>(previousChain.map(block => [block[0]._hash, block]))
+  const head = await blockViewer.currentBlock()
+  let currentBlock: SignedHydratedBlockWithHashMeta | null = head
+  console.log('[getWindowedChain] Current Block:', currentBlock?.[0]._hash)
+  while (currentBlock !== null && newChain.length < maxWindowSize) {
+    const currentBlockNumber = currentBlock[0].block
+    const nextBlock = newChain[0]
+    if (isDefined(nextBlock)) {
+      const nextBlockNumber = nextBlock[0].block
+      assertEx(
+        currentBlockNumber === nextBlockNumber - 1,
+        () => `[getWindowedChain] Non-monotonic block sequence detected: current=${currentBlockNumber}, next=${nextBlockNumber}`,
+      )
+    }
+    assertEx(
+      currentBlockNumber <= head[0].block,
+      () => `[getWindowedChain] Current block number (${currentBlockNumber}) exceeds head block number (${head[0].block})`,
+    )
+    newChain.unshift(currentBlock)
+    const previousBlockHash: Hash | null = currentBlock[0].previous
+    if (isNull(previousBlockHash)) break
+    currentBlock = previousChainByHash.get(previousBlockHash) ?? await blockViewer.blockByHash(previousBlockHash)
+  }
+  return newChain
+}

package/src/primitives/chain/index.ts

@@ -1,2 +1,3 @@
+export * from './getWindowedChain.ts'
 export * from './step/index.ts'
 export * from './time/index.ts'

package/src/primitives/index.ts

@@ -10,3 +10,4 @@ export * from './state/index.ts'
 export * from './step/index.ts'
 export * from './timeBudget.ts'
 export * from './transaction/index.ts'
+export * from './uncle/index.ts'

package/src/primitives/rewards/networkStakeStepRewardPositionWeight.ts

@@ -1,8 +1,8 @@
-import { type StepIdentity } from '@xyo-network/xl1-protocol'
+import { type StepIdentity, XYO_NETWORK_STAKING_ADDRESS } from '@xyo-network/xl1-protocol'
 
 import type { StakedChainContextRead } from '../../model/index.ts'
-import type { BlockViewer } from '../../viewers/Block.ts'
-import { externalBlockRangeFromStep } from '../chain/time/index.ts'
+import type { BlockViewer } from '../../viewers/index.ts'
+import { externalBlockRangeFromStep } from '../chain/index.ts'
 import { weightedStakeForRangeByPosition } from '../stake/index.ts'
 
 export async function networkStakeStepRewardPositionWeight(
@@ -15,6 +15,7 @@ export async function networkStakeStepRewardPositionWeight(
     context,
     blockViewer,
     await externalBlockRangeFromStep(context, blockViewer, stepContext),
+    XYO_NETWORK_STAKING_ADDRESS,
     position,
   )
   return result

package/src/primitives/stake/allStakersForStep.ts

@@ -3,7 +3,7 @@ import type { StepIdentity } from '@xyo-network/xl1-protocol'
 
 import type { StakedChainContextRead } from '../../model/index.ts'
 import type { BlockViewer } from '../../viewers/index.ts'
-import { externalBlockRangeFromXL1BlockRange } from '../chain/time/index.ts'
+import { externalBlockRangeFromXL1BlockRange } from '../chain/index.ts'
 import { stepBlockRange } from '../step/index.ts'
 import { allStakersForRange } from './allStakersForRange.ts'
 

package/src/primitives/stake/weightedStakeForRangeByPosition.ts

@@ -1,3 +1,4 @@
+import type { Address } from '@xylabs/sdk-js'
 import { isDefined } from '@xylabs/sdk-js'
 import { asBlockNumber, type BlockRange } from '@xyo-network/xl1-protocol'
 
@@ -9,6 +10,7 @@ export async function weightedStakeForRangeByPosition(
   context: StakedChainContextRead,
   blockViewer: BlockViewer,
   externalRange: BlockRange, // first to last block of step
+  staked?: Address,
   positionId?: number,
 ): Promise<bigint> {
   const cacheKey = isDefined(positionId) ? `${externalRange[0]}-${externalRange[1]}-${positionId}` : `${externalRange[0]}-${externalRange[1]}-all`
@@ -22,6 +24,12 @@ export async function weightedStakeForRangeByPosition(
       )).toSorted((a, b) => a.time - b.time)
       let currentTime = externalRange[0]
       let currentStake = 0n // await activeStakeAtTimeByPosition(chainEvents, pos.staked, currentTime - 1, position)
+
+      // if not staking the desired address, return 0n
+      if (isDefined(staked) && mergedEvents[0].args.staked !== staked) {
+        return 0n
+      }
+
       for (const event of mergedEvents) {
         if (event.time > currentTime) {
           // Add the weighted stake for the period between the range start or previous event and this event
@@ -44,9 +52,9 @@ export async function weightedStakeForRangeByPosition(
         weightedStakeSum += currentStake * BigInt(externalRange[1] - currentTime)
       }
     } else {
-      const positionCount = await context.stake.stakeEvents.positionCount(externalRange)
+      const positionCount = await context.stake.stakeEvents.positionCount([0, externalRange[1]])
       for (let pos = 0; pos < positionCount; pos++) {
-        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, pos)
+        weightedStakeSum += await weightedStakeForRangeByPosition(context, blockViewer, externalRange, staked, pos)
       }
     }
     return weightedStakeSum

package/src/primitives/uncle/findBestUncle.ts

@@ -0,0 +1,8 @@
+import type { SignedHydratedBlockWithHashMeta } from '@xyo-network/xl1-protocol'
+
+import { scoreUncle } from './scoreUncle.ts'
+
+export function findBestUncle(finalizedWindowedChain: SignedHydratedBlockWithHashMeta[], uncles: SignedHydratedBlockWithHashMeta[][]) {
+  const scores = uncles.map(uncle => ([scoreUncle(finalizedWindowedChain, uncle), uncle] as const)).toSorted((a, b) => b[0] - a[0])
+  return scores[0]?.[1] ?? finalizedWindowedChain
+}