@xyo-network/chain-services 1.17.7 → 1.18.0

package/src/implementation/reward.ts

@@ -1,53 +0,0 @@
-import type { Logger } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import type {
-  BlockRewardViewer, ChainContractViewer, Config, SimpleBlockRewardViewerParams,
-} from '@xyo-network/xl1-protocol-sdk'
-import { SimpleBlockRewardViewer, timeBudget } from '@xyo-network/xl1-protocol-sdk'
-
-import { EvmBlockRewardViewer, type EvmBlockRewardViewerParams } from '../BlockReward/index.ts'
-import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
-
-let rewardServiceSingleton: Promise<BlockRewardViewer> | undefined
-
-export const initBlockRewardViewer: Initializable<
-  Partial<SimpleBlockRewardViewerParams> & {
-    chainContractViewer: ChainContractViewer
-    config: Pick<Config, 'evm'>
-  },
-  BlockRewardViewer
-> = (params): Promise<BlockRewardViewer> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return timeBudget('initBlockRewardViewer', params.logger, () => {
-    const { config } = params
-    rewardServiceSingleton = canUseEvmBlockRewardViewer({ config })
-      ? initEvmBlockRewardViewer(params)
-      : initXyoBlockRewardViewer(params as SimpleBlockRewardViewerParams)
-    return rewardServiceSingleton
-  }, 2000, true)
-}
-
-export const initXyoBlockRewardViewer = (params: SimpleBlockRewardViewerParams): Promise<BlockRewardViewer> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return timeBudget('initXyoBlockRewardViewer', params.logger, () => {
-    rewardServiceSingleton = SimpleBlockRewardViewer.create(params)
-    return rewardServiceSingleton
-  }, 2000, true)
-}
-
-const canUseEvmBlockRewardViewer = (params: { config: Pick<Config, 'evm'> }) => canUseEvmProvider({ config: params.config })
-
-export const initEvmBlockRewardViewer = async (params: ({
-  chainContractViewer: ChainContractViewer
-  config: Pick<Config, 'evm'>
-  logger?: Logger
-})): Promise<BlockRewardViewer> => {
-  if (rewardServiceSingleton) return rewardServiceSingleton
-  return await timeBudget('initEvmBlockRewardViewer', params.logger, async () => {
-    const provider = assertEx(await initEvmProvider(params))
-    const evmBlockRewardViewerParams: EvmBlockRewardViewerParams = { ...params, provider }
-    rewardServiceSingleton = EvmBlockRewardViewer.create(evmBlockRewardViewerParams)
-    return rewardServiceSingleton
-  }, 2000, true)
-}

package/src/implementation/time.ts

@@ -1,26 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import { timeBudget, type TimeSyncViewer } from '@xyo-network/xl1-protocol-sdk'
-import type { Config } from 'cosmiconfig'
-
-import { type BaseTimeServiceParams, BaseTimeSyncService } from '../Time/index.ts'
-import { canUseEvmProvider, initEvmProvider } from './evm/index.ts'
-
-let timeSyncServiceSingleton: Promisable<TimeSyncViewer> | undefined
-
-export const initTimeService: Initializable<BaseTimeServiceParams<Pick<Config, 'evm'>>, TimeSyncViewer> = async ({
-  blockViewer, config, logger, meterProvider, traceProvider,
-}) => {
-  if (timeSyncServiceSingleton) return timeSyncServiceSingleton
-
-  return await timeBudget('initTimeService', logger, async () => {
-  // Configure provider for optional Ethereum time sync
-    const ethProvider = canUseEvmProvider({ config }) ? await initEvmProvider({ config }) : undefined
-
-    // Create service
-    timeSyncServiceSingleton = BaseTimeSyncService.create({
-      blockViewer, ethProvider, logger, meterProvider, traceProvider,
-    })
-    return await timeSyncServiceSingleton
-  }, 2000, true)
-}

package/src/implementation/validator.ts

@@ -1,15 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { Initializable } from '@xyo-network/xl1-protocol'
-import type { BlockProducerService } from '@xyo-network/xl1-protocol-sdk'
-
-import type { SimpleBlockRunnerParams } from '../simple/index.ts'
-import { initBlockProducer } from './producer.ts'
-
-let serviceSingleton: Promisable<BlockProducerService> | undefined
-
-export const initValidator: Initializable<SimpleBlockRunnerParams, BlockProducerService>
-  = (params: SimpleBlockRunnerParams): Promisable<BlockProducerService> => {
-    if (serviceSingleton) return serviceSingleton
-    serviceSingleton = initBlockProducer(params)
-    return serviceSingleton
-  }

package/src/simple/block/runner/spec/SimpleBlockRunner.ts

@@ -1,418 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import type {
-  Address, CreatableName, Hash, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  asAddress, assertEx,
-  delay,
-  exists,
-  filterAs,
-  hexToBigInt, ZERO_HASH,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  buildRandomChain, buildRandomTransaction, createGenesisBlock,
-} from '@xyo-network/chain-protocol'
-import { validateHydratedBlockState } from '@xyo-network/chain-validation'
-import type { PayloadBundle, WithHashMeta } from '@xyo-network/payload-model'
-import { PayloadBundleSchema } from '@xyo-network/payload-model'
-import { HDWallet } from '@xyo-network/wallet'
-import type {
-  BlockBoundWitness, ChainId,
-  HydratedBlock,
-  TimeDomain, TimePayload,
-} from '@xyo-network/xl1-protocol'
-import {
-  asBlockBoundWitness,
-  asTransfer,
-  isTransactionBoundWitness,
-  TimeSchema,
-  XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol'
-import type {
-  BlockRewardViewer,
-  Config, ElectionService,
-  HydratedBlockStateValidationFunction, MempoolRunner, MempoolViewer, StakeIntentService,
-  TimeSyncViewer,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  flattenHydratedBlock, flattenHydratedTransaction, getDefaultConfig,
-  HydratedBlockStateValidationError,
-  SimpleBlockRewardViewer,
-  SimpleMempoolRunner,
-  SimpleMempoolViewer,
-  TimeSyncViewerMoniker,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  beforeAll, beforeEach, describe, expect, it,
-} from 'vitest'
-import { mock } from 'vitest-mock-extended'
-
-import { accountBalancesViewerFromArchivist } from '../../../../AccountBalance/index.ts'
-import type { SimpleBlockRunnerParams } from '../SimpleBlockRunner.ts'
-import { SimpleBlockRunner } from '../SimpleBlockRunner.ts'
-
-describe('SimpleBlockRunner', () => {
-  const leaderCount = 3
-  let mempoolViewer: MempoolViewer
-  let mempoolRunner: MempoolRunner
-  let account: AccountInstance
-  let blockProducer: SimpleBlockRunner
-  let chainArchivist: ArchivistInstance
-  // let chainIterator: EventingChainBlockNumberIteratorService
-  let electionService: ReturnType<typeof mock<ElectionService>>
-  let pendingTransactionsArchivist: ArchivistInstance
-  let pendingBlocksArchivist: ArchivistInstance
-  let rejectedTransactionsArchivist: ArchivistInstance
-  let rewardAddress = '1111111111111111111111111111111111111111' as Address
-  let blockRewardViewer: BlockRewardViewer
-  let stakeIntentService: ReturnType<typeof mock<StakeIntentService>>
-  let time: TimeSyncViewer
-  let transactionAccount: AccountInstance
-  const validPendingTransactions = Math.ceil(SimpleBlockRunner.DefaultBlockSize)
-  let config: Config
-
-  let currentBlock: WithHashMeta<BlockBoundWitness>
-
-  const chainId = assertEx(asAddress('Be17531fec6fEc55f3EAc3f1c187c87e4C47F81E'))
-
-  beforeAll(async () => {
-    account = await Account.random()
-    transactionAccount = await HDWallet.fromPhrase('room maximum palace fragile man pyramid school indoor base business want bronze assume marble report')
-  })
-
-  beforeEach(async () => {
-    config = getDefaultConfig()
-    config.producer.disableIntentRedeclaration = false
-    chainArchivist = await MemoryArchivist.create({ account: 'random' })
-    const genesisBlock = await createGenesisBlock(account, chainId, 0n, account.address)
-    await chainArchivist.insert([...genesisBlock[1], genesisBlock[0]])
-    // const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(chainArchivist)
-    // chainIterator = await ChainBlockNumberIterationService.create({
-    //   chainMap,
-    //   config,
-    // })
-    rejectedTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    electionService = mock<ElectionService>()
-    pendingTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
-    pendingBlocksArchivist = await MemoryArchivist.create({ account: 'random' })
-    mempoolViewer = await SimpleMempoolViewer.create({ pendingBlocksArchivist, pendingTransactionsArchivist })
-    mempoolRunner = await SimpleMempoolRunner.create({ pendingBlocksArchivist, pendingTransactionsArchivist })
-    // const BasePendingTransactionsServiceParams = {
-    //   name: 'TestBasePendingTransactionsServiceParams' as CreatableName,
-    //   chainArchivist,
-    //   chainId,
-    //   config,
-    //   pendingTransactionsArchivist,
-    //   rejectedTransactionsArchivist,
-    // } satisfies BasePendingTransactionsServiceParams
-    // pendingTransactionsService = await BasePendingTransactionsService.create(BasePendingTransactionsServiceParams)
-    // await addPendingTransactions(validPendingTransactions)
-
-    stakeIntentService = mock<StakeIntentService>()
-    stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
-    time = {
-      currentTimeAndHash(domain: TimeDomain): Promisable<[number, Hash | null]> {
-        switch (domain) {
-          case 'epoch': {
-            return [Date.now(), null]
-          }
-          case 'xl1': {
-            return [1, '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff' as Hash]
-          }
-          case 'ethereum': {
-            return [1, '00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff' as Hash]
-          }
-        // No default
-        }
-      },
-      currentTime(domain: TimeDomain): Promisable<[string, number]> {
-        switch (domain) {
-          case 'epoch': {
-            return ['epoch', Date.now()]
-          }
-          case 'xl1': {
-            return ['xl1', 1]
-          }
-          case 'ethereum': {
-            return ['ethereum', 1]
-          }
-        // No default
-        }
-      },
-      currentTimePayload(): Promisable<TimePayload> {
-        return {
-          schema: TimeSchema, epoch: Date.now(), xl1: 1,
-        }
-      },
-      /** Convert time between different domains */
-      convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promisable<number> {
-        if (fromDomain === toDomain) {
-          return from
-        }
-        if (fromDomain === 'epoch' && toDomain === 'xl1') {
-          return 1
-        }
-        if (fromDomain === 'xl1' && toDomain === 'epoch') {
-          return Date.now()
-        }
-        return from
-      },
-      moniker: TimeSyncViewerMoniker,
-    }
-    blockRewardViewer = await SimpleBlockRewardViewer.create()
-    const payloads = await chainArchivist.next({ limit: 1000 })
-    expect(payloads.length).toBe(9)
-    const balanceViewer = await accountBalancesViewerFromArchivist(chainId, chainArchivist)
-    const params: SimpleBlockRunnerParams = {
-      name: 'TestXyoBlockProducerParams' as CreatableName,
-      account,
-      balanceViewer,
-      chainId,
-      config,
-      mempoolRunner,
-      mempoolViewer,
-      // electionService,
-      // pendingTransactionsService,
-      // pendingBundledTransactionsArchivist,
-      rejectedTransactionsArchivist,
-      rewardAddress,
-      blockRewardViewer,
-      // stakeIntentService,
-      time,
-      validateHydratedBlockState,
-    }
-    blockProducer = await SimpleBlockRunner.create(params)
-  })
-
-  const addPendingTransactions = async (count: number = validPendingTransactions) => {
-    for (let i = 0; i < count; i++) {
-      const transaction = await buildRandomTransaction(chainId, [], transactionAccount)
-      const bundledPayload: PayloadBundle = {
-        schema: PayloadBundleSchema, payloads: flattenHydratedTransaction(transaction), root: transaction[0]._hash,
-      }
-      await pendingTransactionsArchivist.insert([bundledPayload])
-    }
-  }
-
-  describe('next', () => {
-    describe('block production', () => {
-      describe('when not current block leader', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          const leaders = await Promise.all(Array.from({ length: leaderCount }, async () => (await Account.random()).address))
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue(leaders)
-          stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
-        })
-        it('should return undefined', async () => {
-        // Arrange
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeUndefined()
-        })
-      })
-      describe('when current block leader', () => {
-        beforeEach(async () => {
-          const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-          currentBlock = hydratedBlock[0]
-          await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-          await delay(1000)
-          electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-        })
-        it('should return a valid block', async () => {
-          // Arrange
-          await addPendingTransactions(validPendingTransactions)
-
-          // Act
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, transactionsAndData] = result ?? []
-          expect(block).toBeDefined()
-          expect(asBlockBoundWitness(block)).toBeDefined()
-          expect(transactionsAndData).toBeDefined()
-          expect(transactionsAndData).toBeArray()
-          const transactions = transactionsAndData?.filter(isTransactionBoundWitness).filter(exists)
-          expect(transactions).toBeArrayOfSize(validPendingTransactions)
-        })
-
-        it('should remove invalid transactions', async () => {
-          // Arrange
-          let rejectBlock = true
-          const validateHydratedBlockState: HydratedBlockStateValidationFunction = async (
-            hydratedBlock: HydratedBlock,
-            chainId: ChainId,
-          ) => {
-            return rejectBlock ? [await Promise.resolve(new HydratedBlockStateValidationError(ZERO_HASH, chainId, hydratedBlock, 'Invalid block'))] : []
-          }
-          // const blockViewer = blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist)
-          const balanceViewer = await accountBalancesViewerFromArchivist(chainId, chainArchivist)
-          const params: SimpleBlockRunnerParams = {
-            name: 'TestXyoBlockProducerParams' as CreatableName,
-            account,
-            balanceViewer,
-            chainId,
-            config,
-            // electionService,
-            mempoolRunner,
-            mempoolViewer,
-            // pendingBundledTransactionsArchivist,
-            // pendingTransactionsService,
-            rejectedTransactionsArchivist,
-            rewardAddress,
-            blockRewardViewer,
-            // stakeIntentService,
-            time,
-            validateHydratedBlockState,
-          }
-          blockProducer = await SimpleBlockRunner.create(params)
-
-          // Act
-          // Force producer to reject first block
-          rejectBlock = true
-          // const invalidTransactionCount = Math.floor(validPendingTransactions / 2)
-          // await addPendingTransactions(invalidTransactionCount)
-
-          // Ensure bad block is not produced
-          const firstResult = await blockProducer.next(currentBlock)
-          expect(firstResult).toBeUndefined()
-          // Do not reject second block
-          rejectBlock = false
-          // Add more pending transactions
-          const newTransactionCount = Math.floor(validPendingTransactions / 2)
-          await addPendingTransactions(newTransactionCount)
-          // Ensure producer recovers from bad block
-          const result = await blockProducer.next(currentBlock)
-
-          // Assert
-          expect(result).toBeDefined()
-          expect(result).toBeArrayOfSize(2)
-          const [block, transactionsAndData] = result ?? []
-          expect(block).toBeDefined()
-          if (block) {
-            expect(asBlockBoundWitness(block)).toBeDefined()
-            expect(transactionsAndData).toBeDefined()
-            expect(transactionsAndData).toBeArray()
-            const transactions = transactionsAndData?.filter(isTransactionBoundWitness).filter(exists) ?? []
-            expect(transactions).toBeArrayOfSize(newTransactionCount)
-            const transfers = filterAs(assertEx(transactionsAndData), asTransfer)
-            const blockRewardTransfer = transfers.find(transfer => transfer.from === XYO_ZERO_ADDRESS)
-            expect(blockRewardTransfer).toBeDefined()
-            let totalTransfer = 0n
-            for (const value of Object.values(blockRewardTransfer?.transfers ?? {})) {
-              const bigIntValue = hexToBigInt(value)
-              totalTransfer += bigIntValue
-            }
-            expect(hexToBigInt(Object.values(blockRewardTransfer!.transfers ?? {})[0])).toBe(25_000_000_000_000_000_000n)
-            expect(hexToBigInt(Object.values(blockRewardTransfer!.transfers ?? {})[1])).toBe(475_000_000_000_000_000_000n)
-            expect(totalTransfer).toEqual(500_000_000_000_000_000_000n)
-          }
-        })
-      })
-    })
-    // describe('producer re-declare intent', () => {
-    //   describe('when within re-declare intent window', () => {
-    //     beforeEach(async () => {
-    //       const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-    //       currentBlock = hydratedBlock[0]
-    //       await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-    //       electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-    //       stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([[0, 10]])
-    //     })
-    //     it('should re-declare intent if configured for re-declaration', async () => {
-    //       // Arrange
-    //       config.producer.disableIntentRedeclaration = false
-
-    //       // Act
-    //       const result = await blockProducer.next(currentBlock)
-
-    //       // Assert
-    //       expect(result).toBeDefined()
-    //       expect(result).toBeArrayOfSize(2)
-    //       const [block, payloads] = result ?? []
-    //       expect(block).toBeDefined()
-    //       expect(asBlockBoundWitness(block)).toBeDefined()
-    //       expect(payloads).toBeArray()
-    //       const allData = flattenHydratedBlock(assertEx(result))
-    //       const declaration = filterAs(allData, asChainStakeIntent).at(0)
-    //       expect(declaration).toBeDefined()
-    //       expect(declaration?.from).toEqual(blockProducer.address)
-    //     })
-    //     it('should not re-declare intent if not configured for re-declaration', async () => {
-    //     // Arrange
-    //       config.producer.disableIntentRedeclaration = true
-
-    //       // Act
-    //       const result = await blockProducer.next(currentBlock)
-
-    //       // Assert
-    //       expect(result).toBeDefined()
-    //       expect(result).toBeArrayOfSize(2)
-    //       const [block, payloads] = result ?? []
-    //       expect(block).toBeDefined()
-    //       expect(asBlockBoundWitness(block)).toBeDefined()
-    //       expect(payloads).toBeArray()
-    //       const allData = flattenHydratedBlock(assertEx(result))
-    //       const declaration = filterAs(allData, asChainStakeIntent).at(0)
-    //       expect(declaration).toBeUndefined()
-    //     })
-    //   })
-    //   describe('when not within re-declare intent window', () => {
-    //     beforeEach(async () => {
-    //       const [hydratedBlock] = await buildRandomChain(account, 1, undefined, chainId, transactionAccount)
-    //       currentBlock = hydratedBlock[0]
-    //       await chainArchivist.insert(flattenHydratedBlock(hydratedBlock))
-    //       electionService.getCreatorCommitteeForNextBlock.mockResolvedValue([account.address])
-    //       stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([[0, 1_000_000_000]])
-    //     })
-    //     it('should not re-declare intent if configured for re-declaration', async () => {
-    //       // Arrange
-    //       config.producer.disableIntentRedeclaration = false
-
-    //       // Act
-    //       const result = await blockProducer.next(currentBlock)
-
-    //       // Assert
-    //       expect(result).toBeDefined()
-    //       expect(result).toBeArrayOfSize(2)
-    //       const [block, payloads] = result ?? []
-    //       expect(block).toBeDefined()
-    //       expect(asBlockBoundWitness(block)).toBeDefined()
-    //       expect(payloads).toBeArray()
-    //       const allData = flattenHydratedBlock(assertEx(result))
-    //       const declaration = filterAs(allData, asChainStakeIntent).at(0)
-    //       expect(declaration).toBeUndefined()
-    //     })
-    //     it('should not re-declare intent if not configured for re-declaration', async () => {
-    //       // Arrange
-    //       config.producer.disableIntentRedeclaration = true
-
-    //       // Act
-    //       const result = await blockProducer.next(currentBlock)
-
-    //       // Assert
-    //       expect(result).toBeDefined()
-    //       expect(result).toBeArrayOfSize(2)
-    //       const [block, payloads] = result ?? []
-    //       expect(block).toBeDefined()
-    //       expect(asBlockBoundWitness(block)).toBeDefined()
-    //       expect(payloads).toBeArray()
-    //       const allData = flattenHydratedBlock(assertEx(result))
-    //       const declaration = filterAs(allData, asChainStakeIntent).at(0)
-    //       expect(declaration).toBeUndefined()
-    //     })
-    //   })
-    // })
-  })
-})