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

package/src/amount/index.ts

@@ -1,4 +0,0 @@
-export * from './ShiftedBigInt.ts'
-export * from './splitOnDecimal.ts'
-export * from './splitOnDecimalToString.ts'
-export * from './XL1Amount.ts'

package/src/amount/splitOnDecimal.ts

@@ -1,6 +0,0 @@
-/** Splits a bigint into whole and decimal parts based on the specified number of decimal places */
-export const splitOnDecimal = (value: bigint, places = 18): [bigint, bigint] => {
-  const whole = value / BigInt(10 ** places)
-  const decimal = value % BigInt(10 ** places)
-  return [whole, decimal]
-}

package/src/amount/splitOnDecimalToString.ts

@@ -1,40 +0,0 @@
-import { splitOnDecimal } from './splitOnDecimal.ts'
-
-/** Formats a bigint as a locale-aware decimal string with configurable precision and character limits */
-export const splitOnDecimalToString = (
-  value: bigint,
-  places = 18,
-  maxDecimal = places,
-  maxCharacters = 9,
-  minDecimals = 1,
-  locale: Intl.LocalesArgument = 'en-US',
-): string => {
-  const [whole, decimal] = splitOnDecimal(value, places)
-  const remainderLength = decimal.toString().length
-  const precedingZerosInDecimal = places - remainderLength
-  if (whole === 0n && precedingZerosInDecimal >= maxDecimal && decimal !== 0n) return '< 0.'.padEnd(maxDecimal + 5, '0') + '1'
-
-  const wholeCharacters = whole.toString(10).length
-  const calcMaxDecimalCharacters = maxCharacters === -1 ? places : wholeCharacters > maxCharacters ? 0 : maxCharacters - wholeCharacters
-  const maxDecimalCharacters = Math.min(maxDecimal, calcMaxDecimalCharacters)
-
-  // Format whole number with thousand separators according to locale
-  const formattedWhole = new Intl.NumberFormat(locale, {
-    maximumFractionDigits: 0,
-    useGrouping: true,
-  }).format(whole)
-
-  // Get decimal separator for the locale
-  const decimalSeparator = new Intl.NumberFormat(locale)
-    .formatToParts(1.1)
-    .find(part => part.type === 'decimal')?.value ?? '.'
-
-  // Pad decimal part to correct number of places
-  let paddedDecimal = decimal.toString().padStart(places, '0').slice(0, maxDecimalCharacters)
-  // remove unneeded trailing zeros (honoring minDecimals)
-  while (paddedDecimal.length > minDecimals && paddedDecimal.endsWith('0')) {
-    paddedDecimal = paddedDecimal.slice(0, -1)
-  }
-
-  return `${formattedWhole}${paddedDecimal.length > 0 ? decimalSeparator : ''}${paddedDecimal}`
-}

package/src/block/hydrate/allHashesPresent.ts

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

package/src/block/hydrate/blockPayloadsFromHydratedBlock.ts

@@ -1,12 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import type { HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-/** blockPayloadsFromHydratedBlock constant. */
-export const blockPayloadsFromHydratedBlock = (block: HydratedBlockWithStorageMeta): WithStorageMeta[] => {
-  return block[0].payload_hashes.map(hash => assertEx(
-    block[1].find(p => p._hash === hash),
-    () => `missing payload ${hash}`,
-  )).filter(x => !isTransactionBoundWitness(x))
-}

package/src/block/hydrate/flattenHydratedBlock.ts

@@ -1,28 +0,0 @@
-import type { Payload } from '@xyo-network/sdk-js'
-import { type BlockBoundWitness, toHydratedBlock } from '@xyo-network/xl1-protocol-lib'
-
-/** flattenHydratedBlock constant. */
-export const flattenHydratedBlock = <B extends BlockBoundWitness, P extends Payload>(hydratedBlock: [B, P[]]): (P | B)[] => {
-  const [blk, blkPayloads] = hydratedBlock
-  return [...blkPayloads, blk]
-}
-
-/** tryUnflattenHydratedBlock constant. */
-export const tryUnflattenHydratedBlock = <
-  B extends BlockBoundWitness,
-  P extends Payload,
->(flattened: (P | B)[]): [B, P[]] | undefined => {
-  // Last element is the block
-  const blk = flattened.at(-1) as B
-
-  // All previous elements are payloads
-  const payloads = flattened.slice(0, -1) as P[]
-
-  return toHydratedBlock([blk, payloads])
-}
-
-/** unflattenHydratedBlock constant. */
-export const unflattenHydratedBlock = <
-  B extends BlockBoundWitness,
-  P extends Payload,
->(flattened: (P | B)[]): [B, P[]] => toHydratedBlock(tryUnflattenHydratedBlock(flattened), true) as [B, P[]]

package/src/block/hydrate/flattenHydratedBlocks.ts

@@ -1,7 +0,0 @@
-import type { HydratedBlock } from '@xyo-network/xl1-protocol-lib'
-
-import { flattenHydratedBlock } from './flattenHydratedBlock.ts'
-
-/** flattenHydratedBlocks constant. */
-export const flattenHydratedBlocks = <T extends HydratedBlock>(hydratedBlocks: T[]): (T[0] | T[1][number])[] =>
-  hydratedBlocks.flatMap(blk => flattenHydratedBlock(blk))

package/src/block/hydrate/hydrateBlock.ts

@@ -1,43 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import { asAnyPayload } from '@xyo-network/sdk-js'
-import type { BlockContextRead, HydratedBlockWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-import { allHashesPresent } from './allHashesPresent.ts'
-
-/** hydrateBlock constant. */
-export const hydrateBlock = async (
-  context: BlockContextRead,
-  hash: Hash,
-  maxDepth: number = 1,
-  minDepth = maxDepth,
-): Promise<HydratedBlockWithStorageMeta> => {
-  assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
-  assertEx(minDepth >= 0, () => 'minDepth must be greater than or equal to 0')
-  assertEx(maxDepth >= minDepth, () => 'maxDepth must be greater than or equal to minDepth')
-
-  const { chainMap } = context
-
-  const [block] = await chainMap.get([hash])
-  const bw = assertEx(asBlockBoundWitnessWithStorageMeta(
-    assertEx(block, () => `block ${hash} not found`),
-  ), () => `hash ${hash} is not a BlockBoundWitness`)
-
-  if (maxDepth === 0) return [bw, []]
-  const blkPayloads = (await chainMap.get(bw.payload_hashes)).map(p => asAnyPayload(p, true))
-  if (minDepth === 1) assertEx(allHashesPresent(bw.payload_hashes, blkPayloads), () => `Unable to find all payloads for block ${hash}`)
-  if (maxDepth === 1) return [bw, blkPayloads]
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta)
-  const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
-  const transactionsPayloads = (await chainMap.get(transactionsPayloadHashes)).map(p => asAnyPayload(p, true))
-  assertEx(allHashesPresent(transactionsPayloadHashes, transactionsPayloads), () => `Unable to find all payloads for transactions in block ${hash}`)
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
-  const allPayloads = (await chainMap.get([...allPayloadsHashes])).map(p => asAnyPayload(p, true))
-  const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
-  if (maxDepth === 2) assertEx(allHashesPresent(
-    [...allPayloadsHashes],
-    allPayloadsFiltered,
-  ), () => `Unable to find all payloads for transactions in block ${hash}`)
-  return [bw, allPayloadsFiltered]
-}

package/src/block/hydrate/index.ts

@@ -1,7 +0,0 @@
-export * from './allHashesPresent.ts'
-export * from './blockPayloadsFromHydratedBlock.ts'
-export * from './flattenHydratedBlock.ts'
-export * from './flattenHydratedBlocks.ts'
-export * from './hydrateBlock.ts'
-export * from './transactionsFromHydratedBlock.ts'
-export * from './tryHydrateBlock.ts'

package/src/block/hydrate/transactionsFromHydratedBlock.ts

@@ -1,7 +0,0 @@
-import type { HydratedBlock, TransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-import { isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-/** transactionsFromHydratedBlock constant. */
-export const transactionsFromHydratedBlock = (block: HydratedBlock): TransactionBoundWitnessWithStorageMeta[] => {
-  return block[1].filter(isTransactionBoundWitnessWithStorageMeta)
-}

package/src/block/hydrate/tryHydrateBlock.ts

@@ -1,26 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { ReadArchivist } from '@xyo-network/sdk-js'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol-lib'
-import { isBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol-lib'
-
-/** tryHydrateBlock constant. */
-export const tryHydrateBlock = async (
-  archivist: ReadArchivist,
-  hash: Hash,
-  maxDepth: number = 1,
-): Promise<HydratedBlock | undefined> => {
-  assertEx(maxDepth >= 0, () => 'maxDepth must be greater than or equal to 0')
-  const bw = (await archivist.get([hash])).find(isBlockBoundWitnessWithStorageMeta)
-  if (!bw) return undefined
-  if (maxDepth === 0) return [bw, []]
-  const blkPayloads = await archivist.get(bw.payload_hashes)
-  if (maxDepth === 1) return [bw, blkPayloads]
-  const transactions = blkPayloads.filter(isTransactionBoundWitnessWithStorageMeta)
-  const transactionsPayloadHashes = transactions.flatMap(tx => tx.payload_hashes)
-  const transactionsPayloads = await archivist.get(transactionsPayloadHashes)
-  const allPayloadsHashes = new Set([...blkPayloads, ...transactionsPayloads].flatMap(p => p._hash))
-  const allPayloads = await archivist.get([...allPayloadsHashes])
-  const allPayloadsFiltered = allPayloads.filter(p => allPayloadsHashes.has(p._hash))
-  return [bw, allPayloadsFiltered]
-}

package/src/block/index.ts

@@ -1,2 +0,0 @@
-export * from './hydrate/index.ts'
-export * from './primitives/index.ts'

package/src/block/primitives/blockFromBlockNumber.ts

@@ -1,69 +0,0 @@
-import {
-  asHash, type Hash, isDefined,
-  spanAsync,
-} from '@xylabs/sdk-js'
-import { toSafeJsonString } from '@xylabs/sdk-js'
-import type { Signed, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  BlockBoundWitness, ChainContextRead, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asSignedBlockBoundWitnessWithStorageMeta, SignedBlockBoundWitnessWithHashMetaZod, StepSizes,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { withContextCacheResponse } from '../../ChainContextHelpers.ts'
-
-/** BlockFromBlockNumber helper function. */
-export async function blockFromBlockNumber(
-  context: ChainContextRead,
-  blockNumber: XL1BlockNumber,
-): Promise<WithHashMeta<Signed<BlockBoundWitness>>> {
-  return await spanAsync('blockFromBlockNumber', async () => {
-    const cacheKey = `${blockNumber}`
-    const { chainMap, head } = context
-    return await withContextCacheResponse(context, 'blockFromBlockNumber', cacheKey, async () => {
-      const [result] = await chainMap.get([head._hash])
-      if (!isDefined(result)) {
-        throw new Error(`Head block not found for hash: ${head._hash}`)
-      }
-      let currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-        result,
-        () => `Found Payload is not a Signed<BlockBoundWitness>: ${JSON.stringify(result, null, 2)}`,
-      )
-      if (currentBlock.block < blockNumber) {
-        throw new Error(`Block number ${blockNumber} is greater than head ${currentBlock.block}.`)
-      }
-      while (currentBlock.block > blockNumber) {
-        let jumpHash: Hash | null = currentBlock.previous
-        let jumpBlockNumber = currentBlock.block - 1
-        for (const [step, stepSize] of StepSizes.entries()) {
-          const possibleJumpBlockNumber = currentBlock.block - (currentBlock.block % stepSize) - 1
-          if (possibleJumpBlockNumber >= blockNumber && possibleJumpBlockNumber <= jumpBlockNumber) {
-            jumpBlockNumber = possibleJumpBlockNumber
-            jumpHash = asHash(currentBlock.step_hashes?.at(step), () => `Step hash not found for step ${step} in block ${currentBlock.block}`)
-          }
-        }
-        const [newBlock] = await chainMap.get([
-          asHash(jumpHash, () => `Jump hash not found for block number [${blockNumber}]: ${jumpBlockNumber} ${toSafeJsonString(currentBlock, 10)}`),
-        ])
-        if (!isDefined(newBlock)) {
-          throw new Error(`Block not found for jump hash: ${jumpHash}`)
-        }
-        currentBlock = asSignedBlockBoundWitnessWithStorageMeta(
-          newBlock,
-          () => {
-            const result = SignedBlockBoundWitnessWithHashMetaZod.safeParse(newBlock)
-            return `Found Payload [jump hash] is not a Signed<BlockBoundWitness>: ${result.error}`
-          },
-        )
-        if (currentBlock.block === blockNumber) {
-          break
-        }
-        if (currentBlock.block < blockNumber) {
-          throw new Error(`Block number ${blockNumber} is not a valid step block number for block ${head._hash}.`)
-        }
-      }
-      return currentBlock
-    })
-  }, { ...context, timeBudgetLimit: 500 })
-}

package/src/block/primitives/frames/calculateFramesFromRange.ts

@@ -1,30 +0,0 @@
-import type { XL1BlockRange } from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, stepSize } from '@xyo-network/xl1-protocol-lib'
-
-/** CalculateFramesFromRange helper function. */
-export function calculateFramesFromRange(range: XL1BlockRange, step: number): [
-  // ranges of fitted frames
-  XL1BlockRange[],
-  // ranges of remaining blocks
-  XL1BlockRange[]] {
-  const size = stepSize(step)
-  let start = (Math.trunc(range[0] / size)) * size
-  const fitted: XL1BlockRange[] = []
-  const remaining: XL1BlockRange[] = []
-
-  // if the start is not aligned with the range, add a remaining block
-  if (start !== range[0]) {
-    start += size
-    remaining.push([range[0], asXL1BlockNumber(Math.min(start - 1, range[1]), true)])
-  }
-
-  for (let i = start; i <= range[1]; i += size) {
-    if ((i + size - 1) <= range[1]) {
-      fitted.push([asXL1BlockNumber(i, { name: 'calculateFramesFromRange A' }),
-        asXL1BlockNumber(Math.min(i + size - 1, range[1]), { name: 'calculateFramesFromRange B' })])
-    } else {
-      remaining.push([asXL1BlockNumber(i, { name: 'calculateFramesFromRange C' }), range[1]])
-    }
-  }
-  return [fitted, remaining]
-}

package/src/block/primitives/frames/deepCalculateFramesFromRange.ts

@@ -1,28 +0,0 @@
-import type { XL1BlockRange } from '@xyo-network/xl1-protocol-lib'
-import { StepSizes } from '@xyo-network/xl1-protocol-lib'
-
-import { calculateFramesFromRange } from './calculateFramesFromRange.ts'
-
-/** DeepCalculateFramesFromRange helper function. */
-export function deepCalculateFramesFromRange(range: XL1BlockRange, startingStep = StepSizes.length - 1): XL1BlockRange[] {
-  const fitted: XL1BlockRange[] = []
-  let remaining: XL1BlockRange[] = [range]
-
-  for (let step = startingStep; step >= 0; step--) {
-    const newRemaining: XL1BlockRange[] = []
-    for (const range of remaining) {
-      const [newFittedFrames, newRemainingFrames] = calculateFramesFromRange(range, step)
-      fitted.push(...newFittedFrames)
-      newRemaining.push(...newRemainingFrames)
-    }
-    remaining = newRemaining
-  }
-
-  for (const range of remaining) {
-    for (let i = range[0]; i <= range[1]; i++) {
-      fitted.push([i, i]) // Add individual frames for remaining ranges
-    }
-  }
-
-  return fitted.toSorted((a, b) => a[0] - b[0]) // Sort by start of range
-}

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

@@ -1,2 +0,0 @@
-export * from './calculateFramesFromRange.ts'
-export * from './deepCalculateFramesFromRange.ts'

package/src/block/primitives/hashFromBlockNumber.ts

@@ -1,9 +0,0 @@
-import { type Hash } from '@xylabs/sdk-js'
-import type { ChainContextRead, XL1BlockNumber } from '@xyo-network/xl1-protocol-lib'
-
-import { blockFromBlockNumber } from './blockFromBlockNumber.ts'
-
-/** HashFromBlockNumber helper function. */
-export async function hashFromBlockNumber(context: ChainContextRead, blockNumber: XL1BlockNumber): Promise<Hash> {
-  return (await blockFromBlockNumber(context, blockNumber))._hash
-}

package/src/block/primitives/index.ts

@@ -1,7 +0,0 @@
-export * from './blockFromBlockNumber.ts'
-export * from './frames/index.ts'
-export * from './hashFromBlockNumber.ts'
-export * from './model.ts'
-export * from './payloads/index.ts'
-export * from './toStepIdentityString.ts'
-export * from './validateTransactionOpcodes.ts'

package/src/block/primitives/model.ts

@@ -1,18 +0,0 @@
-import type {
-  ReadArchivist, ReadWriteArchivist, WriteArchivist,
-} from '@xyo-network/sdk-js'
-
-/** Type guard that checks if a value is a valid ReadArchivist. */
-export function isReadArchivist(value: unknown): value is ReadArchivist {
-  return (value as ReadArchivist).get !== undefined && (value as ReadArchivist).next !== undefined
-}
-
-/** Type guard that checks if a value is a valid WriteArchivist. */
-export function isWriteArchivist(value: unknown): value is WriteArchivist {
-  return (value as WriteArchivist).insert !== undefined
-}
-
-/** Type guard that checks if a value is a valid ReadWriteArchivist. */
-export function isReadWriteArchivist(value: unknown): value is ReadWriteArchivist {
-  return isReadArchivist(value) && isWriteArchivist(value)
-}

package/src/block/primitives/payloads/ChainWindow.ts

@@ -1,7 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-
-/** ChainWindow interface. */
-export interface ChainWindow {
-  depth: number // number of blocks the window covers, including the head
-  head: Hash // the head of the chain
-}

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

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

package/src/block/primitives/toStepIdentityString.ts

@@ -1,6 +0,0 @@
-import type { StepIdentity, StepIdentityString } from '@xyo-network/xl1-protocol-lib'
-
-/** Converts a value to StepIdentityString format. */
-export function toStepIdentityString({ block, step }: StepIdentity): StepIdentityString {
-  return `${block}|${step}` as StepIdentityString
-}

package/src/block/primitives/validateTransactionOpcodes.ts

@@ -1,45 +0,0 @@
-import {
-  assertEx, isHash, toSafeJsonString,
-} from '@xylabs/sdk-js'
-import {
-  type Payload, PayloadBuilder, type WithStorageMeta,
-} from '@xyo-network/sdk-js'
-import type { HydratedTransaction } from '@xyo-network/xl1-protocol-lib'
-import { isExecutable } from '@xyo-network/xl1-protocol-lib'
-
-/** Validates TransactionsOpcodes and returns any errors found. */
-export async function validateTransactionsOpcodes(txs: HydratedTransaction[]) {
-  const txElevatedPayloads: WithStorageMeta<Payload>[] = []
-  for (const [txBw, txPayloads] of txs) {
-    if (isExecutable(txBw)) {
-      const operations = txBw.script.map(op => op.split('|'))
-      for (let [opCode, ...args] of operations) {
-        switch (opCode) {
-          case 'elevate': {
-            const [hash, ...rest] = args
-            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads)
-            assertEx(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args} - Too many Arguments`)
-            if (isHash(hash)) {
-              assertEx(
-                txBw.payload_hashes.includes(hash),
-                () => `Invalid elevate operation ${opCode} ${args} - Hash not in payload hashes => ${toSafeJsonString(txBw, 20)}`,
-              )
-              const txPayload = assertEx(
-                txPayloadsWithStorageMeta.find(p => p._hash === hash),
-                () => `Invalid elevate operation ${opCode} ${args} - Payload not found`,
-              )
-              txElevatedPayloads.push(txPayload)
-            } else {
-              throw new Error(`Invalid elevate operation ${opCode} ${args} - Invalid hash`)
-            }
-            break
-          }
-          default: {
-            throw new Error(`Invalid opCode ${opCode}`)
-          }
-        }
-      }
-    }
-  }
-  return txElevatedPayloads
-}

package/src/config/Actor.ts

@@ -1,32 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-import { MnemonicStringZod } from '../validation/index.ts'
-import { BaseConfigZod } from './Base.ts'
-
-/** ActorConfigZod constant. */
-export const ActorConfigZod = BaseConfigZod.extend({
-  name: z.string(),
-  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
-    description: 'Mnemonic for the Actor wallet',
-    title: 'mnemonic',
-    type: 'string',
-  }),
-  healthCheckPort: z.coerce.number().optional().register(globalRegistry, {
-    description: 'Port for the Producer health checks',
-    title: 'producer.healthCheckPort',
-    type: 'number',
-  }),
-})
-
-/** ActorConfig type. */
-export type ActorConfig = z.infer<typeof ActorConfigZod>
-
-/** Type guard that checks if a value is a valid ActorConfig. */
-export const isActorConfig = zodIsFactory(ActorConfigZod)
-/** Converts a value to ActorConfig, throwing if invalid. */
-export const asActorConfig = zodAsFactory(ActorConfigZod, 'asActorConfig')
-/** toActorConfig constant. */
-export const toActorConfig = zodToFactory(ActorConfigZod, 'toActorConfig')

package/src/config/Actors.ts

@@ -1,9 +0,0 @@
-import z from 'zod'
-
-import { ActorConfigZod } from './Actor.ts'
-
-/** ActorsConfigZod constant. */
-export const ActorsConfigZod = z.array(ActorConfigZod.loose()).describe('Actor-specific configurations that override the base configuration when the actor is running').default([])
-
-/** ActorsConfig type. */
-export type ActorsConfig = z.infer<typeof ActorsConfigZod>

package/src/config/Base.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod'
-
-import { ChainConfigZod } from './Chain.ts'
-import { DataLakeConfigZod } from './DataLake/index.ts'
-import { EvmConfigZod } from './Evm.ts'
-import { LogConfigZod } from './Log.ts'
-import { ProvidersConfigZod } from './Providers.ts'
-import { RemoteConfigZod } from './Remote.ts'
-import { StorageConfigZod } from './storage/index.ts'
-import { TelemetryConfigZod } from './Telemetry.ts'
-import { ValidationConfigZod } from './Validation.ts'
-
-/** BaseConfigZod constant. */
-export const BaseConfigZod = z.object({
-  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe('Configuration for the chain'),
-  dataLake: DataLakeConfigZod.optional().describe('Configuration for data lakes'),
-  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe('Configuration for EVM-backed services'),
-  log: LogConfigZod.default(LogConfigZod.parse({})).describe('Configuration for logging'),
-  providers: ProvidersConfigZod.default(ProvidersConfigZod.parse([])).describe('Configuration for providers'),
-  remote: RemoteConfigZod.default(RemoteConfigZod.parse({})).describe('Configuration for remote services'),
-  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe('Configuration for the storage'),
-  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe('Configuration for telemetry'),
-  validation: ValidationConfigZod.default(ValidationConfigZod.parse({})).describe('Configuration for validation'),
-})
-
-/** BaseConfig type. */
-export type BaseConfig = z.infer<typeof BaseConfigZod>

package/src/config/Chain.ts

@@ -1,23 +0,0 @@
-import { AddressZod, HexZod } from '@xylabs/sdk-js'
-import { globalRegistry, z } from 'zod'
-
-/** ChainConfigZod constant. */
-export const ChainConfigZod = z.object({
-  id: HexZod.optional()
-    .register(globalRegistry, {
-      description:
-      'The unique identifier for the chain. Should be the staking contract address for contract-backed chains.',
-      title: 'chain.id',
-      type: 'string',
-    }),
-  genesisRewardAddress: AddressZod.optional()
-    .register(globalRegistry, {
-      description:
-      'Address to send the initial genesis rewards to, if a new chain is being created.',
-      title: 'chain.genesisRewardAddress',
-      type: 'Address',
-    }),
-})
-
-/** ChainConfig type. */
-export type ChainConfig = z.infer<typeof ChainConfigZod>

package/src/config/Config.ts

@@ -1,24 +0,0 @@
-import type z from 'zod'
-
-import { ActorConfigZod } from './Actor.ts'
-import { ActorsConfigZod } from './Actors.ts'
-import { BaseConfigZod } from './Base.ts'
-import type { DeepPartial } from './DeepPartial.ts'
-
-/** ConfigZod constant. */
-export const ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe('The complete configuration for the protocol, including global settings and actor-specific overrides')
-
-/** Config type. */
-export type Config = z.infer<typeof ConfigZod>
-
-/** ResolveConfig helper function. */
-export function resolveConfig(
-  config: DeepPartial<Config>,
-) {
-  const parsedConfig = ConfigZod.parse(config)
-  const { actors, ...rootConfig } = parsedConfig
-  parsedConfig.actors = actors.map((actorConfig) => {
-    return ActorConfigZod.loose().parse({ ...rootConfig, ...actorConfig })
-  })
-  return parsedConfig
-}

package/src/config/DataLake/DataLake.ts

@@ -1,12 +0,0 @@
-import { z } from 'zod'
-
-import { type RestDataLakeConfig, RestDataLakeConfigZod } from './RestDataLakeConfig.ts'
-import { type RouterDataLakeConfig, RouterDataLakeConfigZod } from './RouterDataLakeConfig.ts'
-
-/** DataLakeConfig type. */
-export type DataLakeConfig = RestDataLakeConfig | RouterDataLakeConfig
-
-// z.lazy handles the circular reference between DataLakeConfigZod and RouterDataLakeZod
-/** DataLakeConfigZod constant. */
-export const DataLakeConfigZod: z.ZodType<DataLakeConfig> = z.lazy(() =>
-  z.union([RestDataLakeConfigZod, RouterDataLakeConfigZod])).describe('Configuration for a data lake')

package/src/config/DataLake/DataLakeRemoteConfig.ts

@@ -1,11 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-/** DataLakeDriverConfigBaseZod constant. */
-export const DataLakeDriverConfigBaseZod = z.object({
-  driver: z.string().register(globalRegistry, {
-    description: 'Driver for the data lake',
-    type: 'string',
-  }),
-}).describe('Base configuration for a data lake driver')
-/** DataLakeDriverConfigBase type. */
-export type DataLakeDriverConfigBase = z.infer<typeof DataLakeDriverConfigBaseZod>

package/src/config/DataLake/RestDataLakeConfig.ts

@@ -1,18 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import { DataLakeDriverConfigBaseZod } from './DataLakeRemoteConfig.ts'
-
-/** RestDataLakeConfigZod constant. */
-export const RestDataLakeConfigZod = DataLakeDriverConfigBaseZod.extend({
-  driver: z.literal('rest').register(globalRegistry, {
-    description: 'Driver for the REST data lake',
-    type: 'string',
-  }),
-  url: z.string().register(globalRegistry, {
-    description: 'URL for the REST data lake',
-    type: 'string',
-  }),
-}).describe('Configuration for the REST data lake driver')
-
-/** RestDataLakeConfig type. */
-export type RestDataLakeConfig = z.infer<typeof RestDataLakeConfigZod>

package/src/config/DataLake/RouterDataLakeConfig.ts

@@ -1,22 +0,0 @@
-import { globalRegistry, z } from 'zod'
-
-import type { DataLakeConfig } from './DataLake.ts'
-import { DataLakeConfigZod } from './DataLake.ts'
-
-/** Configuration for RouterDataLake. */
-export interface RouterDataLakeConfig {
-  children: DataLakeConfig[]
-  driver: 'router'
-}
-
-/** RouterDataLakeConfigZod constant. */
-export const RouterDataLakeConfigZod: z.ZodType<RouterDataLakeConfig> = z.object({
-  driver: z.literal('router').register(globalRegistry, {
-    description: 'Driver for the router data lake',
-    type: 'string',
-  }),
-  children: z.array(z.lazy(() => DataLakeConfigZod)).register(globalRegistry, {
-    description: 'Child data lake drivers',
-    type: 'array',
-  }),
-}).describe('Configuration for the router data lake driver')

package/src/config/DataLake/index.ts

@@ -1,4 +0,0 @@
-export * from './DataLake.ts'
-export * from './DataLakeRemoteConfig.ts'
-export * from './RestDataLakeConfig.ts'
-export * from './RouterDataLakeConfig.ts'