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

package/src/services/StakeIntentService/ChainIndexingServiceStateSchema.ts

@@ -1,50 +0,0 @@
-import type { Hash, JsonValue } from '@xylabs/sdk-js'
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asSchema, isPayloadOfSchemaType, isStorageMeta,
-} from '@xyo-network/sdk-js'
-
-/** Fields stored by a chain indexing service to track its indexing progress and state */
-export interface ChainIndexingServiceStateFields<T extends JsonValue = JsonValue> {
-  /**
-   * The hash of the last block that this service has indexing
-   */
-  endBlockHash: Hash
-  /**
-   * The hash of the block that the service started indexing. If undefined, the service is
-   * assumed to have started indexing from the genesis block
-   */
-  startBlockHash?: Hash
-  /**
-   * The indexed state for the range
-   */
-  state: T
-}
-/** Schema identifier for chain indexing service state payloads */
-export const ChainIndexingServiceStateSchema = asSchema('network.xyo.chain.indexing.service.state', true)
-/** Schema type for ChainIndexingServiceState payloads. */
-export type ChainIndexingServiceStateSchema = typeof ChainIndexingServiceStateSchema
-
-/**
- * The result of a ChainIndexingServiceState
- */
-export type ChainIndexingServiceState<T extends JsonValue = JsonValue> = Payload<ChainIndexingServiceStateFields<T>, ChainIndexingServiceStateSchema>
-
-/**
- * Identity functions for determining if an object is an ChainIndexingServiceState
- */
-export const isChainIndexingServiceState = <T extends JsonValue = JsonValue>(payload?: unknown): payload is ChainIndexingServiceState<T> => {
-  return isPayloadOfSchemaType<ChainIndexingServiceState<T>>(ChainIndexingServiceStateSchema)(payload)
-}
-/** Type assertion factory for ChainIndexingServiceState payloads */
-export const asChainIndexingServiceState = AsObjectFactory.create<ChainIndexingServiceState<JsonValue>>(isChainIndexingServiceState)
-
-/** Type guard for ChainIndexingServiceState with storage metadata */
-export const isChainIndexingServiceStateWithStorageMeta
-  = <T extends JsonValue = JsonValue>(value: unknown): value is WithStorageMeta<ChainIndexingServiceState<T>> =>
-    isChainIndexingServiceState<T>(value) && isStorageMeta(value)
-
-/** Type assertion factory for ChainIndexingServiceState with storage metadata */
-export const asChainIndexingServiceStateWithStorageMeta
-  = AsObjectFactory.create<WithStorageMeta<ChainIndexingServiceState>>(isChainIndexingServiceStateWithStorageMeta)

package/src/services/StakeIntentService/StakeIntentService.ts

@@ -1,35 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { Intent } from '@xyo-network/xl1-protocol-lib'
-
-/** Service for managing and querying stake intent declarations on the chain */
-export interface StakeIntentService {
-
-  /**
-   * Gets the declared ranges for an address based on historical on-chain data
-   * @param address The address to get the declared ranges for
-   * @param intent The declared intent to filter for
-   */
-  getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>>
-
-  /**
-   * Gets the declared candidates for a block based on historical on-chain data
-   * @param block The block number to get the declared candidates for
-   * @param intent The declared intent to filter for
-   */
-  getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]>
-
-  /**
-   * Gets the required minimum stake for a given intent
-   * @param intent The declared intent to filter for
-   * @returns The required minimum stake for the intent
-   */
-  getRequiredMinimumStakeForIntent(intent: Intent): bigint
-
-  /**
-   * Checks if the address is staked for a block for a given intent
-   * @param block The block number to check
-   * @param intent The declared intent to filter for
-   * @param address The address to check
-   */
-  isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean>
-}

package/src/services/StakeIntentService/index.ts

@@ -1,2 +0,0 @@
-export * from './ChainIndexingServiceStateSchema.ts'
-export * from './StakeIntentService.ts'

package/src/services/index.ts

@@ -1,8 +0,0 @@
-export * from './AccountTransfersService.ts'
-export * from './BlockProducerService.ts'
-export * from './Chain/index.ts'
-export * from './Election.ts'
-export * from './NetworkStakeService.ts'
-export * from './PendingTransactionsService.ts'
-export * from './SchemasService.ts'
-export * from './StakeIntentService/index.ts'

package/src/simple/StakeEventsViewer/SimpleStakeEventsViewer.ts

@@ -1,93 +0,0 @@
-import { isDefined } from '@xylabs/sdk-js'
-import {
-  Position, StakeEvent, StakeEventFilter, StakeEventName, StakeEventsViewer, StakeEventsViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeEvents. */
-export interface SimpleStakeEventsParams extends CreatableProviderParams {
-  positions: Position[]
-}
-
-/** SimpleStakeEventsViewer implementation. */
-@creatableProvider()
-export class SimpleStakeEventsViewer extends AbstractCreatableProvider<SimpleStakeEventsParams> implements StakeEventsViewer {
-  static readonly defaultMoniker = StakeEventsViewerMoniker
-  static readonly dependencies = []
-  static readonly monikers = [StakeEventsViewerMoniker]
-  moniker = SimpleStakeEventsViewer.defaultMoniker
-
-  protected get positions() {
-    return this.params.positions
-  }
-
-  positionCount(range: [number, number | 'latest']): number {
-    return this.positionsFromRange(range).length
-  }
-
-  stakeEvents<TName extends StakeEventName>(range: [number, number | 'latest'], { name }: StakeEventFilter<TName> = {}): StakeEvent<TName>[] {
-    const positions = this.positionsFromRange(range)
-    const events = this.eventsFromPositions(positions)
-    if (isDefined(name)) {
-      return events.filter((event): event is StakeEvent<TName> => event.name === name)
-    }
-    return events as StakeEvent<TName>[]
-  }
-
-  protected override async startHandler(): Promise<void> {
-    await super.startHandler()
-  }
-
-  private eventsFromPositions(positions: Position[]): StakeEvent<StakeEventName>[] {
-    const events = positions.map((position) => {
-      const events: StakeEvent<StakeEventName>[] = [{
-        name: 'StakeAdded',
-        time: position.addBlock,
-        args: {
-          staker: position.staker,
-          staked: position.staked,
-          amount: position.amount,
-          id: position.id,
-        },
-      }]
-      if (position.removeBlock !== 0) {
-        events.push({
-          name: 'StakeRemoved',
-          time: position.removeBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id,
-          },
-        })
-      }
-      if (position.withdrawBlock !== 0) {
-        events.push({
-          name: 'StakeWithdrawn',
-          time: position.withdrawBlock,
-          args: {
-            staker: position.staker,
-            staked: position.staked,
-            amount: position.amount,
-            id: position.id,
-          },
-        })
-      }
-      return events
-    })
-    return events.flat()
-  }
-
-  private positionsFromRange(range: [number, number | 'latest']): Position[] {
-    const startBlock = range[0]
-    const endBlock = range[1] === 'latest' ? Number.MAX_SAFE_INTEGER : range[1]
-    const filteredPositions = this.positions?.filter((position) => {
-      return position.addBlock <= endBlock && (position.removeBlock === 0 || position.removeBlock >= startBlock)
-    }) ?? []
-    return filteredPositions
-  }
-}

package/src/simple/StakeEventsViewer/index.ts

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

package/src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts

@@ -1,116 +0,0 @@
-import { type Address, asAddress } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import {
-  StakeTotalsViewer, StakeTotalsViewerMoniker,
-  StakeViewer,
-  StakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeTotalsViewer. */
-export interface SimpleStakeTotalsViewerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleStakeTotalsViewer implementation. */
-@creatableProvider()
-export class SimpleStakeTotalsViewer extends AbstractCreatableProvider<SimpleStakeTotalsViewerParams> implements StakeTotalsViewer {
-  static readonly defaultMoniker = StakeTotalsViewerMoniker
-  static readonly dependencies = [StakeTotalsViewerMoniker]
-  static readonly monikers = [StakeTotalsViewerMoniker]
-  moniker = SimpleStakeTotalsViewer.defaultMoniker
-
-  private _stakeViewer!: StakeViewer
-
-  get stakeViewer() {
-    return this._stakeViewer
-  }
-
-  async active(time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 || position.removeBlock > time) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaked(staked: Address, time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress(position.staked) === asAddress(staked)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER) {
-    let active = 0n
-    const positions = await this.stakeViewer.activeStakes()
-    for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress(position.staker) === asAddress(staker)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._stakeViewer = assertEx(
-      (await this.locateAndCreate<StakeViewer>(StakeViewerMoniker)),
-      () => 'Failed to create StakeViewer',
-    )
-  }
-
-  async pending(time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let pending = 0n
-    const positions = await this.stakeViewer.removedStakes()
-    for (const position of positions) {
-      if ((position.removeBlock !== 0 && position.removeBlock <= time) && (position.withdrawBlock === 0 || position.withdrawBlock > time)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async pendingByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER) {
-    let pending = 0n
-    const positions = await this.stakeViewer.removedStakes()
-    for (const position of positions) {
-      if ((position.removeBlock !== 0 && position.removeBlock <= time) && (position.withdrawBlock === 0 || position.withdrawBlock > time) && asAddress(position.staker) === asAddress(staker)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async withdrawn(time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let withdrawn = 0n
-    const positions = await this.stakeViewer.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  async withdrawnByStaker(staker: Address, time = Number.MAX_SAFE_INTEGER): Promise<bigint> {
-    let withdrawn = 0n
-    const positions = await this.stakeViewer.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time && asAddress(position.staker) === asAddress(staker)) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-}

package/src/simple/StakeTotalsViewer/index.ts

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

package/src/simple/StakeViewer/SimpleStakeViewer.ts

@@ -1,164 +0,0 @@
-import {
-  type Address, asAddress, Promisable, toAddress,
-} from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import {
-  Position, StakeEventsViewer, StakeEventsViewerMoniker, StakeViewer, StakeViewerMoniker,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleStakeViewer. */
-export interface SimpleStakeViewerParams extends CreatableProviderParams {
-  chainId?: Address
-  minWithdrawalBlocks?: number
-  positions: Position[]
-}
-
-/** SimpleStakeViewer implementation. */
-@creatableProvider()
-export class SimpleStakeViewer extends AbstractCreatableProvider<SimpleStakeViewerParams> implements StakeViewer {
-  static readonly defaultMoniker = StakeViewerMoniker
-  static readonly dependencies = [StakeEventsViewerMoniker]
-  static readonly monikers = [StakeViewerMoniker]
-  moniker = SimpleStakeViewer.defaultMoniker
-
-  private _chainStakeEventsViewer: StakeEventsViewer | undefined
-
-  get stakeEvents() {
-    return assertEx(this._chainStakeEventsViewer, () => 'Stake events viewer not set')
-  }
-
-  protected get positions() {
-    return this.params.positions
-  }
-
-  async active(): Promise<bigint> {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByAddressStaked(staked: Address) {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress(position.staked) === asAddress(staked)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  async activeByStaker(staker: Address): Promise<bigint> {
-    let active = 0n
-    const positions = await this.activeStakes()
-    for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress(position.staker) === asAddress(staker)) {
-        active += position.amount
-      }
-    }
-    return active
-  }
-
-  activeStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock === 0) && (s.removeBlock === 0))
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    this._chainStakeEventsViewer = assertEx(
-      (await this.locateAndCreate<StakeEventsViewer>(StakeEventsViewerMoniker)),
-      () => 'Failed to create StakeEventsViewer',
-    )
-  }
-
-  minWithdrawalBlocks(): number {
-    return this.params.minWithdrawalBlocks ?? 10
-  }
-
-  async pending() {
-    let pending = 0n
-    const positions = await this.removedStakes()
-    for (const position of positions) {
-      if (position.removeBlock !== 0 && position.withdrawBlock === 0) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  async pendingByStaker(staker: Address) {
-    let pending = 0n
-    const positions = await this.removedStakes()
-    for (const position of positions) {
-      if (position.removeBlock !== 0 && position.withdrawBlock === 0 && asAddress(position.staker) === asAddress(staker)) {
-        pending += position.amount
-      }
-    }
-    return pending
-  }
-
-  removedStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock === 0) && (s.removeBlock !== 0))
-  }
-
-  rewardsContract(): Address {
-    return toAddress(toAddress(1n))
-  }
-
-  stakeById(id: number): Position {
-    return assertEx(this.positions[id], () => new Error(`Stake with id ${id} not found`))
-  }
-
-  stakeByStaker(staker: Address, slot: number): Position {
-    return this.positions.filter(s => asAddress(s.staker) === asAddress(staker))[slot]
-  }
-
-  stakesByStaked(staked: Address, range: [number, number | undefined] = [0, undefined]): Position[] {
-    const endBlock = (range[1] ?? Number.MAX_SAFE_INTEGER)
-    return this.positions.filter(s => asAddress(s.staked) === asAddress(staked) && s.addBlock <= endBlock && s.removeBlock <= endBlock)
-  }
-
-  stakesByStaker(staker: Address, range: [number, number | undefined] = [0, undefined]): Position[] {
-    const endBlock = (range[1] ?? Number.MAX_SAFE_INTEGER)
-    return this.positions.filter(s => asAddress(s.staker) === asAddress(staker) && s.addBlock <= endBlock && s.removeBlock <= endBlock)
-  }
-
-  stakingTokenAddress(): Address {
-    return toAddress('0x000000000000000000000000000011')
-  }
-
-  async withdrawn() {
-    let withdrawn = 0n
-    const positions = await this.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  async withdrawnByStaker(staker: Address) {
-    let withdrawn = 0n
-    const positions = await this.withdrawnStakes()
-    for (const position of positions) {
-      if (position.withdrawBlock !== 0 && asAddress(position.staker) === asAddress(staker)) {
-        withdrawn += position.amount
-      }
-    }
-    return withdrawn
-  }
-
-  withdrawnStakes(): Promisable<Position[]> {
-    return this.positions.filter(s => (s.withdrawBlock !== 0))
-  }
-}

package/src/simple/StakeViewer/index.ts

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

package/src/simple/TransactionViewer/SimpleTransactionViewer.ts

@@ -1,100 +0,0 @@
-import {
-  assertEx, exists, Hash,
-} from '@xylabs/sdk-js'
-import { BoundWitnessSchema } from '@xyo-network/sdk-js'
-import {
-  asSignedHydratedTransactionWithHashMeta,
-  asSignedTransactionBoundWitness,
-  BlockViewer,
-  BlockViewerMoniker,
-  isTransactionBoundWitnessWithHashMeta,
-  SignedHydratedTransactionWithHashMeta, TransactionViewer, TransactionViewerMoniker,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-
-import {
-  AbstractCreatableProvider, creatableProvider, CreatableProviderParams,
-} from '../../CreatableProvider/index.ts'
-
-/** Parameters for SimpleTransactionViewer. */
-export interface SimpleTransactionViewerParams extends CreatableProviderParams {
-
-}
-
-/** SimpleTransactionViewer implementation. */
-@creatableProvider()
-export class SimpleTransactionViewer extends AbstractCreatableProvider<SimpleTransactionViewerParams> implements TransactionViewer {
-  static readonly defaultMoniker = TransactionViewerMoniker
-  static readonly dependencies = [BlockViewerMoniker]
-  static readonly monikers = [TransactionViewerMoniker]
-  moniker = SimpleTransactionViewer.defaultMoniker
-
-  private _blockViewer!: BlockViewer
-
-  protected get blockViewer() {
-    return this._blockViewer
-  }
-
-  async byBlockHashAndIndex(blockHash: Hash, transactionIndex: number): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byBlockHashAndIndex', async () => {
-      assertEx(transactionIndex >= 0, () => 'transactionIndex must be greater than or equal to 0')
-      try {
-        const block = await this.blockViewer.blockByHash(blockHash)
-        if (!block) return null
-        const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema ? index : undefined).filter(exists)
-        const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map(index => block[0].payload_hashes[index]))
-        const blockBoundWitnesses = block[1].filter(payload => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash))
-        const blockTransactionBoundWitnesses = blockBoundWitnesses.filter(isTransactionBoundWitnessWithHashMeta)
-        const transaction = blockTransactionBoundWitnesses.at(transactionIndex)
-        if (!transaction) return null
-        return await this.byHash(transaction._hash)
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  async byBlockNumberAndIndex(blockNumber: XL1BlockNumber, transactionIndex: number): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byBlockNumberAndIndex', async () => {
-      try {
-        const block = await this.blockViewer.blockByNumber(blockNumber)
-        if (!block) return null
-        return await this.byBlockHashAndIndex(block[0]._hash, transactionIndex)
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  async byHash(transactionHash: Hash): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.spanAsync('byHash', async () => {
-      try {
-        const transaction = asSignedTransactionBoundWitness(await this.blockViewer.payloadByHash(transactionHash))
-        if (transaction) {
-          const payloads = await this.blockViewer.payloadsByHash(transaction.payload_hashes)
-          return asSignedHydratedTransactionWithHashMeta([transaction, payloads]) ?? null
-        }
-        return null
-      } catch {
-        return null
-      }
-    }, this.context)
-  }
-
-  override async createHandler(): Promise<void> {
-    await super.createHandler()
-    this._blockViewer = await this.locator.getInstance<BlockViewer>(BlockViewerMoniker)
-  }
-
-  async transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number = 0): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byBlockHashAndIndex(blockHash, transactionIndex)
-  }
-
-  async transactionByBlockNumberAndIndex(blockNumber: XL1BlockNumber, transactionIndex: number = 0): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byBlockNumberAndIndex(blockNumber, transactionIndex)
-  }
-
-  async transactionByHash(transactionHash: Hash): Promise<SignedHydratedTransactionWithHashMeta | null> {
-    return await this.byHash(transactionHash)
-  }
-}

package/src/simple/TransactionViewer/index.ts

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