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

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

package/src/test/buildNextBlock.ts

@@ -1,37 +0,0 @@
-import type { AccountInstance, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, BlockBoundWitness, ChainId,
-  SignedHydratedBlockWithHashMeta,
-  SignedHydratedTransaction,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  AttoXL1,
-  XYO_STEP_REWARD_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { buildBlock } from './buildBlock.ts'
-
-/** Builds a NextBlock instance. */
-export async function buildNextBlock(
-  previousBlock: WithHashMeta<BlockBoundWitness>,
-  txs: SignedHydratedTransaction[],
-  blockPayloads: AllowedBlockPayload[],
-  signers: AccountInstance[],
-  chainStepRewardAddress = XYO_STEP_REWARD_ADDRESS,
-  stepRewardPoolBalance: AttoXL1 = AttoXL1(0n),
-  protocol?: number,
-  chainId?: ChainId,
-): Promise<SignedHydratedBlockWithHashMeta> {
-  return await buildBlock({
-    chainId: chainId ?? previousBlock.chain,
-    previousBlockNumber: previousBlock.block,
-    previousStepHashes: previousBlock.step_hashes ?? [],
-    previousBlockHash: previousBlock._hash,
-    txs,
-    blockPayloads,
-    signers,
-    protocol,
-    chainStepRewardAddress,
-    stepRewardPoolBalance,
-  })
-}

package/src/test/buildRandomChain.ts

@@ -1,92 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { asAddress, assertEx } from '@xylabs/sdk-js'
-import type { AccountInstance, Id } from '@xyo-network/sdk-js'
-import {
-  Account, asSchema, IdSchema,
-  MemoryArchivist,
-  PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import {
-  asXL1BlockNumber,
-  type ChainId, type SignedHydratedBlockWithHashMeta, type SignedHydratedTransactionWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { flattenHydratedBlocks } from '../block/index.ts'
-import { buildRandomTransaction } from '../transaction/index.ts'
-import { buildNextBlock } from './buildNextBlock.ts'
-import { TestChainId } from './buildRandomGenesisBlock.ts'
-import { createGenesisBlock } from './createGenesisBlock.ts'
-
-/** TestGenesisBlockRewardAddress constant. */
-export const TestGenesisBlockRewardAddress = assertEx(asAddress('fa7f0bb865a4bfff3d5e2c726d3e063297014da9'))
-
-/**
- * Creates a chain of blocks
- * @param blockProducer The producer for the chain blocks
- * @param count The number of blocks to build
- * @param previousBlock The previous block from which to build the chain (if none supplied will create genesis block)
- * @returns A chain of blocks
- */
-export const buildRandomChain = async (
-  blockProducer: AccountInstance,
-  count: number = 10,
-  previousBlock?: SignedHydratedBlockWithHashMeta,
-  chainId?: ChainId,
-  transactionAccount?: AccountInstance,
-  receiverAddresses?: Address[],
-): Promise<SignedHydratedBlockWithHashMeta[]> => {
-  const chainIdToUse = chainId ?? TestChainId
-  const blocks: SignedHydratedBlockWithHashMeta[] = []
-  let remaining = count
-  let lastBlock: SignedHydratedBlockWithHashMeta | undefined = previousBlock
-  const transactionAccountToUse = transactionAccount ?? await Account.random()
-  if (!lastBlock) {
-    const block = await createGenesisBlock(
-      blockProducer,
-      chainIdToUse,
-      1_000_000_000n * (10n ** 18n),
-      transactionAccountToUse.address,
-    )
-    blocks.push(block)
-    remaining = remaining - 1
-    lastBlock = block
-  }
-  const resolvedReceiverAddresses = receiverAddresses ?? [((await Account.random()).address)]
-  let saltCounter = 0
-  while (remaining > 0) {
-    saltCounter += 1
-    const payloads = [new PayloadBuilder<Id>({ schema: IdSchema }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()]
-    saltCounter += 1
-    const additionalPrivatePayloads = (remaining % 2 === 0)
-      ? [new PayloadBuilder({ schema: asSchema('network.xyo.private', true) }).fields({ salt: `${Date.now()}-${saltCounter}` }).build()]
-      : []
-    const txs: SignedHydratedTransactionWithHashMeta[] = []
-    for (const receiverAddress of resolvedReceiverAddresses) {
-      txs.push(await buildRandomTransaction(
-        chainIdToUse,
-        [...payloads, ...additionalPrivatePayloads],
-        transactionAccountToUse,
-        asXL1BlockNumber(Math.max(count - remaining - 1000, 0), true),
-        asXL1BlockNumber(count - remaining + 1000, true),
-        [asSchema('network.xyo.private', true)],
-        receiverAddress,
-      ))
-    }
-    const previousBlock = assertEx(lastBlock?.[0], () => new Error('No last block'))
-    const block = await buildNextBlock(previousBlock, txs, [], [blockProducer], transactionAccountToUse.address)
-    blocks.push(block)
-    remaining = remaining - 1
-    lastBlock = block
-  }
-  return blocks
-}
-
-/** Builds a RandomChainArchivist instance. */
-export async function buildRandomChainArchivist(count = 20) {
-  const producerAccount = await Account.random()
-  const blocks = await buildRandomChain(producerAccount, count)
-  const archivist = await MemoryArchivist.create()
-  const payloads = flattenHydratedBlocks(blocks)
-  await archivist.insert(payloads)
-  return archivist
-}