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

package/src/simple/transactionValidation/SimpleTransactionValidationViewer.ts

@@ -1,173 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import {
-  AccountBalanceViewer,
-  AccountBalanceViewerMoniker,
-  asXL1BlockRange,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainContractViewer,
-  ChainContractViewerMoniker,
-  ChainId,
-  HydratedTransactionStateValidationFunction,
-  HydratedTransactionValidationError,
-  HydratedTransactionValidationFunction,
-  isChainQualifiedHeadConfig,
-  isHydratedTransaction,
-  SignedHydratedTransaction,
-  type SignedHydratedTransactionWithHashMeta,
-  TransactionValidationConfig,
-  TransactionValidationQualification,
-  TransactionValidationViewer,
-  TransactionValidationViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderParams } from '../../CreatableProvider/index.ts'
-import { AbstractCreatableProvider, creatableProvider } from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleTransactionValidationViewer. */
-export interface SimpleTransactionValidationViewerParams extends CreatableProviderParams {
-  maxUncleWindowSize?: number
-  protocol?: HydratedTransactionValidationFunction
-  state?: HydratedTransactionStateValidationFunction
-}
-
-/** SimpleTransactionValidationViewer implementation. */
-@creatableProvider()
-export class SimpleTransactionValidationViewer extends
-  AbstractCreatableProvider<SimpleTransactionValidationViewerParams> implements TransactionValidationViewer {
-  static readonly defaultMoniker = TransactionValidationViewerMoniker
-  static readonly dependencies = [AccountBalanceViewerMoniker, ChainContractViewerMoniker, BlockViewerMoniker]
-  static readonly monikers = [TransactionValidationViewerMoniker]
-  moniker = SimpleTransactionValidationViewer.defaultMoniker
-
-  private _accountBalanceViewer!: AccountBalanceViewer
-  private _blockViewer!: BlockViewer
-  private _chainContractViewer!: ChainContractViewer
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  protected get chainContractViewer() {
-    return this._chainContractViewer
-  }
-
-  protected get maxUncleWindowSize() {
-    return this.params.maxUncleWindowSize!
-  }
-
-  static override async paramsHandler(params: Partial<SimpleTransactionValidationViewerParams>): Promise<SimpleTransactionValidationViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      protocol: params.protocol,
-      state: params.state,
-      maxUncleWindowSize: params.maxUncleWindowSize ?? 100,
-    } satisfies SimpleTransactionValidationViewerParams
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._accountBalanceViewer = await this.locator.getInstance<AccountBalanceViewer>(AccountBalanceViewerMoniker)
-    this._chainContractViewer = await this.locator.getInstance<ChainContractViewer>(ChainContractViewerMoniker)
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async qualifiedValidateTransaction(
-    block: SignedHydratedTransactionWithHashMeta,
-    config?: TransactionValidationConfig,
-  ): Promise<[HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta, TransactionValidationQualification]> {
-    const result = (await this.qualifiedValidateTransactions([block], config))
-    return [result[0][0], result[1]]
-  }
-
-  async qualifiedValidateTransactions(
-    transactions: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig,
-  ): Promise<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionValidationQualification]> {
-    const { value, state } = config ?? {
-      shape: true, links: true, state: true, head: undefined,
-    }
-
-    const transactionsWithMeta = await Promise.all(transactions.map(b => Promise.all([PayloadBuilder.addHashMeta(b[0]), PayloadBuilder.addHashMeta(b[1])])))
-
-    const head = isChainQualifiedHeadConfig(config)
-      ? assertEx(
-          (await this.blockViewer.blockByHash(config.head))?.[0],
-          () => `Specified a head that is not in the chain [${config.head}]`,
-        )
-      : undefined
-
-    const headBlock = head ?? (await this.blockViewer.currentBlock())[0]
-
-    const validateProtocol = value ? this.doValidateProtocol.bind(this) : undefined
-    const validateState = state ? this.doValidateState.bind(this) : undefined
-
-    const chainId = headBlock.chain
-
-    const qualification = { head: headBlock._hash, range: asXL1BlockRange([0, headBlock.block], true) }
-    const [protocolResults, stateResults] = await Promise.all([
-      validateProtocol?.(transactionsWithMeta, chainId), validateState?.(transactionsWithMeta, chainId),
-    ])
-    const blockResults = transactionsWithMeta.map((r, i) => {
-      const errors = []
-      if (protocolResults && !isHydratedTransaction(protocolResults[i])) {
-        errors.push(...(protocolResults[i]))
-      }
-      if (stateResults && !isHydratedTransaction(stateResults[i])) {
-        errors.push(...(stateResults[i]))
-      }
-      return errors.length === 0 ? r : errors
-    })
-    return [blockResults, qualification]
-  }
-
-  qualifiedValidateUncle(
-    _transactions: SignedHydratedTransaction[],
-    _config?: TransactionValidationConfig,
-  ): Promise<[(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[], TransactionValidationQualification]> {
-    throw new Error('Method not implemented.')
-  }
-
-  async validateTransaction(
-    block: SignedHydratedTransaction,
-    config?: TransactionValidationConfig,
-  ): Promise<HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta> {
-    return (await this.validateTransactions([block], config))[0]
-  }
-
-  async validateTransactions(
-    transactions: SignedHydratedTransaction[],
-    config?: TransactionValidationConfig,
-  ): Promise<(HydratedTransactionValidationError[] | SignedHydratedTransactionWithHashMeta)[]> {
-    return (await this.qualifiedValidateTransactions(transactions, config))[0]
-  }
-
-  private async doValidateProtocol(
-    transactions: SignedHydratedTransactionWithHashMeta[],
-    chainId: ChainId,
-  ): Promise<(SignedHydratedTransactionWithHashMeta | HydratedTransactionValidationError[])[]> {
-    return (await Promise.all(transactions.map(async (tx) => {
-      const errors = await this.params.protocol!(
-        { ...this.context, chainId },
-        tx,
-      )
-      return (errors.length === 0) ? tx : errors
-    })))
-  }
-
-  private async doValidateState(
-    transactions: SignedHydratedTransactionWithHashMeta[],
-    chainId: ChainId,
-  ): Promise<(SignedHydratedTransactionWithHashMeta | HydratedTransactionValidationError[])[]> {
-    return (await Promise.all(transactions.map(async (tx) => {
-      const errors = await this.params.state!(
-        {
-          ...this.context, chainId, accountBalanceViewer: this._accountBalanceViewer, blockViewer: this.blockViewer,
-        },
-        tx,
-      )
-      return (errors.length === 0) ? tx : errors
-    })))
-  }
-}

package/src/simple/transactionValidation/index.ts

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

package/src/simple/windowedBlock/SimpleWindowedBlockViewer.ts

@@ -1,207 +0,0 @@
-import {
-  assertEx, exists, type Hash, isNull, type Promisable,
-} from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-import type {
-  BlockViewer,
-  ChainId, HydratedBlockWithHashMeta, SignedHydratedBlockWithHashMeta, SyncMap, WindowedBlockViewer, XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber, BlockViewerMoniker, WindowedBlockViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-import { Mutex } from 'async-mutex'
-
-import { transactionsFromHydratedBlock } from '../../block/index.ts'
-import {
-  AbstractCreatableProvider, creatableProvider, type CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-import { MemoryMap } from '../../driver/index.ts'
-
-/** Parameters for SimpleWindowedBlockViewer. */
-export interface SimpleWindowedBlockViewerParams extends CreatableProviderParams {
-  blockViewer?: BlockViewer
-  maxWindowSize: number
-  syncInterval: number
-}
-
-/** SimpleWindowedBlockViewer implementation. */
-@creatableProvider()
-export class SimpleWindowedBlockViewer extends AbstractCreatableProvider<SimpleWindowedBlockViewerParams> implements WindowedBlockViewer {
-  static readonly defaultMoniker = WindowedBlockViewerMoniker
-  static readonly dependencies = [BlockViewerMoniker]
-  static readonly monikers = [WindowedBlockViewerMoniker]
-  moniker = WindowedBlockViewerMoniker
-
-  private _blockHashMap!: SyncMap<Hash, SignedHydratedBlockWithHashMeta>
-  private _blockNumberMap!: SyncMap<XL1BlockNumber, SignedHydratedBlockWithHashMeta>
-  // the external BlockViewer
-  private _blockViewer!: BlockViewer
-  private _chain: SignedHydratedBlockWithHashMeta[] = []
-  private _syncMutex = new Mutex()
-  private _timerId: ReturnType<typeof setInterval> | null = null
-  private _transactionHashMap!: SyncMap<Hash, SignedHydratedBlockWithHashMeta>
-
-  protected get maxWindowSize() {
-    return this.params.maxWindowSize
-  }
-
-  protected get syncInterval() {
-    return this.params.syncInterval
-  }
-
-  static override async paramsHandler(params?: Partial<SimpleWindowedBlockViewerParams>): Promise<SimpleWindowedBlockViewerParams> {
-    return {
-      ...await super.paramsHandler(params),
-      maxWindowSize: params?.maxWindowSize ?? 1000,
-      syncInterval: params?.syncInterval ?? 10_000,
-    }
-  }
-
-  blockByHash(hash: Hash) {
-    return this._blockHashMap.get(hash) ?? null
-  }
-
-  blockByNumber(blockNumber: XL1BlockNumber) {
-    return this._blockNumberMap.get(blockNumber) ?? null
-  }
-
-  async blockByTransactionHash(hash: Hash) {
-    const [block = null] = await this.blocksByTransactionHashes([hash])
-    return block
-  }
-
-  blocksByHash(hash: Hash, limit?: number) {
-    const result: SignedHydratedBlockWithHashMeta[] = []
-    let block = this._blockHashMap.get(hash)
-    while (block && (limit === undefined || result.length < limit)) {
-      result.unshift(block)
-      const previousHash = block[0].previous
-      block = previousHash ? this._blockHashMap.get(previousHash) : undefined
-    }
-    return result
-  }
-
-  blocksByNumber(blockNumber: XL1BlockNumber, limit?: number) {
-    const result: SignedHydratedBlockWithHashMeta[] = []
-    let block = this._blockNumberMap.get(blockNumber)
-    while (block && (limit === undefined || result.length < limit)) {
-      result.unshift(block)
-      const previousBlockNumber = asXL1BlockNumber(block[0].block - 1, true)
-      block = (previousBlockNumber >= 0) ? this._blockNumberMap.get(previousBlockNumber) : undefined
-    }
-    return result
-  }
-
-  blocksByTransactionHashes(hashes: Hash[]): Promisable<HydratedBlockWithHashMeta[]> {
-    return hashes.map(hash => this._transactionHashMap.get(hash)).filter(exists)
-  }
-
-  chainId(_blockNumber?: unknown): Promisable<ChainId> {
-    throw new Error('Method not implemented.')
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-
-    this._blockViewer = assertEx(
-      this.params.blockViewer ?? await this.locator.getInstance<BlockViewer>(BlockViewerMoniker),
-      () => 'BlockViewer instance is required',
-    )
-    this._blockHashMap = new MemoryMap<Hash, SignedHydratedBlockWithHashMeta>()
-    this._blockNumberMap = new MemoryMap<XL1BlockNumber, SignedHydratedBlockWithHashMeta>()
-    this._transactionHashMap = new MemoryMap<Hash, SignedHydratedBlockWithHashMeta>()
-  }
-
-  currentBlock(): Promisable<SignedHydratedBlockWithHashMeta> {
-    return assertEx(this._chain.at(-1))
-  }
-
-  currentBlockHash(): Promisable<Hash> {
-    return assertEx(this._chain.at(-1)?.[0]._hash)
-  }
-
-  currentBlockNumber(): Promisable<XL1BlockNumber> {
-    return assertEx(this._chain.at(-1)?.[0].block)
-  }
-
-  async payloadByHash(hash: Hash): Promise<WithHashMeta<Payload> | null> {
-    const payloads = await this.payloadsByHash([hash])
-    return payloads.length > 0 ? payloads[0] : null
-  }
-
-  payloadsByHash(_hashes: Hash[]): Promisable<WithHashMeta<Payload>[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  override async startHandler() {
-    await super.startHandler()
-    await this.sync()
-    this.stopPoll()
-    this.startPoll()
-  }
-
-  override async stopHandler() {
-    await super.stopHandler()
-    this.stopPoll()
-  }
-
-  private addBlock(block: SignedHydratedBlockWithHashMeta) {
-    // Add the new block to the end of the window
-    this._chain.push(block)
-
-    // Index the new block
-    this._blockHashMap.set(block[0]._hash, block)
-    this._blockNumberMap.set(block[0].block, block)
-    for (const tx of transactionsFromHydratedBlock(block)) {
-      this._transactionHashMap.set(tx._hash, block)
-    }
-
-    // Purge only if the window size is exceeded
-    while (this._chain.length > this.maxWindowSize) {
-      const removedBlock = this._chain.shift()
-      if (!removedBlock) break
-
-      this._blockHashMap.delete(removedBlock[0]._hash)
-      this._blockNumberMap.delete(removedBlock[0].block)
-      for (const tx of transactionsFromHydratedBlock(removedBlock)) {
-        this._transactionHashMap.delete(tx._hash)
-      }
-    }
-  }
-
-  private startPoll() {
-    this._timerId = setInterval(() => {
-      void this.sync()
-    }, this.syncInterval)
-  }
-
-  private stopPoll() {
-    if (this._timerId) {
-      clearInterval(this._timerId)
-    }
-    this._timerId = null
-  }
-
-  private async sync() {
-    if (this._syncMutex.isLocked()) {
-      return
-    }
-    return await this._syncMutex.runExclusive(async () => {
-      try {
-        let cursor: SignedHydratedBlockWithHashMeta | null = await this._blockViewer.currentBlock()
-        const previousHead = this._chain.length > 0 ? await this.currentBlockHash() : null
-        const newBlocks: SignedHydratedBlockWithHashMeta[] = []
-        while (!isNull(cursor) && cursor[0]._hash !== previousHead && newBlocks.length < this.maxWindowSize) {
-          newBlocks.unshift(cursor)
-          const previousHash = newBlocks[0][0].previous
-          cursor = isNull(previousHash) ? null : await this._blockViewer.blockByHash(previousHash)
-        }
-        for (const block of newBlocks) {
-          this.addBlock(block)
-        }
-      } catch (ex) {
-        console.error('Error during sync:', ex)
-      }
-    })
-  }
-}

package/src/simple/windowedBlock/index.ts

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

package/src/status/RuntimeStatusMonitor.ts

@@ -1,120 +0,0 @@
-import type { CreatableName, CreatableStatus } from '@xylabs/sdk-js'
-
-import { LoggerStatusReporter } from './ServiceStatus.ts'
-
-/**
- * Enum-like record for statuses with priority allowing
- * for determination of the aggregated status.
- */
-const statusPriority: Record<CreatableStatus, number> = {
-  error: 0,
-  stopped: 1,
-  stopping: 2,
-  creating: 3,
-  created: 4,
-  starting: 5,
-  started: 6,
-}
-
-/**
- * A sentinel status that represents the initial state
- * before any statuses are reported.
- * It is used to ensure that the monitor has a valid status
- * even when no statuses have been reported yet and to
- * prevent the system from showing an "error" state
- * when no statuses are available.
- */
-const SENTINEL_STATUS: CreatableStatus = 'starting'
-
-/**
- * Given an array of statuses, this function reduces them
- * to the minimum status based on the defined priority.
- * @param statuses An array of statuses to reduce.
- * @returns The minimum status based on priority.
- */
-const reduceToMinimumStatus = (statuses: CreatableStatus[]): CreatableStatus => {
-  let minStatus: CreatableStatus = SENTINEL_STATUS
-  let minPriority = Infinity
-
-  for (const status of statuses) {
-    const priority = statusPriority[status]
-    if (priority < minPriority) {
-      minPriority = priority
-      minStatus = status
-    }
-  }
-  return minStatus
-}
-
-/** Handler for global status transitions with optional from/to filters */
-export type GlobalTransitionHandler = {
-  from?: CreatableStatus
-  handler: (from: CreatableStatus, to: CreatableStatus) => void
-  to?: CreatableStatus
-}
-/** Handler for named service status transitions with optional from/to filters */
-export type TransitionHandler = GlobalTransitionHandler & {
-  name?: string
-}
-
-/** Monitors runtime service statuses and fires transition callbacks on status changes */
-export class RuntimeStatusMonitor extends LoggerStatusReporter {
-  private globalTransitions: GlobalTransitionHandler[] = []
-  private transitions: TransitionHandler[] = []
-
-  getGlobalStatus(): CreatableStatus {
-    // If no statuses have been reported, return the sentinel status
-    if (Object.keys(this.statusMap).length === 0) return SENTINEL_STATUS
-    return reduceToMinimumStatus(Object.values(this.statusMap))
-  }
-
-  getStatus(name: CreatableName): CreatableStatus | undefined {
-    return this.statusMap[name]
-  }
-
-  onGlobalTransition(match: { from?: CreatableStatus; to?: CreatableStatus }, handler: (from: CreatableStatus, to: CreatableStatus) => void) {
-    this.globalTransitions.push({ ...match, handler })
-  }
-
-  /**
-   * Register a callback to be called on a specific transition.
-   */
-  onTransition(match: { from?: CreatableStatus; name: string; to?: CreatableStatus }, handler: (from: CreatableStatus, to: CreatableStatus) => void) {
-    this.transitions.push({ ...match, handler })
-  }
-
-  override report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
-    // Capture the current status before updating
-    const previous = this.statusMap[name]
-    const previousGlobal = this.getGlobalStatus()
-
-    // Update the status map with the new status
-    super.report(name, status, progress)
-
-    // If the status hasn't changed, do not run handlers
-    if (previous === status) return
-    this.runTransitions(this.transitions, previous, status, name)
-
-    // If the global status hasn't changed, do not run handlers
-    const globalStatus = this.getGlobalStatus()
-    if (previousGlobal === globalStatus) return
-    this.runTransitions(this.globalTransitions, previousGlobal, globalStatus)
-  }
-
-  private runTransitions(
-    transitions: (TransitionHandler | GlobalTransitionHandler)[],
-    prev: CreatableStatus,
-    next: CreatableStatus,
-    name?: string,
-  ) {
-    for (const {
-      from, to, name: matchName, handler,
-    } of transitions as TransitionHandler[]) {
-      if ((matchName === undefined || matchName === name)
-        && (from === undefined || from === prev)
-        && (to === undefined || to === next)) {
-        handler(prev, next)
-      }
-    }
-  }
-}

package/src/status/ServiceStatus.ts

@@ -1,21 +0,0 @@
-import type {
-  CreatableName, CreatableStatus, CreatableStatusReporter, Logger,
-} from '@xylabs/sdk-js'
-
-/** Status reporter that logs status changes and tracks service status counts */
-export class LoggerStatusReporter implements CreatableStatusReporter {
-  protected logger: Logger
-
-  protected statusMap: Record<CreatableName, CreatableStatus> = {}
-
-  constructor(logger: Logger) {
-    this.logger = logger
-  }
-
-  report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
-    this.statusMap[name] = status
-    const starting = (Object.entries(this.statusMap).map(([, value]): number => value === 'starting' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    const started = (Object.entries(this.statusMap).map(([, value]): number => value === 'started' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    this.logger.info(`${started}/${starting + started} ${name} status: ${status}`, { progress })
-  }
-}

package/src/status/index.ts

@@ -1,2 +0,0 @@
-export * from './RuntimeStatusMonitor.ts'
-export * from './ServiceStatus.ts'

package/src/summary/index.ts

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

package/src/summary/model/BalancesStepSummary.ts

@@ -1,35 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, isStorageMeta,
-} from '@xyo-network/sdk-js'
-
-import type { SignedBigInt } from '../../SignedBigInt.ts'
-import type { StepSummary } from './StepSummary.ts'
-
-/** Schema identifier for balances step summary payloads */
-export const BalancesStepSummarySchema = asSchema('network.xyo.step.summary.balances', true)
-/** Schema type for BalancesStepSummary payloads. */
-export type BalancesStepSummarySchema = typeof BalancesStepSummarySchema
-
-/** Step summary payload containing net balance changes per address */
-export type BalancesStepSummary = StepSummary<{
-  balances: Record<Address, SignedBigInt>
-}, BalancesStepSummarySchema>
-
-/**
- * Identity function for determining if an object is an BalancesStepSummary
- */
-export const isBalancesStepSummary = isPayloadOfSchemaType<BalancesStepSummary>(BalancesStepSummarySchema)
-/** Type assertion factory for BalancesStepSummary payloads */
-export const asBalancesStepSummary = AsObjectFactory.create<BalancesStepSummary>(isBalancesStepSummary)
-
-/**
- * Identity function for determining if an object is an BalancesStepSummary with Storage Meta
- */
-export const isBalancesStepSummaryWithStorageMeta = (value: unknown): value is WithStorageMeta<BalancesStepSummary> => {
-  return isBalancesStepSummary(value) && isStorageMeta(value)
-}
-/** Type assertion factory for BalancesStepSummary with storage metadata */
-export const asBalancesStepSummaryWithStorageMeta = AsObjectFactory.create<WithStorageMeta<BalancesStepSummary>>(isBalancesStepSummaryWithStorageMeta)

package/src/summary/model/SchemasStepSummary.ts

@@ -1,33 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Schema, WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, isStorageMeta,
-} from '@xyo-network/sdk-js'
-
-import type { StepSummary } from './StepSummary.ts'
-
-/** Schema identifier for schemas step summary payloads */
-export const SchemasStepSummarySchema = asSchema('network.xyo.step.summary.schemas', true)
-/** Schema type for sStepSummary payloads. */
-export type SchemasStepSummarySchema = typeof SchemasStepSummarySchema
-
-/** Step summary payload containing schema occurrence counts */
-export type SchemasStepSummary = StepSummary<{
-  schemas: Record<Schema, number>
-}, SchemasStepSummarySchema>
-
-/**
- * Identity function for determining if an object is an SchemasStepSummary
- */
-export const isSchemasStepSummary = isPayloadOfSchemaType<SchemasStepSummary>(SchemasStepSummarySchema)
-/** Type assertion factory for SchemasStepSummary payloads */
-export const asSchemasStepSummary = AsObjectFactory.create<SchemasStepSummary>(isSchemasStepSummary)
-
-/**
- * Identity function for determining if an object is an SchemasStepSummary with Storage Meta
- */
-export const isSchemasStepSummaryWithStorageMeta = (value: unknown): value is WithStorageMeta<SchemasStepSummary> => {
-  return isSchemasStepSummary(value) && isStorageMeta(value)
-}
-/** Type assertion factory for SchemasStepSummary with storage metadata */
-export const asSchemasStepSummaryWithStorageMeta = AsObjectFactory.create<WithStorageMeta<SchemasStepSummary>>(isSchemasStepSummaryWithStorageMeta)

package/src/summary/model/StepSummary.ts

@@ -1,20 +0,0 @@
-import type { EmptyObject, Hash } from '@xylabs/sdk-js'
-import {
-  asSchema, type Payload, type Schema,
-} from '@xyo-network/sdk-js'
-
-/** Schema identifier for step summary payloads */
-export const StepSummarySchema = asSchema('network.xyo.step.summary', true)
-/** Schema type for StepSummary payloads. */
-export type StepSummarySchema = typeof StepSummarySchema
-
-/** Fields common to all step summary payloads */
-export interface StepSummaryFields {
-  hash: Hash // the stepHash - the hash of the last block in the step frame
-  stepSize: number // the stepSize in blocks
-}
-
-/** Payload type for a step summary with optional additional fields and schema */
-export type StepSummary<TAdditionalFields extends EmptyObject | void = void,
-  TSchema extends Schema | void = void> = Payload<TAdditionalFields extends void ? StepSummaryFields : TAdditionalFields & StepSummaryFields,
-  TSchema extends void ? StepSummarySchema : TSchema>

package/src/summary/model/TransfersSummary.ts

@@ -1,36 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, isStorageMeta,
-} from '@xyo-network/sdk-js'
-
-import type { SignedBigInt } from '../../SignedBigInt.ts'
-import type { StepSummary } from './StepSummary.ts'
-
-/** Schema identifier for transfers step summary payloads */
-export const TransfersStepSummarySchema = asSchema('network.xyo.step.summary.transfer', true)
-/** Schema type for TransfersStepSummary payloads. */
-export type TransfersStepSummarySchema = typeof TransfersStepSummarySchema
-
-/** Step summary payload containing transfer amounts between address pairs */
-export type TransfersStepSummary = StepSummary<{
-  transfers: Record<Address, Record<Address, SignedBigInt>>
-}, TransfersStepSummarySchema>
-
-/**
- * Identity function for determining if an object is an TransfersStepSummary
- */
-export const isTransfersStepSummary = isPayloadOfSchemaType<TransfersStepSummary>(TransfersStepSummarySchema)
-/** Type assertion factory for TransfersStepSummary payloads */
-export const asTransfersStepSummary = AsObjectFactory.create<TransfersStepSummary>(isTransfersStepSummary)
-
-/**
- * Identity function for determining if an object is an TransfersStepSummary with Storage Meta
- */
-export const isTransfersStepSummaryWithStorageMeta = (value: unknown): value is WithStorageMeta<TransfersStepSummary> => {
-  return isTransfersStepSummary(value) && isStorageMeta(value)
-}
-/** Type assertion factory for TransfersStepSummary with storage metadata */
-export const asTransfersStepSummaryWithStorageMeta
-  = AsObjectFactory.create<WithStorageMeta<TransfersStepSummary>>(isTransfersStepSummaryWithStorageMeta)

package/src/summary/model/index.ts

@@ -1,4 +0,0 @@
-export * from './BalancesStepSummary.ts'
-export * from './SchemasStepSummary.ts'
-export * from './StepSummary.ts'
-export * from './TransfersSummary.ts'