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

package/src/summary/primitives/balances/balancesStepSummaryFromRange.ts

@@ -1,94 +0,0 @@
-import { type Address, spanRootAsync } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { isAnyPayload } from '@xyo-network/sdk-js'
-import type {
-  BlockViewer, CachingContext, MapType, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, StepSizes } from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import { withContextCacheResponse } from '../../../ChainContextHelpers.ts'
-import { netBalancesForPayloads } from '../../../payloads/index.ts'
-import {
-  parseSignedBigInt, type SignedBigInt, toSignedBigInt,
-} from '../../../SignedBigInt.ts'
-import type { BalancesStepSummary } from '../../model/index.ts'
-import { BalancesStepSummarySchema } from '../../model/index.ts'
-
-/** BalancesStepSummaryFromRange helper function. */
-export async function balancesStepSummaryFromRange(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, BalancesStepSummary>,
-  range: XL1BlockRange,
-): Promise<BalancesStepSummary> {
-  const cacheKey = `${range[0]}|${range[1]}`
-  return await withContextCacheResponse(context, 'balancesStepSummaryFromRange', cacheKey, async () => {
-    return await spanRootAsync('balancesStepSummaryFromRange', async () => {
-      // console.log(`balanceStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
-      const [frameHead] = assertEx(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`)
-      const frameSize = range[1] - range[0] + 1
-
-      const key = `${frameHead._hash}|${frameSize}`
-
-      return (frameSize === 1)
-        ? await spanRootAsync(`balancesStepSummaryFromRange.frameSize=1[${key}]`, async () => {
-            const [,payloads] = assertEx(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`)
-            const balances: Record<Address, SignedBigInt> = {}
-            for (const [address, balance] of Object.entries(netBalancesForPayloads(context, payloads))) {
-              balances[address as Address] = toSignedBigInt(balance)
-            }
-            return {
-              schema: BalancesStepSummarySchema, hash: frameHead._hash, stepSize: -1, balances,
-            }
-          }, { ...context, timeBudgetLimit: 500 })
-        : await spanRootAsync(`balancesStepSummaryFromRange.frameSize>1[${key}]`, async () => {
-            const step = StepSizes.indexOf(asXL1BlockNumber(frameSize, true))
-            assertEx(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes.join(', ')}`)
-
-            const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`)
-            if (isAnyPayload(summaryResult)) {
-              return summaryResult as BalancesStepSummary
-            } else {
-            // We do not have it, so lets build it
-              await semaphores[step].acquire()
-              try {
-                const subRanges = deepCalculateFramesFromRange(range, step - 1)
-                const promises = subRanges.map(subRange => balancesStepSummaryFromRange(
-                  context,
-                  semaphores,
-                  blockViewer,
-                  summaryMap,
-                  subRange,
-                ))
-                const subResults = await Promise.all(promises)
-
-                // add them all up
-                const bigIntBalances: Record<Address, bigint> = {}
-                for (const subResult of subResults) {
-                  for (const [address, balance] of Object.entries(subResult.balances)) {
-                    bigIntBalances[address as Address] = (bigIntBalances[address as Address] ?? 0n) + parseSignedBigInt(balance)
-                  }
-                }
-
-                const balances: Record<Address, SignedBigInt> = {}
-                for (const [address, balance] of Object.entries(bigIntBalances)) {
-                  balances[address as Address] = toSignedBigInt(balance)
-                }
-
-                const result = {
-                  schema: BalancesStepSummarySchema, hash: frameHead._hash, stepSize: frameSize, balances,
-                }
-
-                await summaryMap.set(key, result)
-                return result
-              } finally {
-                semaphores[step].release()
-              }
-            }
-          }, { ...context, timeBudgetLimit: 500 })
-    }, { ...context, timeBudgetLimit: 500 })
-  }, { max: 100_000 })
-}

package/src/summary/primitives/balances/balancesSummary.ts

@@ -1,48 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, spanRootAsync,
-} from '@xylabs/sdk-js'
-import type {
-  BlockViewer,
-  CachingContext, ChainQualified, ChainQualifiedConfig,
-  MapType,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asBlockBoundWitnessWithStorageMeta, asXL1BlockRange, isChainQualifiedHeadConfig,
-  isChainQualifiedRangeConfig,
-} from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import { parseSignedBigInt } from '../../../SignedBigInt.ts'
-import type { BalancesStepSummary } from '../../model/index.ts'
-import { balancesStepSummaryFromRange } from './balancesStepSummaryFromRange.ts'
-
-/** BalancesSummary helper function. */
-export async function balancesSummary(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, BalancesStepSummary>,
-  config?: ChainQualifiedConfig,
-): Promise<ChainQualified<Record<Address, bigint>>> {
-  return await spanRootAsync('balancesSummary', async () => {
-    const headHash = isChainQualifiedHeadConfig(config) ? config.head : await blockViewer.currentBlockHash()
-    const [head] = assertEx(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`)
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`)
-    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange([0, headBoundWitness.block], true)
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
-      range,
-      { name: 'balancesSummary' },
-    ))
-    const summaries = await Promise.all(ranges.map(range => balancesStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range)))
-    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, { range, head: headHash }]
-  }, { ...context, timeBudgetLimit: 500 })
-}

package/src/summary/primitives/balances/index.ts

@@ -1,2 +0,0 @@
-export * from './balancesStepSummaryFromRange.ts'
-export * from './balancesSummary.ts'

package/src/summary/primitives/index.ts

@@ -1,3 +0,0 @@
-export * from './balances/index.ts'
-export * from './schemas/index.ts'
-export * from './transfers/index.ts'

package/src/summary/primitives/schemas/index.ts

@@ -1,2 +0,0 @@
-export * from './schemasStepSummaryFromRange.ts'
-export * from './schemasSummary.ts'

package/src/summary/primitives/schemas/schemasStepSummaryFromRange.ts

@@ -1,86 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { Schema, WithHashMeta } from '@xyo-network/sdk-js'
-import {
-  isAnyPayload, isBoundWitness,
-  isHashMeta, PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import type {
-  BlockViewer, CachingContext, MapType, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-import { StepSizes } from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import { type SchemasStepSummary, SchemasStepSummarySchema } from '../../model/index.ts'
-
-/** SchemasStepSummaryFromRange helper function. */
-export async function schemasStepSummaryFromRange(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, WithHashMeta<SchemasStepSummary>>,
-  range: XL1BlockRange,
-): Promise<WithHashMeta<SchemasStepSummary>> {
-  // console.log(`balanceStepSummaryFromRange: head=${head}, range=${range[0]}-${range[1]}`)
-  const [frameHead] = assertEx(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`)
-  const frameSize = range[1] - range[0] + 1
-
-  let result: WithHashMeta<SchemasStepSummary> | undefined = undefined
-
-  if (frameSize === 1) {
-    const [block, payloads] = assertEx(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`)
-    const boundWitnesses = [block, ...payloads.filter(x => isBoundWitness(x) && isHashMeta(x))]
-    const schemas: Record<Schema, number> = {}
-    for (const bw of boundWitnesses) {
-      schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1
-      for (const schema of bw.payload_schemas) {
-        schemas[schema] = (schemas[schema] ?? 0) + 1
-      }
-    }
-    result = await PayloadBuilder.addHashMeta({
-      schema: SchemasStepSummarySchema, hash: frameHead._hash, stepSize: -1, schemas,
-    })
-  } else {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const step = (StepSizes as any).indexOf(frameSize)
-    assertEx(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes.join(', ')}`)
-
-    const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`)
-    if (isAnyPayload(summaryResult)) {
-      result = summaryResult as WithHashMeta<SchemasStepSummary>
-    } else {
-    // We do not have it, so lets build it
-      await semaphores[step].acquire()
-      try {
-        const subRanges = deepCalculateFramesFromRange(range, step - 1)
-        const promises = subRanges.map(subRange => schemasStepSummaryFromRange(
-          context,
-          semaphores,
-          blockViewer,
-          summaryMap,
-          subRange,
-        ))
-        const subResults = await Promise.all(promises)
-
-        // add them all up
-        const schemas: Record<Schema, number> = {}
-        for (const subResult of subResults) {
-          for (const [schema, count] of Object.entries(subResult.schemas)) {
-            const typedSchema = schema as Schema
-            schemas[typedSchema] = (schemas[typedSchema] ?? 0) + count
-          }
-        }
-
-        result = await PayloadBuilder.addHashMeta({
-          schema: SchemasStepSummarySchema, hash: frameHead._hash, stepSize: frameSize, schemas: schemas,
-        })
-
-        await summaryMap.set(`${frameHead._hash}|${frameSize}`, result)
-      } finally {
-        semaphores[step].release()
-      }
-    }
-  }
-  // console.log(`balanceStepSummaryFromRange-result: head=${head}, range=${range[0]}-${range[1]}: ${toSafeJsonString(result, 10)}`)
-  return await PayloadBuilder.addHashMeta(result)
-}

package/src/summary/primitives/schemas/schemasSummary.ts

@@ -1,44 +0,0 @@
-import { assertEx, spanRootAsync } from '@xylabs/sdk-js'
-import type { Schema, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  BlockViewer, CachingContext, ChainQualified, ChainQualifiedConfig,
-  MapType,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asBlockBoundWitnessWithStorageMeta, asXL1BlockRange, isChainQualifiedHeadConfig,
-  isChainQualifiedRangeConfig,
-} from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import type { SchemasStepSummary } from '../../model/index.ts'
-import { schemasStepSummaryFromRange } from './schemasStepSummaryFromRange.ts'
-
-/** SchemasSummary helper function. */
-export async function schemasSummary(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, WithHashMeta<SchemasStepSummary>>,
-  config?: ChainQualifiedConfig,
-): Promise<ChainQualified<Record<Schema, number>>> {
-  return await spanRootAsync('schemasSummary', async () => {
-    const headHash = isChainQualifiedHeadConfig(config) ? config.head : await blockViewer.currentBlockHash()
-    const [head] = assertEx(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`)
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`)
-    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange([0, headBoundWitness.block], true)
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
-      range,
-      { name: 'schemasSummary' },
-    ))
-    const summaries = await Promise.all(ranges.map(range => schemasStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range)))
-    const results: Record<Schema, number> = {}
-    for (let summary of summaries) {
-      for (const [schema, count] of Object.entries(summary.schemas)) {
-        const typedSchema = schema as Schema
-        results[typedSchema] = (results[typedSchema] ?? 0) + count
-      }
-    }
-    return [results, { range, head: headHash }]
-  }, context)
-}

package/src/summary/primitives/transfers/index.ts

@@ -1,2 +0,0 @@
-export * from './transfersStepSummaryFromRange.ts'
-export * from './transfersSummary.ts'

package/src/summary/primitives/transfers/transfersStepSummaryFromRange.ts

@@ -1,109 +0,0 @@
-/* eslint-disable max-statements */
-import type { Address, Hash } from '@xylabs/sdk-js'
-import { assertEx, spanRootAsync } from '@xylabs/sdk-js'
-import { isAnyPayload } from '@xyo-network/sdk-js'
-import type {
-  BlockViewer, CachingContext, MapType, XL1BlockRange,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, StepSizes } from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import { withContextCacheResponse } from '../../../ChainContextHelpers.ts'
-import { netTransfersForPayloads } from '../../../payloads/index.ts'
-import {
-  parseSignedBigInt, type SignedBigInt, toSignedBigInt,
-} from '../../../SignedBigInt.ts'
-import {
-  asTransfersStepSummary, type TransfersStepSummary, TransfersStepSummarySchema,
-} from '../../model/index.ts'
-
-/** TransfersSummaryKey helper function. */
-export function transfersSummaryKey(frameHeadHash: Hash, frameSize: number) {
-  return `${frameHeadHash}|${frameSize}`
-}
-
-/** TransfersStepSummaryFromRange helper function. */
-export async function transfersStepSummaryFromRange(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, TransfersStepSummary>,
-  range: XL1BlockRange,
-): Promise<TransfersStepSummary> {
-  const cacheKey = `${range[0]}|${range[1]}`
-  return await withContextCacheResponse(context, 'transfersStepSummaryFromRange', cacheKey, async () => {
-    return await spanRootAsync('transfersStepSummaryFromRange', async () => {
-      const [frameHead] = assertEx(await blockViewer.blockByNumber(range[1]), () => `Block not found for number: ${range[1]}`)
-      const frameSize = range[1] - range[0] + 1
-
-      let result: TransfersStepSummary | undefined
-
-      if (frameSize === 1) {
-        const [, payloads] = assertEx(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`)
-        const transfers: Record<Address, Record<Address, SignedBigInt>> = {}
-        for (const [from, toMap] of Object.entries(netTransfersForPayloads(context, payloads))) {
-          transfers[from as Address] = transfers[from as Address] ?? {}
-          for (const [to, amount] of Object.entries(toMap)) {
-            transfers[from as Address][to as Address] = toSignedBigInt(amount)
-          }
-        }
-        result = {
-          schema: TransfersStepSummarySchema, hash: frameHead._hash, stepSize: -1, transfers,
-        }
-      } else {
-        const step = (StepSizes).indexOf(asXL1BlockNumber(frameSize, true))
-        assertEx(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes.join(', ')}`)
-
-        const key = transfersSummaryKey(frameHead._hash, frameSize)
-
-        const summaryResult = await summaryMap.get(key)
-        if (isAnyPayload(summaryResult)) {
-          result = asTransfersStepSummary(summaryResult, { required: true })
-        } else {
-          await semaphores[step].acquire()
-          // We do not have it, so lets build it
-          try {
-            const subRanges = deepCalculateFramesFromRange(range, step - 1)
-            const promises = subRanges.map(subRange => transfersStepSummaryFromRange(
-              context,
-              semaphores,
-              blockViewer,
-              summaryMap,
-              subRange,
-            ))
-            const subResults = await Promise.all(promises)
-
-            // add them all up
-            const bigIntBalances: Record<Address, Record<Address, bigint>> = {}
-            for (const subResult of subResults) {
-              for (const [from, toMap] of Object.entries(subResult.transfers)) {
-                bigIntBalances[from as Address] = bigIntBalances[from as Address] ?? {}
-                for (const [to, transfer] of Object.entries(toMap)) {
-                  bigIntBalances[from as Address][to as Address] = (bigIntBalances[from as Address][to as Address] ?? 0n) + parseSignedBigInt(transfer)
-                }
-              }
-            }
-
-            const transfers: Record<Address, Record<Address, SignedBigInt>> = {}
-            for (const [from, toMap] of Object.entries(bigIntBalances)) {
-              transfers[from as Address] = transfers[from as Address] ?? {}
-              for (const [to, transfer] of Object.entries(toMap)) {
-                transfers[from as Address][to as Address] = toSignedBigInt(transfer)
-              }
-            }
-
-            result = {
-              schema: TransfersStepSummarySchema, hash: frameHead._hash, stepSize: frameSize, transfers,
-            }
-
-            await summaryMap.set(key, result)
-          } finally {
-            semaphores[step].release()
-          }
-        }
-      }
-      return result
-    }, { ...context, timeBudgetLimit: 500 })
-  }, { max: 100_000 })
-}

package/src/summary/primitives/transfers/transfersSummary.ts

@@ -1,52 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, spanRootAsync,
-} from '@xylabs/sdk-js'
-import type {
-  BlockViewer, CachingContext, ChainQualified, ChainQualifiedConfig,
-  MapType,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asBlockBoundWitnessWithStorageMeta, asXL1BlockRange, isChainQualifiedHeadConfig,
-  isChainQualifiedRangeConfig,
-} from '@xyo-network/xl1-protocol-lib'
-import type { Semaphore } from 'async-mutex'
-
-import { deepCalculateFramesFromRange } from '../../../block/index.ts'
-import { parseSignedBigInt } from '../../../SignedBigInt.ts'
-import type { TransfersStepSummary } from '../../model/index.ts'
-import { transfersStepSummaryFromRange } from './transfersStepSummaryFromRange.ts'
-
-// the summary of amount of rewards claimed from the step reward pool by addresses
-/** TransfersSummary helper function. */
-export async function transfersSummary(
-  context: CachingContext,
-  semaphores: Semaphore[],
-  blockViewer: BlockViewer,
-  summaryMap: MapType<string, TransfersStepSummary>,
-  config?: ChainQualifiedConfig,
-): Promise<ChainQualified<Record<Address, Record<Address, bigint>>>> {
-  return await spanRootAsync('transferSummary', async () => {
-    const headHash = isChainQualifiedHeadConfig(config) ? config.head : await blockViewer.currentBlockHash()
-    const [head] = assertEx(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`)
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`)
-    const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange([0, headBoundWitness.block], true)
-    const ranges = deepCalculateFramesFromRange(asXL1BlockRange(
-      range,
-      { name: 'transfersSummary' },
-    ))
-    const summaries = await Promise.all(ranges.map(range => transfersStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range)))
-    const transfers: Record<Address, Record<Address, bigint>> = {}
-    for (let summary of summaries) {
-      for (const [from, toMap] of Object.entries(summary.transfers)) {
-        const validFrom = asAddress(from, () => `Invalid address: ${from}`)
-        transfers[validFrom] = transfers[validFrom] ?? {}
-        for (const [to, transfer] of Object.entries(toMap)) {
-          const validTo = asAddress(to, () => `Invalid address: ${to}`)
-          transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer)
-        }
-      }
-    }
-    return [transfers, { range, head: headHash }]
-  }, { ...context, timeBudgetLimit: 500 })
-}

package/src/test/BuildBlockOptions.ts

@@ -1,81 +0,0 @@
-import type { Address, Hash } from '@xylabs/sdk-js'
-import {
-  isAddress, isArray, isHash,
-  isNumber, isObject,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, AttoXL1, ChainId, SignedHydratedTransaction, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-/** Options for BaseBuildBlock. */
-export interface BaseBuildBlockOptions {
-  blockPayloads: AllowedBlockPayload[]
-  chainId: ChainId
-  chainStepRewardAddress?: Address
-  previousBlockNumber?: XL1BlockNumber
-  protocol?: number
-  signers: AccountInstance[]
-  txs: SignedHydratedTransaction[]
-}
-
-/** Type guard that checks if a value is a valid BaseBuildBlockOptions. */
-export const isBaseBuildBlockOptions = (value: unknown): value is BaseBuildBlockOptions => {
-  if (!isObject(value)) {
-    return false
-  }
-  const typedValue = value as BaseBuildBlockOptions
-  if (!isArray(typedValue.blockPayloads) || !isAddress(typedValue.chainId) || !isArray(typedValue.signers) || !isArray(typedValue.txs)) {
-    return false
-  }
-  return true
-}
-
-/** Options for BuildGenesisBlock. */
-export interface BuildGenesisBlockOptions extends BaseBuildBlockOptions {
-  previousBlockHash: null
-}
-
-/** Type guard that checks if a value is a valid BuildGenesisBlockOptions. */
-export const isBuildGenesisBlockOptions = (value: unknown): value is BuildGenesisBlockOptions => {
-  if (!isBaseBuildBlockOptions(value)) {
-    return false
-  }
-  const typedValue = value as BuildGenesisBlockOptions
-  if (typedValue.previousBlockHash !== null) {
-    return false
-  }
-  if (typedValue.previousBlockNumber !== undefined) {
-    return false
-  }
-  return true
-}
-
-/** Options for BuildNextBlock. */
-export interface BuildNextBlockOptions extends BaseBuildBlockOptions {
-  previousBlockHash: Hash
-  previousBlockNumber: XL1BlockNumber
-  previousStepHashes: Hash[]
-  stepRewardPoolBalance: AttoXL1
-}
-
-/** Type guard that checks if a value is a valid BuildNextBlockOptions. */
-export const isBuildNextBlockOptions = (value: unknown): value is BuildNextBlockOptions => {
-  if (!isBaseBuildBlockOptions(value)) {
-    return false
-  }
-  const typedValue = value as BuildNextBlockOptions
-  if (!isHash(typedValue.previousBlockHash)) {
-    return false
-  }
-  if (!isNumber(typedValue.previousBlockNumber)) {
-    return false
-  }
-  if (!isArray(typedValue.previousStepHashes)) {
-    return false
-  }
-  return true
-}
-
-/** BuildBlockOptions type. */
-export type BuildBlockOptions = BuildGenesisBlockOptions | BuildNextBlockOptions

package/src/test/buildBlock.ts

@@ -1,105 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-import { assertEx, isDefined } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asAnyPayload, BoundWitnessBuilder, PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import type {
-  BlockBoundWitness, SignedHydratedBlockWithHashMeta, Transfer,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber, AttoXL1, isBlockBoundWitness, StepRewardFractions,
-  StepSizes,
-  XL1_PROTOCOL_VERSION,
-  XYO_STEP_REWARD_ADDRESS,
-  XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { validateTransactionsOpcodes } from '../block/index.ts'
-import { createTransferPayload } from '../createTransferPayload.ts'
-import { completedStepRewardAddress } from '../primitives/index.ts'
-import {
-  type BuildBlockOptions, isBuildGenesisBlockOptions, isBuildNextBlockOptions,
-} from './BuildBlockOptions.ts'
-
-/*
-//this is for testing only to speed up the pace
-export const StepRewardFractions = [
-  [0n, 1n], // 0%
-  [1n, 10_000n], // 0.01%
-  [2n, 1000n], // 0.2%
-  [3n, 100n], // 3%
-  [45n, 100n], // 45%
-] as const
- */
-
-function calculateCompletedStepReward(step: number, balance: AttoXL1): AttoXL1 {
-  return AttoXL1(StepRewardFractions[step][0] * balance / StepRewardFractions[step][1])
-}
-
-/** Builds a Block instance. */
-export async function buildBlock(options: BuildBlockOptions): Promise<SignedHydratedBlockWithHashMeta> {
-  const previousBlockNumber = isBuildGenesisBlockOptions(options) ? -1 : options.previousBlockNumber
-  const blockNumber = asXL1BlockNumber(previousBlockNumber + 1, true)
-  const inStepHashes = isBuildNextBlockOptions(options) ? options.previousStepHashes : []
-  const previousBlockHash = isBuildNextBlockOptions(options) ? options.previousBlockHash : undefined
-  const stepRewardPoolBalance = isBuildNextBlockOptions(options) ? options.stepRewardPoolBalance : AttoXL1(0n)
-  const {
-    chainId, txs,
-    chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS,
-    blockPayloads, protocol = XL1_PROTOCOL_VERSION, signers,
-  } = options
-  const step_hashes: Hex[] = []
-
-  for (const [tx] of txs) {
-    if (tx.nbf > blockNumber) {
-      throw new Error(`Transaction ${await PayloadBuilder.hash(tx)} not valid for block ${blockNumber} - NBF is ${tx.nbf}`)
-    }
-    if (tx.exp < blockNumber) {
-      throw new Error(`Transaction ${await PayloadBuilder.hash(tx)} not valid for block ${blockNumber} - EXP is ${tx.exp}`)
-    }
-  }
-
-  const completedStepRewardTransfers: Transfer[] = []
-
-  // update the step hashes
-  for (const [i, step] of StepSizes.entries()) {
-    if (blockNumber < step) {
-      break
-    }
-    if (blockNumber % step === 0) {
-      if (StepRewardFractions[i][0] > 0 && chainStepRewardAddress !== XYO_ZERO_ADDRESS) {
-        const completedStepRewardHolderAddress = completedStepRewardAddress({ block: blockNumber, step })
-        const completedStepReward = calculateCompletedStepReward(i, stepRewardPoolBalance)
-        completedStepRewardTransfers.push(createTransferPayload(chainStepRewardAddress, { [completedStepRewardHolderAddress]: completedStepReward }))
-      }
-      step_hashes.push(assertEx(previousBlockHash, () => `Previous block hash is required for step ${step} at block ${blockNumber}`))
-    } else {
-      if (isDefined(inStepHashes.at(i))) {
-        step_hashes.push(inStepHashes[i])
-      }
-    }
-  }
-
-  const previous = previousBlockHash ?? null
-  const block = blockNumber
-  const txElevatedPayloads = await validateTransactionsOpcodes(txs)
-
-  const payloads: Payload[] = [
-    ...txs.map(([tx]) => tx),
-    ...blockPayloads,
-    ...txElevatedPayloads,
-    ...completedStepRewardTransfers,
-  ]
-
-  const [bw, txPayloads] = await new BoundWitnessBuilder<BlockBoundWitness, WithStorageMeta<Payload>>()
-    .fields({
-      block, chain: chainId, previous, step_hashes, protocol,
-    })
-    .meta({ $epoch: Date.now(), $signatures: [] })
-    .signers(signers)
-    .payloads(await PayloadBuilder.addStorageMeta(payloads))
-    .build()
-  assertEx(isBlockBoundWitness(bw), () => 'Build of BlockBoundWitness failed')
-  return [await PayloadBuilder.addStorageMeta(bw), txPayloads.map(p => asAnyPayload(p, true))]
-}

package/src/test/buildGenesisBlock.ts

@@ -1,29 +0,0 @@
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId,
-  SignedHydratedBlockWithHashMeta,
-  SignedHydratedTransactionWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-import { XYO_ZERO_ADDRESS } from '@xyo-network/xl1-protocol-lib'
-
-import { buildBlock } from './buildBlock.ts'
-
-/** Builds a GenesisBlock instance. */
-export async function buildGenesisBlock(
-  chainId: ChainId,
-  txs: SignedHydratedTransactionWithHashMeta[],
-  blockPayloads: AllowedBlockPayload[],
-  signers: AccountInstance[],
-  chainStepRewardAddress = XYO_ZERO_ADDRESS,
-  protocol?: number,
-): Promise<SignedHydratedBlockWithHashMeta> {
-  return await buildBlock({
-    previousBlockHash: null,
-    chainId,
-    txs,
-    blockPayloads,
-    signers,
-    chainStepRewardAddress,
-    protocol,
-  })
-}