@xyo-network/chain-services 1.17.0 → 1.17.1

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,98 +0,0 @@
-import {
-  Address, assertEx, creatable, Hash,
-} from '@xylabs/sdk-js'
-import { spanRootAsync } from '@xylabs/telemetry'
-import { ReadArchivist } from '@xyo-network/archivist-model'
-import { AttoXL1, XL1BlockRange } from '@xyo-network/xl1-protocol'
-import {
-  AccountBalanceHistoryItem,
-  AccountBalanceViewer,
-  balancesSummary,
-  BalanceStepSummaryContext,
-  BlockViewer,
-  SimpleAccountBalanceViewer,
-  TransfersStepSummaryContext,
-} from '@xyo-network/xl1-protocol-sdk'
-import z from 'zod'
-
-import { BaseService } from '../BaseService.ts'
-import { BaseServiceParams } from '../model/index.ts'
-
-export const BaseAccountBalanceServiceParamsZod = z.object({
-  blockViewer: z.object().loose(),
-  chainArchivist: z.object().loose(),
-  chainIterator: z.object().loose(),
-  context: z.object().loose(),
-  transferContext: z.object().loose(),
-})
-
-export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
-  blockViewer: BlockViewer
-  chainArchivist: ReadArchivist
-  context: BalanceStepSummaryContext
-  transfersSummaryContext: TransfersStepSummaryContext
-}
-
-@creatable()
-export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceViewer {
-  protected accountBalanceViewer!: AccountBalanceViewer
-
-  protected get blockViewer() {
-    return assertEx(this.params.blockViewer, () => 'BlockViewer has not been initialized yet')
-  }
-
-  static override async paramsHandler(params?: Partial<BaseAccountBalanceServiceParams> | undefined): Promise<BaseAccountBalanceServiceParams> {
-    // TODO: Use a real zod and move the zod check to the AbstractCreatable class
-    BaseAccountBalanceServiceParamsZod.parse(params)
-    assertEx(params?.context?.head, () => 'BalanceStepSummaryContext is required in BaseAccountBalanceServiceParams')
-    return { ...(await super.paramsHandler(params)), ...params } as BaseAccountBalanceServiceParams
-  }
-
-  async accountBalance(address: Address, headOrRange?: XL1BlockRange | Hash): Promise<AttoXL1> {
-    const balances = await this.accountsBalances([address], headOrRange)
-    return balances[address] ?? AttoXL1(0n)
-  }
-
-  async accountBalanceHistory(address: Address): Promise<AccountBalanceHistoryItem[]>
-  async accountBalanceHistory(address: Address, head: Hash): Promise<AccountBalanceHistoryItem[]>
-  async accountBalanceHistory(address: Address, range: XL1BlockRange): Promise<AccountBalanceHistoryItem[]>
-  accountBalanceHistory(_address: Address, _headOrRange?: Hash | XL1BlockRange): Promise<AccountBalanceHistoryItem[]> {
-    throw new Error('Method not implemented.')
-  }
-
-  async accountsBalances(address: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AttoXL1>>> {
-    return await spanRootAsync('balances', async () => {
-      const context = {
-        head: this.params.context.head,
-        stepSemaphores: this.params.context.stepSemaphores,
-        store: this.params.context.store,
-        chainId: this.params.context.chainId,
-        summaryMap: this.params.context.summaryMap,
-      } satisfies BalanceStepSummaryContext
-      const summary = await balancesSummary(
-        context,
-      )
-      const result: Record<Address, AttoXL1> = {}
-      for (const addr of address) {
-        const summaryBalance = summary[addr] ?? 0n
-        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
-      }
-      return result
-    })
-  }
-
-  async accountsBalancesHistory(addresses: Address[]): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountsBalancesHistory(addresses: Address[], head: Hash): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  async accountsBalancesHistory(addresses: Address[], range: XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>>
-  accountsBalancesHistory(_addresses: Address[], _headOrRange?: Hash | XL1BlockRange): Promise<Partial<Record<Address, AccountBalanceHistoryItem[]>>> {
-    throw new Error('Method not implemented.')
-  }
-
-  override async createHandler() {
-    this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
-      context: this.params.context,
-      transfersSummaryContext: this.params.transfersSummaryContext,
-      blockViewer: this.blockViewer,
-    })
-  }
-}

package/src/AccountTransfers/BaseAccountTransfersService.ts

@@ -1,36 +0,0 @@
-import {
-  Address, creatable, Hash,
-} from '@xylabs/sdk-js'
-import { spanRootAsync } from '@xylabs/telemetry'
-import { AttoXL1 } from '@xyo-network/xl1-protocol'
-import {
-  AccountTransfersService,
-  TransfersStepSummaryContext,
-  transfersSummary,
-} from '@xyo-network/xl1-protocol-sdk'
-
-import { BaseService } from '../BaseService.ts'
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseAccountTransferServiceParams extends BaseServiceParams {
-  context: TransfersStepSummaryContext
-}
-
-@creatable()
-export class BaseAccountTransfersService extends BaseService<BaseAccountTransferServiceParams> implements AccountTransfersService {
-  async transfer(head: Hash, address: Address): Promise<AttoXL1> {
-    return (await this.transfers(head, [address]))[address] ?? AttoXL1(0n)
-  }
-
-  async transfers(head: Hash, addresses: Address[]): Promise<Partial<Record<Address, AttoXL1>>> {
-    return await spanRootAsync('transfers', async () => {
-      const summary = await transfersSummary(this.params.context)
-      const result: Record<Address, AttoXL1> = {}
-      for (const addr of addresses) {
-        const summaryBalance = summary[addr] ?? 0n
-        result[addr] = AttoXL1(summaryBalance)
-      }
-      return result
-    })
-  }
-}

package/src/AccountTransfers/index.ts

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

package/src/BlockProducer/index.ts

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

package/src/BlockReward/BaseBlockRewardService.ts

@@ -1,17 +0,0 @@
-import {
-  creatable, EmptyObject, Promisable,
-} from '@xylabs/sdk-js'
-import { BlockRewardService } from '@xyo-network/xl1-protocol-sdk'
-
-import { BaseService } from '../BaseService.ts'
-import { BaseServiceParams } from '../model/index.ts'
-
-export interface BaseBlockRewardServiceParams<TConfig extends EmptyObject = EmptyObject> extends BaseServiceParams<TConfig> {}
-
-@creatable()
-export class BaseBlockRewardService<TParams extends BaseBlockRewardServiceParams = BaseBlockRewardServiceParams>
-  extends BaseService<TParams> implements BlockRewardService {
-  getRewardForBlock(_blockNumber: bigint): Promisable<bigint> {
-    throw new Error('getRewardForBlock method must be implemented in derived classes')
-  }
-}

package/src/BlockReward/EvmBlockRewardService.ts

@@ -1,49 +0,0 @@
-import {
-  assertEx, creatable, toEthAddress,
-} from '@xylabs/sdk-js'
-import { AccountInstance } from '@xyo-network/account-model'
-import { XyoChainRewards__factory as XyoChainRewardsFactory } from '@xyo-network/typechain'
-import {
-  BlockRewardService, ChainService, Config,
-} from '@xyo-network/xl1-protocol-sdk'
-import { Provider } from 'ethers/providers'
-
-import { BaseBlockRewardService, BaseBlockRewardServiceParams } from './BaseBlockRewardService.ts'
-
-export interface EvmBlockRewardServiceParams extends BaseBlockRewardServiceParams<Pick<Config, 'evm'>> {
-  account: AccountInstance
-  chainService?: ChainService
-  provider?: Provider
-}
-
-@creatable()
-export class EvmBlockRewardService extends BaseBlockRewardService<EvmBlockRewardServiceParams> implements BlockRewardService {
-  protected _contractAddress: string | undefined
-
-  protected get chainService() {
-    return assertEx(this.params.chainService, () => 'chainService is required')
-  }
-
-  protected get contractAddress() {
-    return assertEx(this._contractAddress, () => 'contractAddress is required')
-  }
-
-  protected get provider() {
-    return assertEx(this.params.provider, () => 'provider is required')
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    try {
-      this._contractAddress = await this.chainService.rewardsContract()
-    } catch (ex) {
-      const error = ex as Error
-      throw new Error(`Failed to get rewards contract address: ${error.message}`)
-    }
-  }
-
-  override async getRewardForBlock(blockNumber: bigint): Promise<bigint> {
-    const contract = XyoChainRewardsFactory.connect(toEthAddress(this.contractAddress), this.provider)
-    return await contract.calcBlockReward(blockNumber)
-  }
-}

package/src/BlockReward/MemoryBlockRewardService.ts

@@ -1,72 +0,0 @@
-import {
-  assertEx, creatable, Promisable, toFixedPoint,
-} from '@xylabs/sdk-js'
-import { rewardFromBlockNumber } from '@xyo-network/chain-protocol'
-import { BlockRewardService } from '@xyo-network/xl1-protocol-sdk'
-
-import { BaseBlockRewardService, BaseBlockRewardServiceParams } from './BaseBlockRewardService.ts'
-
-export interface MemoryBlockRewardServiceParams extends BaseBlockRewardServiceParams {
-  creatorReward?: bigint
-  initialStepReward?: bigint
-  minRewardPerBlock?: bigint
-  stepFactorDenominator?: bigint
-  stepFactorNumerator?: bigint
-  stepSize?: bigint
-}
-
-@creatable()
-export class MemoryBlockRewardService<TParams extends MemoryBlockRewardServiceParams = MemoryBlockRewardServiceParams>
-  extends BaseBlockRewardService<TParams> implements BlockRewardService {
-  protected readonly rewardFromBlockNumber = rewardFromBlockNumber(18)
-
-  get creatorReward() {
-    return assertEx(this.params.creatorReward, () => 'creatorReward is required')
-  }
-
-  get initialReward() {
-    return assertEx(this.params.initialStepReward, () => 'initialStepReward is required')
-  }
-
-  get minRewardPerBlock() {
-    return assertEx(this.params.minRewardPerBlock, () => 'minRewardPerBlock is required')
-  }
-
-  get stepFactorDenominator() {
-    return assertEx(this.params.stepFactorDenominator, () => 'stepFactorDenominator is required')
-  }
-
-  get stepFactorNumerator() {
-    return assertEx(this.params.stepFactorNumerator, () => 'stepFactorNumerator is required')
-  }
-
-  get stepSize() {
-    return assertEx(this.params.stepSize, () => 'stepSize is required')
-  }
-
-  static override async paramsHandler<T extends MemoryBlockRewardService['params']>(
-    inParams?: Partial<T>,
-  ): Promise<T> {
-    return {
-      ...await super.paramsHandler(inParams),
-      creatorReward: inParams?.creatorReward ?? toFixedPoint(20_000_000_000n),
-      initialStepReward: inParams?.initialStepReward ?? toFixedPoint(3000n),
-      minRewardPerBlock: inParams?.minRewardPerBlock ?? toFixedPoint(30n),
-      stepFactorDenominator: inParams?.stepFactorDenominator ?? 100n,
-      stepFactorNumerator: inParams?.stepFactorNumerator ?? 90n,
-      stepSize: inParams?.stepSize ?? 1_000_000n,
-    } as T
-  }
-
-  override getRewardForBlock(blockNumber: bigint): Promisable<bigint> {
-    return this.rewardFromBlockNumber(
-      blockNumber,
-      this.initialReward,
-      this.stepSize,
-      this.stepFactorNumerator,
-      this.stepFactorDenominator,
-      this.minRewardPerBlock,
-      this.creatorReward,
-    )
-  }
-}