@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.14

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)
-}

package/src/primitives/chain/time/externalBlockNumberFromXL1BlockNumber.ts

@@ -1,32 +0,0 @@
-import { assertEx, isArray } from '@xylabs/sdk-js'
-import type {
-  BlockNumber, BlockViewer, CachingContext, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asBlockNumber, asTimePayload, isTimePayload,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { withContextCacheResponse } from '../../../ChainContextHelpers.ts'
-
-const functionName = 'externalBlockNumberFromXL1BlockNumber' as const
-
-/** ExternalBlockNumberFromXL1BlockNumber helper function. */
-export async function externalBlockNumberFromXL1BlockNumber(
-  context: CachingContext,
-  blockViewer: BlockViewer,
-  xl1BlockNumber: XL1BlockNumber,
-  externalTimeName: 'ethereum' | 'epoch',
-  externalGenesisTime?: BlockNumber,
-): Promise<BlockNumber> {
-  const cacheKey = `${xl1BlockNumber}-${externalTimeName}-${externalGenesisTime ?? 'default'}`
-  return await withContextCacheResponse(context, functionName, cacheKey, async () => {
-    const [, payloads = []] = await blockViewer.blockByNumber(xl1BlockNumber) ?? []
-    assertEx(isArray(payloads))
-    const timePayload = asTimePayload(payloads.find(isTimePayload))
-    // the default here is the block number we know where the xl1 chain started running (first external staking - 1)
-    return asBlockNumber(
-      timePayload?.[externalTimeName] ?? externalGenesisTime ?? 23_372_716,
-      { name: functionName },
-    ) // default is xl1 mainnet genesis time
-  })
-}

package/src/primitives/chain/time/externalBlockRangeFromStep.ts

@@ -1,21 +0,0 @@
-import type {
-  BlockRange, BlockViewer, CachingContext, StepIdentity,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { toStepIdentityString } from '../../../block/index.ts'
-import { withContextCacheResponse } from '../../../ChainContextHelpers.ts'
-import { stepBlockRange } from '../../step/index.ts'
-import { externalBlockRangeFromXL1BlockRange } from './externalBlockRangeFromXL1BlockRange.ts'
-
-/** ExternalBlockRangeFromStep helper function. */
-export async function externalBlockRangeFromStep(
-  context: CachingContext,
-  blockViewer: BlockViewer,
-  stepIdentity: StepIdentity,
-): Promise<BlockRange> {
-  const cacheKey = toStepIdentityString(stepIdentity)
-  return await withContextCacheResponse(context, 'externalBlockRangeFromStep', cacheKey, async () => {
-    const xl1BlockRange = stepBlockRange(stepIdentity)
-    return await externalBlockRangeFromXL1BlockRange(context, blockViewer, xl1BlockRange)
-  })
-}

package/src/primitives/chain/time/externalBlockRangeFromXL1BlockRange.ts

@@ -1,17 +0,0 @@
-import type {
-  BlockRange, BlockViewer, CachingContext, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { externalBlockNumberFromXL1BlockNumber } from './externalBlockNumberFromXL1BlockNumber.ts'
-
-/** ExternalBlockRangeFromXL1BlockRange helper function. */
-export async function externalBlockRangeFromXL1BlockRange(
-  context: CachingContext,
-  blockViewer: BlockViewer,
-  xl1BlockRange: XL1BlockRange,
-  externalTimeName: 'ethereum' = 'ethereum',
-): Promise<BlockRange> {
-  const start = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[0], externalTimeName)
-  const end = await externalBlockNumberFromXL1BlockNumber(context, blockViewer, xl1BlockRange[1], externalTimeName)
-  return [start, end]
-}

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

@@ -1,3 +0,0 @@
-export * from './externalBlockNumberFromXL1BlockNumber.ts'
-export * from './externalBlockRangeFromStep.ts'
-export * from './externalBlockRangeFromXL1BlockRange.ts'

package/src/primitives/datalake/addDataLakePayloads.ts

@@ -1,18 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { DataLakeViewer, HydratedBoundWitnessWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-
-import { addDataLakePayloadsToPayloads } from './addDataLakePayloadsToPayloads.ts'
-
-/** AddDataLakePayloads helper function. */
-export async function addDataLakePayloads<T extends HydratedBoundWitnessWithHashMeta>(
-  [boundWitness, payloads]: T,
-  dataLakeViewer?: DataLakeViewer,
-): Promise<[T, Hash[]]> {
-  const [updatedPayloads, foundHashes] = await addDataLakePayloadsToPayloads(boundWitness.payload_hashes, payloads, dataLakeViewer)
-  return [
-    [
-      boundWitness,
-      updatedPayloads,
-    ] as T,
-    foundHashes]
-}

package/src/primitives/datalake/addDataLakePayloadsToPayloads.ts

@@ -1,24 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { isUndefined } from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-import { isAnyPayload, PayloadBuilder } from '@xyo-network/sdk-js'
-import type { DataLakeViewer } from '@xyo-network/xl1-protocol-lib'
-
-/** AddDataLakePayloadsToPayloads helper function. */
-export async function addDataLakePayloadsToPayloads<T extends WithHashMeta<Payload>>(
-  hashes: Hash[],
-  payloads: T[],
-  dataLakeViewer?: DataLakeViewer,
-): Promise<[
-  /* Updated payloads with hash metadata */
-  T[],
-  /* Hashes of the newly added payloads */
-  Hash[],
-]> {
-  if (isUndefined(dataLakeViewer)) return [payloads, []]
-  const missingPayloadHashes = hashes.filter(hash => !payloads.some(p => p._hash === hash))
-  const payloadsFromDataLake = await PayloadBuilder.addHashMeta(
-    await PayloadBuilder.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload)),
-  )
-  return [[...payloads, ...payloadsFromDataLake] as T[], payloadsFromDataLake.map(p => p._hash)]
-}

package/src/primitives/datalake/index.ts

@@ -1,2 +0,0 @@
-export * from './addDataLakePayloads.ts'
-export * from './addDataLakePayloadsToPayloads.ts'

package/src/primitives/index.ts

@@ -1,13 +0,0 @@
-export * from './block/index.ts'
-export * from './chain/index.ts'
-export * from './datalake/index.ts'
-export * from './mapToMapType.ts'
-export * from './payload/index.ts'
-export * from './readPayloadMapFromStore.ts'
-export * from './rewardFromBlockNumber.ts'
-export * from './rewards/index.ts'
-export * from './stake/index.ts'
-export * from './state/index.ts'
-export * from './step/index.ts'
-export * from './transaction/index.ts'
-export * from './uncle/index.ts'

package/src/primitives/mapToMapType.ts

@@ -1,35 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import type { SyncIterableMap } from '@xyo-network/xl1-protocol-lib'
-
-/** MapToMapType helper function. */
-export function mapToMapType<K extends {}, V extends {}>(map: Map<K, V> | SyncIterableMap<K, V>): SyncIterableMap<K, V> {
-  return {
-    get: (key: K) => map.get(key),
-    has: (key: K) => map.has(key),
-    set: (key: K, value: V) => {
-      map.set(key, value)
-    },
-    setMany: (entries: [K, V][]) => {
-      for (const [key, value] of entries) {
-        map.set(key, value)
-      }
-    },
-    delete: (key: K) => map.delete(key),
-    clear: () => map.clear(),
-    getMany: (keys: K[]) => {
-      const result: V[] = []
-      for (const key of keys) {
-        const value = map.get(key)
-        if (isDefined(value)) {
-          result.push(value)
-        }
-      }
-      return result
-    },
-    [Symbol.iterator]: function* (): Iterator<[K, V]> {
-      for (const entry of map) {
-        yield entry
-      }
-    },
-  }
-}

package/src/primitives/payload/index.ts

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

package/src/primitives/payload/mergeTransfers.ts

@@ -1,16 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { hexToBigInt, toAddress } from '@xylabs/sdk-js'
-import type { Transfer } from '@xyo-network/xl1-protocol-lib'
-
-/** MergeTransfers helper function. */
-export function mergeTransfers(transfers: Transfer[]): Record<Address, Record<Address, bigint>> {
-  const result: Record<Address, Record<Address, bigint>> = {}
-  for (const transfer of transfers) {
-    result[transfer.from] = result[transfer.from] ?? {}
-    for (const [to, value] of Object.entries(transfer.transfers)) {
-      const typedTo = toAddress(to)
-      result[transfer.from][typedTo] = (result[transfer.from][typedTo] ?? 0n) + (hexToBigInt(value))
-    }
-  }
-  return result
-}

package/src/primitives/readPayloadMapFromStore.ts

@@ -1,58 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { isDefined } from '@xylabs/sdk-js'
-import type {
-  ReadArchivist, ReadWriteArchivist,
-  WithStorageMeta,
-} from '@xyo-network/sdk-js'
-import type { PayloadMap, PayloadMapRead } from '@xyo-network/xl1-protocol-lib'
-
-import { isReadArchivist, isReadWriteArchivist } from '../block/index.ts'
-
-/** ReadPayloadMapFromStore helper function. */
-export function readPayloadMapFromStore(store: ReadArchivist | PayloadMapRead): PayloadMapRead {
-  if (isReadArchivist(store)) {
-    return {
-      get: async (hash: Hash) => {
-        return (await store.get([hash]))[0]
-      },
-      getMany: async (hashes: Hash[]) => {
-        return (await store.get(hashes))
-      },
-      has: async (hash: Hash) => {
-        return isDefined((await store.get([hash]))[0])
-      },
-    }
-  }
-  return store
-}
-
-/** PayloadMapFromStore helper function. */
-export function payloadMapFromStore(store: ReadWriteArchivist | PayloadMap): PayloadMap {
-  if (isReadWriteArchivist(store)) {
-    return {
-      get: async (hash: Hash) => {
-        return (await store.get([hash]))[0]
-      },
-      getMany: async (hashes: Hash[]) => {
-        return (await store.get(hashes))
-      },
-      has: async (hash: Hash) => {
-        return isDefined((await store.get([hash]))[0])
-      },
-      clear: async () => {
-        return await store.clear()
-      },
-      delete: async (id: Hash) => {
-        await store.delete([id])
-        return true
-      },
-      set: async (_id: Hash, data: WithStorageMeta) => {
-        await store.insert([data])
-      },
-      setMany: async (entries: [Hash, WithStorageMeta][]) => {
-        await store.insert(entries.map(e => e[1]))
-      },
-    } satisfies PayloadMap<WithStorageMeta>
-  }
-  return store
-}

package/src/primitives/rewardFromBlockNumber.ts

@@ -1,19 +0,0 @@
-import {
-  asAttoXL1, XL1_REWARDS_BLOCKS_PER_STEP, XL1_REWARDS_CREATOR_REWARD,
-  XL1_REWARDS_MIN_BLOCK_REWARD, XL1_REWARDS_STARTING_REWARD, XL1_REWARDS_STEP_FACTOR_DENOMINATOR,
-  XL1_REWARDS_STEP_FACTOR_NUMERATOR, type XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** RewardFromBlockNumber helper function. */
-export function rewardFromBlockNumber(blockNumber: XL1BlockNumber) {
-  if (blockNumber === 0) {
-    return XL1_REWARDS_CREATOR_REWARD
-  }
-  const step = Math.floor((blockNumber + XL1_REWARDS_BLOCKS_PER_STEP) / XL1_REWARDS_BLOCKS_PER_STEP)
-  const stepExp = BigInt(step - 1)
-  const poweredNumerator = stepExp > 0 ? XL1_REWARDS_STEP_FACTOR_NUMERATOR ** stepExp : 1n
-  const poweredDenominator = stepExp > 0 ? XL1_REWARDS_STEP_FACTOR_DENOMINATOR ** stepExp : 1n
-  let reward = (XL1_REWARDS_STARTING_REWARD * poweredNumerator) / poweredDenominator
-  // eslint-disable-next-line unicorn/prefer-math-min-max
-  return asAttoXL1((reward < XL1_REWARDS_MIN_BLOCK_REWARD) ? XL1_REWARDS_MIN_BLOCK_REWARD : reward)
-}

package/src/primitives/rewards/index.ts

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