@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/multipliers.ts

@@ -1,18 +0,0 @@
-import type { XL1BlockRangeKey, XL1RangeMultipliers } from '@xyo-network/xl1-protocol-lib'
-import { asAttoXL1 } from '@xyo-network/xl1-protocol-lib'
-
-import { XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK } from './constants.ts'
-
-/** XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS constant. */
-export const XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS = asAttoXL1(1_343_884_111_859_145_740_576_652n)
-/** XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS constant. */
-export const XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS = asAttoXL1(100_000_000_000_000_000_000_000_000n)
-/** XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS constant. */
-export const XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_REWARDS
-  = XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS + XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS
-
-/** RewardMultipliers constant. */
-export const RewardMultipliers: XL1RangeMultipliers = {
-  [`0|${XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK}` as XL1BlockRangeKey]:
-      [XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_BONUS_REWARDS, XL1_NETWORK_STAKING_GENESIS_PERIOD_TOTAL_EARNED_REWARDS],
-}

package/src/payloads/AddressPairPayload.ts

@@ -1,27 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, type Payload,
-} from '@xyo-network/sdk-js'
-
-/** Schema identifier for AddressPair payloads. */
-export const AddressPairSchema = asSchema('network.xyo.address.pair', true)
-/** Schema type for AddressPair payloads. */
-export type AddressPairSchema = typeof AddressPairSchema
-
-/** AddressFields interface. */
-export interface AddressFields {
-  addresses: [Address, Address]
-}
-
-/** AddressPairPayload type. */
-export type AddressPairPayload = Payload<AddressFields, AddressPairSchema>
-
-/**
- * Identity function for determining if an object is an AddressPairPayload
- */
-export const isAddressPairPayload = isPayloadOfSchemaType<AddressPairPayload>(AddressPairSchema)
-/** Converts a value to AddressPairPayload, throwing if invalid. */
-export const asAddressPairPayload = AsObjectFactory.create(isAddressPairPayload)
-/** Optionally converts a value to AddressPairPayload if valid. */
-export const asOptionalAddressPairPayload = AsObjectFactory.createOptional(isAddressPairPayload)

package/src/payloads/index.ts

@@ -1,4 +0,0 @@
-export * from './AddressPairPayload.ts'
-export * from './netBalancesForPayloads.ts'
-export * from './netSchemasForPayloads.ts'
-export * from './netTransfersForPayloads.ts'

package/src/payloads/netBalancesForPayloads.ts

@@ -1,24 +0,0 @@
-import {
-  type Address, type Hex, hexToBigInt, toAddress,
-} from '@xylabs/sdk-js'
-import { span } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import type { BaseContext } from '@xyo-network/xl1-protocol-lib'
-import { isTransfer } from '@xyo-network/xl1-protocol-lib'
-
-/** netBalancesForPayloads constant. */
-export const netBalancesForPayloads = (context: BaseContext, payloads: Payload[]) => {
-  return span('netBalancesForPayloads', () => {
-    const balances: Record<Address, bigint> = {}
-    for (const payload of payloads) {
-      if (isTransfer(payload)) {
-        const { from } = payload
-        for (let [address, amount] of Object.entries(payload.transfers) as [Address, Hex][]) {
-          balances[toAddress(address)] = (balances[toAddress(address)] ?? 0n) + hexToBigInt(amount)
-          balances[toAddress(from)] = (balances[toAddress(from)] ?? 0n) - hexToBigInt(amount)
-        }
-      }
-    }
-    return balances
-  }, context.traceProvider)
-}

package/src/payloads/netSchemasForPayloads.ts

@@ -1,24 +0,0 @@
-import {
-  type Address, type Hex, hexToBigInt, toAddress,
-} from '@xylabs/sdk-js'
-import { span } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import type { BaseContext } from '@xyo-network/xl1-protocol-lib'
-import { isTransfer } from '@xyo-network/xl1-protocol-lib'
-
-/** netSchemasForPayloads constant. */
-export const netSchemasForPayloads = (context: BaseContext, payloads: Payload[]) => {
-  return span('netSchemasForPayloads', () => {
-    const balances: Record<Address, bigint> = {}
-    for (const payload of payloads) {
-      if (isTransfer(payload)) {
-        const { from } = payload
-        for (let [address, amount] of Object.entries(payload.transfers) as [Address, Hex][]) {
-          balances[toAddress(address)] = (balances[toAddress(address)] ?? 0n) + hexToBigInt(amount)
-          balances[toAddress(from)] = (balances[toAddress(from)] ?? 0n) - hexToBigInt(amount)
-        }
-      }
-    }
-    return balances
-  }, context.traceProvider)
-}

package/src/payloads/netTransfersForPayloads.ts

@@ -1,27 +0,0 @@
-import {
-  type Address, type Hex, hexToBigInt,
-} from '@xylabs/sdk-js'
-import { span } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import type { BaseContext } from '@xyo-network/xl1-protocol-lib'
-import { isTransfer } from '@xyo-network/xl1-protocol-lib'
-
-// the net transfer amounts for the specified accounts only
-/** NetTransfersForPayloads helper function. */
-export function netTransfersForPayloads(context: BaseContext, payloads: Payload[]): Record<Address, Record<Address, bigint>> {
-  return span('netTransfersForPayloads', () => {
-    const transfers: Record<Address, Record<Address, bigint>> = {}
-    for (const payload of payloads) {
-      if (isTransfer(payload)) {
-        const { from } = payload
-        transfers[from] = transfers[from] ?? {}
-        for (let [to, amount] of Object.entries(payload.transfers) as [Address, Hex][]) {
-          transfers[to] = transfers[to] ?? {}
-          transfers[to][from] = (transfers[to][from] ?? 0n) + hexToBigInt(amount)
-          transfers[from][to] = (transfers[from][to] ?? 0n) - hexToBigInt(amount)
-        }
-      }
-    }
-    return transfers
-  }, context.traceProvider)
-}

package/src/primitives/block/index.ts

@@ -1,2 +0,0 @@
-export * from './range/index.ts'
-export * from './rate/index.ts'

package/src/primitives/block/range/blockRangeSteps.ts

@@ -1,23 +0,0 @@
-import type {
-  StepIdentity,
-  XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, StepSizes } from '@xyo-network/xl1-protocol-lib'
-
-/** BlockRangeSteps helper function. */
-export function blockRangeSteps(range: XL1BlockRange, steps: number[]): StepIdentity[] {
-  const result: StepIdentity[] = []
-  for (const step of steps) {
-    const stepSize = StepSizes[step]
-    // we add stepSize twice to get to the start of the next full step
-    const startOfFirstStepCandidate = range[0] - (range[0] % stepSize) + stepSize
-    const startOfFirstStep = asXL1BlockNumber(
-      startOfFirstStepCandidate,
-      { name: 'blockRangeSteps' },
-    )
-    for (let block = startOfFirstStep; block <= range[1]; block = asXL1BlockNumber(block + stepSize, { name: 'blockRangeSteps' })) {
-      result.push({ step, block })
-    }
-  }
-  return result
-}

package/src/primitives/block/range/index.ts

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

package/src/primitives/block/rate/blockRate.ts

@@ -1,77 +0,0 @@
-import { isDefined, isFalsy } from '@xylabs/sdk-js'
-import type {
-  BlockViewer,
-  HydratedBlock, TimeDurations, XL1BlockNumber, XL1BlockRange, XL1BlockRate,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockRange } from '@xyo-network/xl1-protocol-lib'
-
-import { rateMultipliers, timeDurations } from './timeHelpers.ts'
-
-/** blockRate constant. */
-export const blockRate = (
-  startBlock: HydratedBlock,
-  endBlock: HydratedBlock,
-  timeUnit?: keyof TimeDurations,
-): XL1BlockRate => {
-  const startingBlock = startBlock[0]
-  const endingBlock = endBlock[0]
-
-  const heightDifference = endingBlock.block - startingBlock.block
-  const timeDifference = endingBlock.$epoch - startingBlock.$epoch
-
-  if (timeDifference === 0) {
-    throw new Error('Time difference must be greater than 0')
-  }
-
-  const rate = heightDifference / timeDifference
-
-  const timeUnitValue = isDefined(timeUnit) ? timeUnit : 'millis'
-  const returnedTimeDifference = isDefined(timeUnit) ? timeDurations(timeDifference)[timeUnit] : timeDifference
-  const timePerBlock = returnedTimeDifference / heightDifference
-
-  return {
-    range: asXL1BlockRange([startingBlock.block, endingBlock.block], true),
-    span: heightDifference,
-    rate: isDefined(timeUnit) ? rate * rateMultipliers[timeUnit] : rate,
-    timeUnit: timeUnitValue,
-    timeDifference: returnedTimeDifference,
-    timePerBlock,
-  }
-}
-
-/** getBlockRateBlocks constant. */
-export const getBlockRateBlocks = async (
-  viewer: BlockViewer,
-  startBlockHeight: XL1BlockNumber,
-  endBlockHeight: XL1BlockNumber,
-): Promise<{ endingBlock: HydratedBlock; startingBlock: HydratedBlock }> => {
-  if (endBlockHeight <= startBlockHeight) {
-    console.error('startBlockHeight', startBlockHeight)
-    console.error('endBlockHeight', endBlockHeight)
-    throw new Error('End block height must be greater than start block height')
-  }
-
-  const startingBlock = await viewer.blockByNumber(startBlockHeight)
-  const endingBlock = await viewer.blockByNumber(endBlockHeight)
-
-  if (isFalsy(startingBlock) || isFalsy(endingBlock)) {
-    throw new Error('Could not retrieve blocks for speed calculation')
-  }
-
-  return { startingBlock, endingBlock }
-}
-
-/** calculateBlockRate constant. */
-export const calculateBlockRate = async (
-  viewer: BlockViewer,
-  range: XL1BlockRange,
-  timeUnit?: keyof TimeDurations,
-): Promise<XL1BlockRate> => {
-  const [startBlockHeight, endBlockHeight] = range
-  const { startingBlock, endingBlock } = await getBlockRateBlocks(
-    viewer,
-    startBlockHeight,
-    endBlockHeight,
-  )
-  return blockRate(startingBlock, endingBlock, timeUnit)
-}

package/src/primitives/block/rate/index.ts

@@ -1,4 +0,0 @@
-export * from './blockRate.ts'
-export * from './stepRate.ts'
-export * from './timeHelpers.ts'
-export * from './timeRate.ts'

package/src/primitives/block/rate/stepRate.ts

@@ -1,37 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  BlockViewer,
-  TimeDurations, XL1BlockNumber, XL1BlockRate,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockRange, isValidStep, StepSizes,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { calculateBlockRate } from './blockRate.ts'
-
-/** stepRate constant. */
-export const stepRate = async (
-  viewer: BlockViewer,
-  start: XL1BlockNumber,
-  step: typeof StepSizes[number],
-  count = 1,
-  timeUnit?: keyof TimeDurations,
-): Promise<XL1BlockRate> => {
-  const end = start + step * count
-  const range = asXL1BlockRange([start, end], true)
-
-  return await calculateBlockRate(viewer, range, timeUnit)
-}
-
-/** calculateStepSizeRate constant. */
-export const calculateStepSizeRate = async (
-  viewer: BlockViewer,
-  start: XL1BlockNumber,
-  stepIndex: number,
-  count = 1,
-  timeUnit?: keyof TimeDurations,
-) => {
-  assertEx(isValidStep(stepIndex), () => `Invalid step index: ${stepIndex}`)
-  const step = StepSizes[stepIndex]
-  return await stepRate(viewer, start, step, count, timeUnit)
-}

package/src/primitives/block/rate/timeHelpers.ts

@@ -1,61 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { SingleTimeConfig, TimeDurations } from '@xyo-network/xl1-protocol-lib'
-
-/** rateMultipliers constant. */
-export const rateMultipliers: TimeDurations = {
-  millis: 1,
-  seconds: 1000,
-  minutes: 1000 * 60,
-  hours: 1000 * 60 * 60,
-  days: 1000 * 60 * 60 * 24,
-  weeks: 1000 * 60 * 60 * 24 * 7,
-}
-
-/** timeDurations constant. */
-export const timeDurations = (timeInMs: number): TimeDurations => ({
-  millis: timeInMs,
-  seconds: timeInMs / 1000,
-  minutes: timeInMs / (1000 * 60),
-  hours: timeInMs / (1000 * 60 * 60),
-  days: timeInMs / (1000 * 60 * 60 * 24),
-  weeks: timeInMs / (1000 * 60 * 60 * 24 * 7),
-})
-
-/** getTimeConfigInMilliseconds constant. */
-export const getTimeConfigInMilliseconds = (timeConfig: SingleTimeConfig): number => {
-  const assertedTimeConfig = assertEx(isDefined(timeConfig) ? timeConfig : undefined, () => 'Time configuration must be provided')
-  // Convert all time units to milliseconds
-  let totalMilliseconds = 0
-
-  if ('years' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.years * 31_536_000_000 // 1 year = 31,536,000,000 milliseconds
-    return totalMilliseconds
-  }
-
-  if ('months' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.months * 2_592_000_000 // 1 month = 2,592,000,000 milliseconds
-    return totalMilliseconds
-  }
-
-  if ('weeks' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.weeks * 604_800_000 // 1 week = 604,800,000 milliseconds
-    return totalMilliseconds
-  }
-
-  if ('days' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.days * 86_400_000 // 1 day = 86,400,000 milliseconds
-    return totalMilliseconds
-  }
-
-  if ('hours' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.hours * 3_600_000 // 1 hour = 3,600,000 milliseconds
-    return totalMilliseconds
-  }
-
-  if ('minutes' in assertedTimeConfig) {
-    totalMilliseconds += assertedTimeConfig.minutes * 60_000 // 1 minute = 60,000 milliseconds
-    return totalMilliseconds
-  }
-
-  return totalMilliseconds
-}

package/src/primitives/block/rate/timeRate.ts

@@ -1,121 +0,0 @@
-import {
-  assertEx, isDefined, isDefinedNotNull,
-} from '@xylabs/sdk-js'
-import type {
-  BlockBoundWitness,
-  BlockViewer,
-  SingleTimeConfig,
-  TimeDurations,
-  XL1BlockNumber,
-  XL1BlockRate,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, asXL1BlockRange } from '@xyo-network/xl1-protocol-lib'
-
-import { calculateBlockRate } from './blockRate.ts'
-import { getTimeConfigInMilliseconds } from './timeHelpers.ts'
-
-/** DEFAULT_TOLERANCE_MS constant. */
-export const DEFAULT_TOLERANCE_MS = 30_000 // 30 seconds
-/** DEFAULT_MAX_ATTEMPTS constant. */
-export const DEFAULT_MAX_ATTEMPTS = 10
-
-/** calculateTimeRate constant. */
-export const calculateTimeRate = async (
-  viewer: BlockViewer,
-  timeConfig: SingleTimeConfig,
-  startBlockNumber?: XL1BlockNumber,
-  timeUnit?: keyof TimeDurations,
-  // default tolerance of 30 seconds to cut down on iterations
-  toleranceMs = DEFAULT_TOLERANCE_MS,
-  // maximum recursive attempts to prevent infinite loops
-  maxAttempts = DEFAULT_MAX_ATTEMPTS,
-): Promise<XL1BlockRate> => {
-  // check the time config has only one key
-  assertEx(Object.keys(timeConfig ?? {}).length === 1, () => 'Only one time unit should be specified in timeConfig')
-
-  // resolve the starting block
-  const startBlock = isDefinedNotNull(startBlockNumber) ? await viewer.blockByNumber(startBlockNumber) : null
-  const resolvedStartBlock = isDefinedNotNull(startBlock)
-    ? startBlock[0]
-    : (await viewer.currentBlock())[0]
-
-  const timeInMilliseconds = getTimeConfigInMilliseconds(timeConfig)
-  assertEx(timeInMilliseconds > 0, () => 'Time duration must be greater than zero')
-
-  // Estimate blocks per milliseconds (bpm) based on average block time
-  const blocksPerMillisecondRate = 1 / (12 * 1000) // Approximate average block time of 12 seconds
-
-  // Calculate the number of blocks in the given time duration
-  const initialBlocksInDuration = Math.floor(blocksPerMillisecondRate * timeInMilliseconds)
-
-  // Recursively find the proper end block
-  const endBlockNumber = await findEndBlockRecursive(
-    viewer,
-    resolvedStartBlock,
-    timeInMilliseconds,
-    initialBlocksInDuration,
-    toleranceMs,
-    maxAttempts,
-  )
-
-  return await calculateBlockRate(
-    viewer,
-    asXL1BlockRange([endBlockNumber, resolvedStartBlock.block], true),
-    timeUnit,
-  )
-}
-
-const findEndBlockRecursive = async (
-  viewer: BlockViewer,
-  startBlock: BlockBoundWitness,
-  targetTimeMs: number,
-  estimatedBlocksBack: number,
-  toleranceMs: number,
-  attemptsRemaining: number,
-): Promise<XL1BlockNumber> => {
-  console.log(`Attempts remaining: ${attemptsRemaining}, Estimated blocks back: ${estimatedBlocksBack}`)
-  assertEx(attemptsRemaining >= 0, () => 'Maximum attempts reached while searching for end block')
-
-  const startBlockEpoch = startBlock.$epoch
-  const estimatedEndBlockNumber = asXL1BlockNumber(startBlock.block - estimatedBlocksBack, true)
-  if (estimatedEndBlockNumber < 0) {
-    throw new Error('Estimated end block number is less than zero')
-  }
-
-  // Fetch the estimated end block
-  const endBlock = await viewer.blockByNumber(estimatedEndBlockNumber)
-  const resolvedEndBlock = assertEx(
-    isDefined(endBlock?.[0]) ? endBlock[0] : undefined,
-    () => `Could not retrieve block ${estimatedEndBlockNumber} for time rate calculation`,
-  )
-
-  const endBlockEpoch = resolvedEndBlock.$epoch
-  const actualTimeDifference = startBlockEpoch - endBlockEpoch
-
-  // Check if we're within tolerance
-  const timeDelta = Math.abs(actualTimeDifference - targetTimeMs)
-  if (timeDelta <= toleranceMs) {
-    return resolvedEndBlock.block
-  }
-
-  // Calculate adjustment factor and recursively search
-  let adjustedBlocksBack: number
-  if (actualTimeDifference < targetTimeMs) {
-    // Need to go further back
-    const adjustmentFactor = targetTimeMs / actualTimeDifference
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack * adjustmentFactor)
-  } else {
-    // Need to come forward
-    const adjustmentFactor = actualTimeDifference / targetTimeMs
-    adjustedBlocksBack = Math.floor(estimatedBlocksBack / adjustmentFactor)
-  }
-
-  return await findEndBlockRecursive(
-    viewer,
-    startBlock,
-    targetTimeMs,
-    adjustedBlocksBack,
-    toleranceMs,
-    attemptsRemaining - 1,
-  )
-}

package/src/primitives/chain/getWindowedChain.ts

@@ -1,50 +0,0 @@
-import {
-  assertEx, type Hash, isDefined, isNull,
-  spanRootAsync,
-} from '@xylabs/sdk-js'
-import type {
-  BaseContext, BlockViewer, SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-
-/**
- * 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(
-  context: BaseContext,
-  blockViewer: BlockViewer,
-  maxWindowSize: number,
-  previousChain: SignedHydratedBlockWithHashMeta[] = [],
-):
-Promise<SignedHydratedBlockWithHashMeta[]> {
-  return await spanRootAsync('getWindowedChain', async () => {
-    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
-  }, context)
-}

package/src/primitives/chain/index.ts

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

package/src/primitives/chain/step/chainStepRewardAddress.ts

@@ -1,30 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  assertEx, exists, toAddress,
-} from '@xylabs/sdk-js'
-import type {
-  BlockViewer, CachingContext, StepIdentity,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asTransfer, isTransfer, XYO_STEP_REWARD_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { mergeTransfers } from '../../payload/index.ts'
-import { stepTransferIndex } from '../../step/index.ts'
-import { stepRewardBlock } from './stepRewardBlock.ts'
-
-/** ChainStepRewardAddress helper function. */
-export async function chainStepRewardAddress(context: CachingContext, blockViewer: BlockViewer, { block, step }: StepIdentity): Promise<Address> {
-  const hydratedBlock = await stepRewardBlock(context, blockViewer, { block, step })
-  const [transferIndex, transferCount] = stepTransferIndex(block, step)
-  const [blockBw, payloads] = hydratedBlock
-
-  const transfersFromPool = payloads.filter(isTransfer).map(p => asTransfer(p)).filter(exists).filter(t => t.from === XYO_STEP_REWARD_ADDRESS)
-  const fromEntries = Object.entries(mergeTransfers(transfersFromPool)[XYO_STEP_REWARD_ADDRESS])
-  const sortedTransferAmounts = (fromEntries).toSorted(([,a], [,b]) => a > b ? -1 : a < b ? 1 : 0)
-  assertEx(
-    sortedTransferAmounts.length === transferCount,
-    () => `Step Transfers mismatch ${block} (${blockBw._hash}) [${sortedTransferAmounts.length} - ${transferCount}]`,
-  )
-  return toAddress(sortedTransferAmounts[transferIndex][0])
-}

package/src/primitives/chain/step/index.ts

@@ -1,4 +0,0 @@
-export * from './chainStepRewardAddress.ts'
-export * from './stepRewardBlock.ts'
-export * from './stepRewardTotal.ts'
-export * from './stepsRewardTotal.ts'

package/src/primitives/chain/step/stepRewardBlock.ts

@@ -1,13 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type {
-  BlockViewer,
-  CachingContext,
-  HydratedBlockWithHashMeta, StepIdentity,
-} from '@xyo-network/xl1-protocol-lib'
-import { StepSizes } from '@xyo-network/xl1-protocol-lib'
-
-/** StepRewardBlock helper function. */
-export async function stepRewardBlock(context: CachingContext, blockViewer: BlockViewer, { block, step }: StepIdentity): Promise<HydratedBlockWithHashMeta> {
-  assertEx((block % StepSizes[step]) === 0, () => `Block must be the first block of the step [${StepSizes[step]}], got ${block}`)
-  return assertEx(await blockViewer.blockByNumber(block), () => `Could not find block for block number ${block}`)
-}

package/src/primitives/chain/step/stepRewardTotal.ts

@@ -1,46 +0,0 @@
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type {
-  AttoXL1, BlockViewer, CachingContext, StepIdentity, XL1BlockRange, XL1RangeMultipliers,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asAttoXL1, asXL1BlockRange, isTransfer,
-  XYO_STEP_REWARD_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { withContextCacheResponse } from '../../../ChainContextHelpers.ts'
-import { netTransfersForPayloads } from '../../../payloads/index.ts'
-import { stepBlockRange, stepTransferIndex } from '../../step/index.ts'
-import { stepRewardBlock } from './stepRewardBlock.ts'
-
-function stepInRange(step: StepIdentity, range: XL1BlockRange): boolean {
-  const stepRange = stepBlockRange(step)
-  return ((stepRange[0] >= range[0]) && (stepRange[1] <= range[1]))
-}
-
-/** StepRewardTotal helper function. */
-export async function stepRewardTotal(context: CachingContext, blockViewer: BlockViewer, { block, step }: StepIdentity, multipliers: XL1RangeMultipliers): Promise<AttoXL1> {
-  const cacheKey = `${block}|${step}|${isDefined(multipliers)}`
-  return await withContextCacheResponse(context, 'stepRewardTotal', cacheKey, async () => {
-    const [blockBw, payloads] = await stepRewardBlock(context, blockViewer, { block, step })
-    assertEx(blockBw.block === block, () => `Block Mismatch: expected ${block}, got ${blockBw.block}`)
-    const [transferIndex] = stepTransferIndex(block, step)
-    const stepTransfer = assertEx(
-      payloads.find(p => isTransfer(p) && p.from === XYO_STEP_REWARD_ADDRESS),
-      () => `No step transfer found for step ${step} at block ${block} (${blockBw._hash})`,
-    )
-    const rewards = assertEx(
-      netTransfersForPayloads(context, [stepTransfer])[XYO_STEP_REWARD_ADDRESS],
-      () => `No rewards found for step reward address ${XYO_STEP_REWARD_ADDRESS} at block ${block} (${blockBw._hash})`,
-    )
-    const sortedTransfers = (Object.entries(rewards)).toSorted(([,a], [,b]) => a > b ? -1 : a < b ? 1 : 0)
-    let result = asAttoXL1(sortedTransfers[transferIndex][1] * -1n)
-    for (const [rangeKey, [numerator, denominator]] of Object.entries(multipliers)) {
-      const rangeParts = rangeKey.split('|').map(Number)
-      const range: XL1BlockRange = asXL1BlockRange([rangeParts[0], rangeParts[1]], { name: 'stepRewardTotal' })
-      if (stepInRange({ block, step }, range)) {
-        result = asAttoXL1(result + result * numerator / denominator)
-      }
-    }
-    return result
-  })
-}

package/src/primitives/chain/step/stepsRewardTotal.ts

@@ -1,37 +0,0 @@
-import type {
-  AttoXL1, BlockViewer, CachingContext, StepIdentity, XL1BlockRange,
-  XL1RangeMultipliers,
-} from '@xyo-network/xl1-protocol-lib'
-import { asAttoXL1, asXL1BlockRange } from '@xyo-network/xl1-protocol-lib'
-
-import { XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK } from '../../../constants.ts'
-import { blockRangeSteps } from '../../block/index.ts'
-import { stepRewardTotal } from './stepRewardTotal.ts'
-
-/** StepsRewardTotalGenesisPeriod helper function. */
-export async function stepsRewardTotalGenesisPeriod(context: CachingContext, blockViewer: BlockViewer, multipliers: XL1RangeMultipliers, stepSizes?: number[]): Promise<AttoXL1> {
-  const range = asXL1BlockRange([0, XL1_NETWORK_STAKING_GENESIS_PERIOD_END_XL1_BLOCK], { name: 'stepsRewardTotalGenesisPeriod' })
-  return await stepsRewardTotalRange(context, blockViewer, range, stepSizes, multipliers)
-}
-
-/** StepsRewardTotalRange helper function. */
-export async function stepsRewardTotalRange(
-  context: CachingContext,
-  blockViewer: BlockViewer,
-  range: XL1BlockRange,
-  stepSizes: number[] = [3, 4, 5, 6],
-  multipliers: XL1RangeMultipliers,
-): Promise<AttoXL1> {
-  const steps = blockRangeSteps(range, stepSizes)
-  return await stepsRewardTotal(context, blockViewer, steps, multipliers)
-}
-
-/** StepsRewardTotal helper function. */
-export async function stepsRewardTotal(context: CachingContext, blockViewer: BlockViewer, steps: StepIdentity[], multipliers: XL1RangeMultipliers): Promise<AttoXL1> {
-  let totalRewards = 0n
-  for (const step of steps) {
-    const stepTotal = await stepRewardTotal(context, blockViewer, step, multipliers)
-    totalRewards += stepTotal
-  }
-  return asAttoXL1(totalRewards)
-}