@xyo-network/chain-services 1.19.14 → 1.19.16

package/src/PendingTransactions/hydratedTransactionToPayloadBundle.ts

@@ -1,18 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { PayloadBundle } from '@xyo-network/payload-model'
-import { PayloadBundleSchema } from '@xyo-network/payload-model'
-import type { SignedHydratedTransactionWithHashMeta } from '@xyo-network/xl1-sdk'
-import { flattenHydratedTransaction } from '@xyo-network/xl1-sdk'
-
-export const hydratedTransactionToPayloadBundle = (transaction: SignedHydratedTransactionWithHashMeta): PayloadBundle => {
-  const root = transaction[0]._hash
-  return bundle(root, transaction)
-}
-
-const bundle = (root: Hash, transaction: SignedHydratedTransactionWithHashMeta) => {
-  const payloads = flattenHydratedTransaction(transaction).flatMap(p => PayloadBuilder.omitStorageMeta(p))
-  return new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema })
-    .fields({ payloads, root })
-    .build()
-}

package/src/PendingTransactions/index.ts

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

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -1,259 +0,0 @@
-import {
-  Address, asAddress, assertEx, filterAs, Hash,
-  isUndefined,
-} from '@xylabs/sdk-js'
-import { ArchivistInstance, ArchivistNextOptions } from '@xyo-network/archivist-model'
-import {
-  analyzeChain, ChainStakeIntentAnalyzer,
-  isChainSummaryStakeIntent,
-} from '@xyo-network/chain-analyze'
-import {
-  DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS,
-  findFirstMatching, IntervalMap,
-  SerializedIntervalMap,
-} from '@xyo-network/chain-utils'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import {
-  AbstractCreatableProvider,
-  asChainIndexingServiceStateWithStorageMeta,
-  BlockViewer,
-  BlockViewerMoniker,
-  ChainIndexingServiceState, ChainIndexingServiceStateSchema, ChainStakeViewer,
-  ChainStakeViewerMoniker,
-  creatableProvider,
-  isChainIndexingServiceState,
-  readPayloadMapFromStore,
-  StakeIntentService,
-  timeBudget,
-} from '@xyo-network/xl1-sdk'
-import {
-  asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, asChainStakeIntent, type Intent,
-} from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-import { LRUCache } from 'lru-cache'
-
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface XyoStakeIntentServiceParams extends BaseServiceParams {
-  blockViewer: BlockViewer
-  chainArchivist: ArchivistInstance
-  chainStakeViewer: ChainStakeViewer
-  stakeIntentStateArchivist: ArchivistInstance
-}
-
-/**
- * The number of blocks to periodically persist state
- */
-// const STATE_PERSISTENCE_INTERVAL = 60n
-
-const ACTIVE_STAKE_TTL = 1000 * 60 * 60 * 2 // 2 hours in milliseconds
-const NO_ACTIVE_STAKE_TTL = 1000 * 2 // 2 seconds in milliseconds
-const STAKE_CACHE_MAX_ENTRIES = 10_000
-
-@creatableProvider()
-export class XyoStakeIntentService extends AbstractCreatableProvider<XyoStakeIntentServiceParams> implements StakeIntentService {
-  static readonly defaultMoniker = 'StakeIntent'
-  static readonly dependencies = []
-  static readonly monikers = [XyoStakeIntentService.defaultMoniker]
-  moniker = 'StakeIntent'
-  // TODO: Use hash instead of block number to handle chain reorgs
-  protected _lastIndexedBlockHash: Hash | undefined = undefined
-  // TODO: Interval tree per declaration (bank, validator, etc.)
-
-  // Ideally move to DataIntervalTree to handle declared
-  // ranges as it enables range queries in O(min(n, k * log n)) time,
-  // where k is the number of intervals in the output list time
-  // Currently using set based because it's simpler, equivalent
-  // in performance for small sets, and (most importantly) easily
-  // persisted so we can recover state on restart.
-  protected _producers: IntervalMap<Address> = new IntervalMap()
-  protected _stakeCache = new LRUCache<Address, bigint>({ max: STAKE_CACHE_MAX_ENTRIES })
-  protected _updateMutex = new Mutex()
-
-  private _blockViewer?: BlockViewer
-  private _chainStakeViewer?: ChainStakeViewer
-
-  protected get blockViewer() {
-    return this._blockViewer!
-  }
-
-  protected get chainArchivist() {
-    return assertEx(this.params.chainArchivist!, () => 'chainArchivist not set')
-  }
-
-  protected get chainStakeViewer() {
-    return this._chainStakeViewer!
-  }
-
-  protected get stakeIntentStateArchivist() {
-    return assertEx(this.params.stakeIntentStateArchivist!, () => 'stakeIntentStateArchivist not set')
-  }
-
-  static override async paramsHandler(params: Partial<XyoStakeIntentServiceParams>): Promise<XyoStakeIntentServiceParams> {
-    return {
-      ...await super.paramsHandler(params),
-      chainArchivist: assertEx(params?.chainArchivist, () => 'chainArchivist is required'),
-      stakeIntentStateArchivist: assertEx(params?.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist is required'),
-    } as XyoStakeIntentServiceParams
-  }
-
-  override async createHandler() {
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker)
-    this._chainStakeViewer = await this.locator.getInstance(ChainStakeViewerMoniker)
-    const head = await this.blockViewer.currentBlock()
-    if (isUndefined(head)) return
-    await this.recoverState(head[0]._hash)
-  }
-
-  async getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>> {
-    await Promise.resolve()
-    assertEx(intent === 'producer', () => `Support not yet added for intent ${intent}`)
-    const results = this._producers.get(address)
-    return results ?? []
-  }
-
-  async getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]> {
-    return await this.spanAsync('getDeclaredCandidatesForBlock', async () => {
-      assertEx(intent === 'producer', () => `Support not yet added for intent ${intent}`)
-      const results = this._producers.findAllContaining(block)
-      const candidates = [...results]
-      const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent)
-      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer, requiredMinimumStake)
-      return validCandidates
-    }, this.context)
-  }
-
-  getRequiredMinimumStakeForIntent(intent: Intent): bigint {
-    switch (intent) {
-      case 'producer': {
-        const { minStake } = this.params.context.config.actors.producer
-        return BigInt(minStake)
-      }
-    }
-  }
-
-  async isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean> {
-    const candidates = await this.getDeclaredCandidatesForBlock(block, intent)
-    return candidates.includes(address)
-  }
-
-  override async startHandler(): Promise<void> {
-    await this.updateIndex(true)
-  }
-
-  private async filterToValidStake(
-    candidates: Address[],
-    chainStakeViewer: ChainStakeViewer,
-    requiredMinimumStake: bigint,
-  ): Promise<Address[]> {
-    type CandidateStake = { candidate: Address; stake: bigint }
-
-    // Find the stake for each candidate
-    const candidatesWithStake: CandidateStake[] = await Promise.all(
-      candidates.map(async (candidate) => {
-        // Check if the stake is already cached
-        const stake = this._stakeCache.get(candidate)
-        if (stake === undefined) {
-          // Fetch from chainStakeViewer if not cached
-          const activeStake = await chainStakeViewer.activeByStaked(candidate)
-          if (activeStake > 0n) {
-            // Store result in cache
-            this._stakeCache.set(candidate, activeStake, { ttl: ACTIVE_STAKE_TTL })
-          } else {
-            this._stakeCache.set(candidate, activeStake, { ttl: NO_ACTIVE_STAKE_TTL })
-          }
-          return { candidate, stake: activeStake }
-        } else {
-          return { candidate, stake }
-        }
-      }),
-    )
-
-    // Filter out candidates whose stake is greater than or equal to the required minimum
-    return candidatesWithStake
-      .filter(({ stake }) => stake >= requiredMinimumStake)
-      .map(({ candidate }) => candidate)
-  }
-
-  private async persistState(current: Hash): Promise<void> {
-    const state = this._producers.serialize()
-    const payload = new PayloadBuilder<ChainIndexingServiceState<SerializedIntervalMap>>({ schema: ChainIndexingServiceStateSchema })
-      .fields({ endBlockHash: current, state })
-      .build()
-    await this.stakeIntentStateArchivist.insert([payload])
-  }
-
-  private async recoverState(current: Hash): Promise<void> {
-    return await timeBudget('XyoStakeIntentService.recoverState', console, async () => {
-      const currentBlock = assertEx(asBlockBoundWitness((await this.chainArchivist.get([current]))?.[0]), () => `Block ${current} not found`)
-      const currentBlockNum = currentBlock.block
-      // Find last state before current head (in case of rollback, we indexed past it on an uncle chain, etc.)
-      const opts: ArchivistNextOptions = { ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS }
-      while (true) {
-        const predicate = (p: WithStorageMeta<Payload>) => {
-          const state = asChainIndexingServiceStateWithStorageMeta(p)
-          return state ? true : false
-        }
-        const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts)
-        if (isChainIndexingServiceState<SerializedIntervalMap>(state)) {
-          const indexed = (await this.chainArchivist.get([state.endBlockHash]))?.[0]
-          const indexedBlock = asBlockBoundWitnessWithStorageMeta(indexed)
-          if (indexedBlock) {
-            const indexedBlockNum = indexedBlock.block
-            if (indexedBlockNum <= currentBlockNum) {
-              const data = state.state as SerializedIntervalMap
-              this._producers = new IntervalMap(data)
-              this._lastIndexedBlockHash = indexedBlock._hash
-              break
-            }
-          }
-        } else {
-        // No state found, start from genesis
-          break
-        }
-        opts.open = true
-      }
-    }, 2000, true)
-  }
-
-  private async updateIndex(displayProgress = false): Promise<void> {
-    if (this._updateMutex.isLocked()) {
-      return
-    }
-    await this._updateMutex.runExclusive(async () => {
-      return await this.spanAsync('updateIndex', async () => {
-        const currentHead = (await this.blockViewer.currentBlock())[0]
-        if (isUndefined(currentHead)) return
-        const currentHeadHash = currentHead._hash
-        const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(this.chainArchivist)
-        const result = await analyzeChain(
-          { ...this.context, chainMap },
-          [new ChainStakeIntentAnalyzer('producer')],
-          currentHeadHash,
-          this._lastIndexedBlockHash,
-        )
-        const signedDeclarations = filterAs(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent)
-        if (currentHead.block === undefined) return
-        const currentHeadBlockNum = currentHead.block
-        if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`)
-        for (const signedDeclaration of signedDeclarations) {
-          const { exp, nbf } = signedDeclaration
-          const start = nbf
-          const stop = exp
-          const address = asAddress(signedDeclaration?.from)
-          if (start !== undefined && stop !== undefined && address !== undefined) {
-            this._producers.insert(address, start, stop)
-          }
-        }
-        /*
-      if (index % STATE_PERSISTENCE_INTERVAL === 0n) {
-        if (displayProgress) this.logger?.info(`Persisting state at block ${index}`)
-        await this.persistState(await PayloadBuilder.hash(block))
-      }
-        */
-        this._lastIndexedBlockHash = currentHeadHash
-      }, this.context)
-    })
-  }
-}

package/src/StakeIntent/index.ts

@@ -1,2 +0,0 @@
-export * from './lib/index.ts'
-export * from './XyoStakeIntentService.ts'

package/src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts

@@ -1,47 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { exists, filterAs } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import { isBoundWitness } from '@xyo-network/boundwitness-model'
-import { payloadSchemasContains } from '@xyo-network/boundwitness-validator'
-import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type {
-  BlockBoundWitness, ChainStakeIntent, Intent,
-} from '@xyo-network/xl1-sdk'
-import { asChainStakeIntent, ChainStakeIntentSchema } from '@xyo-network/xl1-sdk'
-
-export const getBlockSignedStakeDeclarations = async (block: BlockBoundWitness, archivist: ArchivistInstance, intent: Intent): Promise<ChainStakeIntent[]> => {
-  // Get payloads in block
-  const blockData = await archivist.get(block.payload_hashes)
-  // Filter Payloads in block to BoundWitnesses
-  const bwsFromBlock = blockData.filter(x => isBoundWitness(x))
-  // Filter to BoundWitnesses with StakeIntent payloads
-  const bwsFromBlockWithDeclarations = bwsFromBlock.filter(bw => payloadSchemasContains(bw, ChainStakeIntentSchema))
-  // Filter to only valid signed BWs
-  const validBlockBwsWithDeclarations = await filterToValidSignedBoundWitnesses(bwsFromBlockWithDeclarations)
-  return (await Promise.all(validBlockBwsWithDeclarations.map(async (bw) => {
-    // Get staked intent hashes from signed declarations
-    const stakeIntentHashes = validBlockBwsWithDeclarations
-      .flatMap(mapBoundWitnessToStakeIntentHashes)
-      .filter(exists)
-    // Get staked intent payloads
-    const payloads = await archivist.get(stakeIntentHashes)
-    // Filter payloads to staked intents
-    const stakeIntents = filterAs(payloads, asChainStakeIntent)
-      // that are producers
-      .filter(p => p.intent === intent)
-      // where the issuer of the intent is also the signer of this BW
-      .filter(p => bw.addresses.includes(p.from))
-
-    return stakeIntents
-  }))).flat()
-}
-
-const filterToValidSignedBoundWitnesses = async (bws: BoundWitness[]): Promise<BoundWitness[]> => {
-  const validBwIndexes = await Promise.all(bws.map(bw => BoundWitnessWrapper.parse(bw).getValid()))
-  return bws.filter((_, index) => validBwIndexes[index])
-}
-
-const mapBoundWitnessToStakeIntentHashes = (bw: BoundWitness): (Hash | undefined)[] => {
-  return bw.payload_schemas.map((schema, index) => schema === ChainStakeIntentSchema ? bw.payload_hashes[index] : undefined)
-}

package/src/StakeIntent/lib/index.ts

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