@xyo-network/chain-services 1.18.0 → 1.18.2

package/dist/neutral/implementation/chain/evm.d.ts

@@ -1,7 +0,0 @@
-import type { Initializable } from '@xyo-network/xl1-protocol';
-import type { Config } from '@xyo-network/xl1-protocol-sdk';
-import { EvmChainViewer } from '../../ChainService/index.ts';
-import type { BaseAccountableServiceParams } from '../../model/index.ts';
-export declare const canUseEvmContractChainService: (config: Pick<Config, "chain" | "evm">) => boolean;
-export declare const initEvmContractChainService: Initializable<BaseAccountableServiceParams, EvmChainViewer>;
-//# sourceMappingURL=evm.d.ts.map

package/dist/neutral/implementation/chain/evm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evm.d.ts","sourceRoot":"","sources":["../../../../src/implementation/chain/evm.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAI3D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAA;AAKxE,eAAO,MAAM,6BAA6B,GAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,KAAK,CAAC,YAGlF,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,aAAa,CAAC,4BAA4B,EAAE,cAAc,CAkBnG,CAAA"}

package/dist/neutral/implementation/chain/index.d.ts

@@ -1,6 +0,0 @@
-import type { Initializable } from '@xyo-network/xl1-protocol';
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk';
-import type { BaseAccountableServiceParams } from '../../model/index.ts';
-export declare const initChainService: Initializable<BaseAccountableServiceParams, ChainService>;
-export declare const initMemoryChainService: Initializable<BaseAccountableServiceParams, ChainService>;
-//# sourceMappingURL=index.d.ts.map

package/dist/neutral/implementation/chain/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/implementation/chain/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAA;AAKxE,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,4BAA4B,EACvE,YAAY,CAUb,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,4BAA4B,EAAE,YAAY,CAO5F,CAAA"}

package/src/BaseService.ts

@@ -1,45 +0,0 @@
-import type { EventData, Promisable } from '@xylabs/sdk-js'
-import { creatable } from '@xylabs/sdk-js'
-import { AbstractCreatableProvider } from '@xyo-network/xl1-protocol-sdk'
-import { Mutex } from 'async-mutex'
-
-import type { BaseAccountableServiceParams, BaseServiceParams } from './model/index.ts'
-
-declare global {
-  var xyoServiceSingletons: Record<string, unknown>
-}
-
-@creatable()
-export class BaseService<TParams extends BaseServiceParams = BaseServiceParams, TEventData extends EventData = EventData>
-  extends AbstractCreatableProvider<TParams, TEventData> {
-  private static singletonInitMutex = new Mutex()
-
-  static get singletons() {
-    return globalThis['xyoServiceSingletons'] ?? (globalThis['xyoServiceSingletons'] = {})
-  }
-
-  static initSingleton<TService extends BaseService<TParams>, TParams extends BaseServiceParams>(params: Partial<TParams>) {
-    if (this.singletons[this.name]) throw new Error(`Singleton already initialized for ${this.name}`)
-    return this.singletonInitMutex.runExclusive(async () => {
-      return await this.create(params) as TService
-    })
-  }
-}
-
-export abstract class BaseAccountableService<
-  TParams extends BaseAccountableServiceParams = BaseAccountableServiceParams,
-> extends BaseService<TParams> {
-  // Base class for services that have an account
-}
-
-export interface CreatableService<T extends BaseService = BaseService> {
-  new(params: T['params']): T
-  create<T extends BaseService>(this: CreatableService<T>, params?: Partial<T['params']>): Promisable<T>
-}
-
-export function creatableService<T extends BaseService = BaseService>() {
-  return <U extends CreatableService<T>>(constructor: U) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    constructor
-  }
-}

package/src/ChainService/Evm/Evm.ts

@@ -1,105 +0,0 @@
-import type {
-  Address, Hex, Promisable,
-} from '@xylabs/sdk-js'
-import { toAddress, toEthAddress } from '@xylabs/sdk-js'
-import type { StakedXyoChain } from '@xyo-network/typechain'
-import type { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
-import { ChainContractViewerMoniker, type ChainService } from '@xyo-network/xl1-protocol-sdk'
-import { getAddress } from 'ethers/address'
-import type { ContractRunner } from 'ethers/providers'
-
-import { BaseService } from '../../BaseService.ts'
-import type { BaseServiceParams } from '../../model/index.ts'
-
-export interface EvmChainViewerParams extends BaseServiceParams {
-  contract: StakedXyoChain
-  id: Hex
-  runner: ContractRunner
-}
-
-/**
- * A class that represents a chain stake as backed by an EVM smart contract
- */
-export class EvmChainViewer extends BaseService<EvmChainViewerParams> implements ChainService {
-  static readonly defaultMoniker = ChainContractViewerMoniker
-  static readonly monikers = [ChainContractViewerMoniker]
-  moniker = EvmChainViewer.defaultMoniker
-
-  protected get contract() {
-    return this.params.contract
-  }
-
-  async active(): Promise<bigint> {
-    return await (this.contract).active()
-  }
-
-  async activeByStaked(staked: Address): Promise<bigint> {
-    return await (this.contract).activeByAddressStaked(getAddress(toEthAddress(staked)))
-  }
-
-  async activeByStaker(address: Address): Promise<bigint> {
-    return await (this.contract).activeByStaker(getAddress(toEthAddress(address)))
-  }
-
-  async addStake(staked: Address, amount: bigint): Promise<boolean> {
-    const result = await (this.contract).addStake(getAddress(toEthAddress(staked)), amount)
-    await result.wait()
-    return true
-  }
-
-  async forkedAtBlockNumber(): Promise<bigint> {
-    return await (this.contract).forkedAtBlockNumber()
-  }
-
-  async forkedAtHash(): Promise<bigint> {
-    return await (this.contract).forkedAtHash()
-  }
-
-  async forkedChainId(): Promise<Address> {
-    return toAddress(await (this.contract).forkedChainId())
-  }
-
-  async minWithdrawalBlocks(): Promise<bigint> {
-    return await (this.contract).minWithdrawalBlocks()
-  }
-
-  async pending(): Promise<bigint> {
-    return await (this.contract).pending()
-  }
-
-  async pendingByStaker(staker: Address): Promise<bigint> {
-    return await (this.contract).pendingByStaker(getAddress(toEthAddress(staker)))
-  }
-
-  async removeStake(slot: bigint): Promise<boolean> {
-    const result = await (this.contract).removeStake(slot)
-    await result.wait()
-    return true
-  }
-
-  rewardForBlock(_block: XL1BlockNumber): Promisable<AttoXL1> {
-    throw new Error('Method not implemented.')
-  }
-
-  async rewardsContract(): Promise<string> {
-    return await (this.contract).rewardsContract()
-  }
-
-  async stakingTokenAddress(): Promise<string> {
-    return await (this.contract).stakingTokenAddress()
-  }
-
-  async withdrawStake(slot: bigint): Promise<boolean> {
-    const result = await (this.contract).withdrawStake(slot)
-    await result.wait()
-    return true
-  }
-
-  async withdrawn(): Promise<bigint> {
-    return await (this.contract).withdrawn()
-  }
-
-  async withdrawnByStaker(staker: string): Promise<bigint> {
-    return await (this.contract).withdrawnByStaker(getAddress(staker))
-  }
-}

package/src/ChainService/Evm/index.ts

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

package/src/ChainService/Memory/Memory.ts

@@ -1,106 +0,0 @@
-import type {
-  Address, Hex, Promisable,
-} from '@xylabs/sdk-js'
-import { toAddress, ZERO_ADDRESS } from '@xylabs/sdk-js'
-import type { AttoXL1, XL1BlockNumber } from '@xyo-network/xl1-protocol'
-import {
-  ChainContractViewerMoniker,
-  type ChainService,
-} from '@xyo-network/xl1-protocol-sdk'
-
-import { BaseService } from '../../BaseService.ts'
-import type { BaseServiceParams } from '../../model/index.ts'
-
-export interface MemoryChainViewerParams extends BaseServiceParams {
-  chainId: Hex
-}
-
-/**
- * A class that represents a chain stake as backed in memory
- */
-export class MemoryChainViewer extends BaseService<MemoryChainViewerParams> implements ChainService {
-  static readonly defaultMoniker = ChainContractViewerMoniker
-  static readonly monikers = [ChainContractViewerMoniker]
-  moniker = MemoryChainViewer.defaultMoniker
-
-  protected _chainId: Hex | undefined
-  protected _simulatedStake: bigint = 1n
-
-  async active(): Promise<bigint> {
-    return await Promise.resolve(this._simulatedStake)
-  }
-
-  async activeByStaked(_staked: Address): Promise<bigint> {
-    return await Promise.resolve(this._simulatedStake)
-  }
-
-  async activeByStaker(_address: string): Promise<bigint> {
-    return await Promise.resolve(this._simulatedStake)
-  }
-
-  async addStake(_staked: string, _amount: bigint): Promise<boolean> {
-    return await Promise.resolve(true)
-  }
-
-  override createHandler(): void {
-    const { minStake = 1 } = this.params.context.config.producer ?? {}
-    this._simulatedStake = BigInt(minStake)
-  }
-
-  async forkedAtBlockNumber(): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  async forkedAtHash(): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  async forkedChainId(): Promise<Address> {
-    return await Promise.resolve(ZERO_ADDRESS)
-  }
-
-  async minWithdrawalBlocks(): Promise<bigint> {
-    return await Promise.resolve(1n)
-  }
-
-  async pending(): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  async pendingByStaker(_staker: string): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  async removeStake(_slot: bigint): Promise<boolean> {
-    return await Promise.resolve(true)
-  }
-
-  rewardForBlock(_block: XL1BlockNumber): Promisable<AttoXL1> {
-    throw new Error('Method not implemented.')
-  }
-
-  async rewardsContract(): Promise<string> {
-    return await Promise.resolve('')
-  }
-
-  async stakingTokenAddress(): Promise<string> {
-    return await Promise.resolve('')
-  }
-
-  async withdrawStake(_slot: bigint): Promise<boolean> {
-    return await Promise.resolve(true)
-  }
-
-  async withdrawn(): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  async withdrawnByStaker(_staker: string): Promise<bigint> {
-    return await Promise.resolve(0n)
-  }
-
-  protected override async startHandler(): Promise<void> {
-    await super.startHandler()
-    this._chainId = this.params.chainId ?? toAddress(1n)
-  }
-}

package/src/ChainService/Memory/index.ts

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

package/src/ChainService/index.ts

@@ -1,2 +0,0 @@
-export * from './Evm/index.ts'
-export * from './Memory/index.ts'

package/src/implementation/chain/evm.ts

@@ -1,39 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx, isDefined, ZERO_ADDRESS,
-} from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import type { Config } from '@xyo-network/xl1-protocol-sdk'
-import type { ContractRunner } from 'ethers'
-import { Wallet } from 'ethers/wallet'
-
-import { EvmChainViewer } from '../../ChainService/index.ts'
-import type { BaseAccountableServiceParams } from '../../model/index.ts'
-import { canUseEvmProvider, initEvmProvider } from '../evm/index.ts'
-
-let chainStakeServiceSingleton: Promisable<EvmChainViewer> | undefined
-
-export const canUseEvmContractChainService = (config: Pick<Config, 'chain' | 'evm'>) => {
-  const { id } = config.chain
-  return isDefined(id) && id !== ZERO_ADDRESS && canUseEvmProvider({ config })
-}
-
-export const initEvmContractChainService: Initializable<BaseAccountableServiceParams, EvmChainViewer> = async ({
-  account, context: { config }, traceProvider, meterProvider, logger,
-}) => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
-  // Parse config
-  const emvStakingContractAddress = assertEx(config.chain.id, () => 'config.chain.id is required')
-  // Configure ContractRunner
-  const id: Address = assertEx(asAddress(emvStakingContractAddress), () => 'config.chain.id is not a valid address')
-  const provider = assertEx(await initEvmProvider({ config }))
-  const privateKey = assertEx(account.private?.hex, () => 'Account does not have a private key')
-  const runner: ContractRunner = new Wallet(privateKey, provider)
-  // Create service
-  chainStakeServiceSingleton = EvmChainViewer.create({
-    id, runner, traceProvider, meterProvider, logger,
-  })
-  const result = await chainStakeServiceSingleton
-  await result.start()
-  return result
-}

package/src/implementation/chain/index.ts

@@ -1,44 +0,0 @@
-import {
-  assertEx, type CreatableName, type Promisable,
-} from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import type { ChainService } from '@xyo-network/xl1-protocol-sdk'
-
-import { MemoryChainViewer } from '../../ChainService/index.ts'
-import type { BaseAccountableServiceParams } from '../../model/index.ts'
-import { canUseEvmContractChainService, initEvmContractChainService } from './evm.ts'
-
-let chainStakeServiceSingleton: Promisable<ChainService> | undefined
-
-export const initChainService: Initializable<BaseAccountableServiceParams,
-  ChainService> = ({ account, context }) => {
-  const { logger } = context
-  logger?.log('ChainService: Initializing...')
-  const result = init({
-    context,
-    name: 'ChainService' as CreatableName,
-    account,
-  })
-  logger?.log('ChainService: Initialized')
-  return result
-}
-
-export const initMemoryChainService: Initializable<BaseAccountableServiceParams, ChainService> = async ({ context }) => {
-  const result = await MemoryChainViewer.create({
-    context,
-    name: 'MemoryChainService' as CreatableName,
-  })
-  assertEx(await result.start(), () => 'Failed to start MemoryChainService')
-  return result
-}
-
-const init: Initializable<BaseAccountableServiceParams,
-  ChainService> = async (params): Promise<ChainService> => {
-  if (chainStakeServiceSingleton) return chainStakeServiceSingleton
-  const { config } = params.context
-  chainStakeServiceSingleton = canUseEvmContractChainService(config)
-    ? await initEvmContractChainService({ ...params, name: 'ChainStakeService' as CreatableName })
-    : await initMemoryChainService(params)
-  // Create service
-  return chainStakeServiceSingleton
-}