@xyo-network/chain-services 1.14.1 → 1.14.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.14.1",
+  "version": "1.14.3",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -48,37 +48,37 @@
     "@xylabs/promise": "~5.0.11",
     "@xylabs/telemetry": "~5.0.11",
     "@xylabs/typeof": "~5.0.11",
-    "@xyo-network/account-model": "~5.1.0",
-    "@xyo-network/archivist-memory": "~5.1.0",
-    "@xyo-network/archivist-model": "~5.1.0",
-    "@xyo-network/boundwitness-model": "~5.1.0",
-    "@xyo-network/boundwitness-validator": "~5.1.0",
-    "@xyo-network/boundwitness-wrapper": "~5.1.0",
-    "@xyo-network/chain-analyze": "~1.14.1",
-    "@xyo-network/chain-modules": "~1.14.1",
-    "@xyo-network/chain-protocol": "~1.14.1",
-    "@xyo-network/chain-utils": "~1.14.1",
-    "@xyo-network/payload-builder": "~5.1.0",
-    "@xyo-network/payload-model": "~5.1.0",
-    "@xyo-network/typechain": "~4.0.3",
-    "@xyo-network/xl1-protocol": "~1.11.0",
-    "@xyo-network/xl1-protocol-sdk": "~1.14.1",
-    "@xyo-network/xl1-validation": "~1.14.1",
-    "@xyo-network/xl1-wrappers": "~1.14.1",
+    "@xyo-network/account-model": "~5.1.2",
+    "@xyo-network/archivist-memory": "~5.1.2",
+    "@xyo-network/archivist-model": "~5.1.2",
+    "@xyo-network/boundwitness-model": "~5.1.2",
+    "@xyo-network/boundwitness-validator": "~5.1.2",
+    "@xyo-network/boundwitness-wrapper": "~5.1.2",
+    "@xyo-network/chain-analyze": "~1.14.3",
+    "@xyo-network/chain-modules": "~1.14.3",
+    "@xyo-network/chain-protocol": "~1.14.3",
+    "@xyo-network/chain-utils": "~1.14.3",
+    "@xyo-network/payload-builder": "~5.1.2",
+    "@xyo-network/payload-model": "~5.1.2",
+    "@xyo-network/typechain": "~4.0.8",
+    "@xyo-network/xl1-protocol": "~1.12.22",
+    "@xyo-network/xl1-protocol-sdk": "~1.14.3",
+    "@xyo-network/xl1-validation": "~1.14.3",
+    "@xyo-network/xl1-wrappers": "~1.14.3",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
-    "lru-cache": "~11.1.0"
+    "lru-cache": "~11.2.1"
   },
   "devDependencies": {
-    "@types/node": "~24.3.0",
+    "@types/node": "~24.3.1",
     "@xylabs/delay": "~5.0.11",
     "@xylabs/ts-scripts-yarn3": "~7.1.7",
     "@xylabs/tsconfig": "~7.1.7",
     "@xylabs/vitest-extended": "~5.0.11",
-    "@xyo-network/account": "~5.1.0",
-    "@xyo-network/account-model": "~5.1.0",
-    "@xyo-network/chain-validation": "~1.14.1",
-    "@xyo-network/wallet": "~5.1.0",
+    "@xyo-network/account": "~5.1.2",
+    "@xyo-network/account-model": "~5.1.2",
+    "@xyo-network/chain-validation": "~1.14.3",
+    "@xyo-network/wallet": "~5.1.2",
     "eslint": "^9.34.0",
     "tslib": "~2.8.1",
     "typescript": "~5.9.2",

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,5 +1,6 @@
 import { creatable } from '@xylabs/creatable'
 import { Address, Hash } from '@xylabs/hex'
+import { spanRootAsync } from '@xylabs/telemetry'
 import { ReadArchivist } from '@xyo-network/archivist-model'
 import {
   AccountBalanceServiceV2,
@@ -21,14 +22,16 @@ export interface BaseAccountBalanceServiceParams extends BaseServiceParams {
 @creatable()
 export class BaseAccountBalanceService extends BaseService<BaseAccountBalanceServiceParams> implements AccountBalanceServiceV2 {
   async balances(head: Hash, address: Address[]): Promise<Partial<Record<Address, AttoXL1>>> {
-    const summary = await balanceSummary({
-      chainArchivist: this.params.chainArchivist, summaryRepository: this.params.summaryRepository, head,
+    return await spanRootAsync('balances', async () => {
+      const summary = await balanceSummary({
+        chainArchivist: this.params.chainArchivist, summaryRepository: this.params.summaryRepository, head,
+      })
+      const result: Record<Address, AttoXL1> = {}
+      for (const addr of address) {
+        const summaryBalance = summary[addr] ?? 0n
+        result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
+      }
+      return result
     })
-    const result: Record<Address, AttoXL1> = {}
-    for (const addr of address) {
-      const summaryBalance = summary[addr] ?? 0n
-      result[addr] = AttoXL1(summaryBalance < 0n ? 0n : summaryBalance)
-    }
-    return result
   }
 }

package/src/BaseService.ts

@@ -1,8 +1,9 @@
 import { AbstractCreatable, creatable } from '@xylabs/creatable'
 import type { EventData } from '@xylabs/events'
+import { Hash } from '@xylabs/hex'
 import type { Promisable } from '@xylabs/promise'
-import { span, spanAsync } from '@xylabs/telemetry'
-import type { Service } from '@xyo-network/xl1-protocol'
+import { spanRoot, spanRootAsync } from '@xylabs/telemetry'
+import type { ServiceInterface } from '@xyo-network/xl1-protocol'
 import { Mutex } from 'async-mutex'
 
 import type { BaseAccountableServiceParams, BaseServiceParams } from './model/index.ts'
@@ -13,7 +14,7 @@ declare global {
 
 @creatable()
 export class BaseService<TParams extends BaseServiceParams = BaseServiceParams, TEventData extends EventData = EventData>
-  extends AbstractCreatable<TParams, TEventData> {
+  extends AbstractCreatable<TParams, TEventData> implements ServiceInterface {
   private static singletonInitMutex = new Mutex()
 
   static get singletons() {
@@ -32,11 +33,15 @@ export class BaseService<TParams extends BaseServiceParams = BaseServiceParams,
   }
 
   span<T>(name: string, fn: () => T): T {
-    return span(name, fn, this.tracer)
+    return spanRoot(name, fn, this.tracer)
   }
 
   async spanAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
-    return await spanAsync(name, fn, this.tracer)
+    return await spanRootAsync(name, fn, this.tracer)
+  }
+
+  sync(_head: Hash): Promise<void> {
+    throw new Error('Method not implemented.')
   }
 }
 
@@ -46,7 +51,7 @@ export abstract class BaseAccountableService<
   // Base class for services that have an account
 }
 
-export interface CreatableService<T extends BaseService = BaseService> extends Service {
+export interface CreatableService<T extends BaseService = BaseService> extends ServiceInterface {
   new(params: T['params']): T
   create<T extends BaseService>(this: CreatableService<T>, params?: Partial<T['params']>): Promisable<T>
 }

package/src/BlockProducer/BaseBlockProducerService.ts

@@ -15,7 +15,9 @@ import {
   AccountBalanceServiceV2,
   AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumber, BlockNumberSchema,
   BlockProducerService, ChainStakeIntent,
-  HydratedBlock, PendingTransactionsService, StakeIntentService, Transfer,
+  defaultRewardRatio,
+  HydratedBlock, PendingTransactionsService, SignedHydratedTransaction, StakeIntentService,
+  TimePayload, TimeSchema, TimeSyncViewInterface, Transfer,
 } from '@xyo-network/xl1-protocol'
 
 import { BaseService } from '../BaseService.ts'
@@ -43,6 +45,7 @@ export interface BaseBlockProducerServiceParams extends XyoValidatorParams {
   pendingTransactionsService: PendingTransactionsService
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
+  time: TimeSyncViewInterface
 }
 
 @creatable()
@@ -116,6 +119,10 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
     return assertEx(this.params.stakeIntentService, () => 'No StakeIntentService provided')
   }
 
+  protected get time(): TimeSyncViewInterface {
+    return assertEx(this.params.time, () => 'No TimeSyncViewInterface provided')
+  }
+
   protected get validateHydratedBlockState() {
     return assertEx(this.params.validateHydratedBlockState, () => 'validateHydratedBlockState is required')
   }
@@ -139,7 +146,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
         blockRewardService: this.rewardService,
         config: {
           rewardAddress: this.rewardAddress,
-          rewardPercentageRatio: 0.5,
+          rewardPercentageRatio: defaultRewardRatio,
           schema: FixedPercentageBlockRewardDivinerConfigSchema,
         },
       })
@@ -194,32 +201,26 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       if (rewardTransferPayload) blockPayloads.push(rewardTransferPayload)
 
       const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions)
+      const timePayload = await this.generateTimePayload(nextBlock)
 
-      const fundedTransfers: Transfer[] = []
-      const fundedNextBlockTransactions = (await Promise.all(nextBlockTransactions.map(async (tx) => {
-        const transfer: Transfer | undefined = transactionTransfers.find(txTransfer => txTransfer.from === tx[0].from)
-        if (!transfer) return
-        const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? '00' as Hex), 0n)
-        if (validateBalances) {
-          const balance = (await this.balanceService.balances(head._hash, [transfer.from]))[transfer.from] ?? AttoXL1(0n)
-          if (balance >= totalTransferCost) {
-            fundedTransfers.push(transfer)
-            return tx
-          }
-        } else {
-          fundedTransfers.push(transfer)
-          return tx
-        }
-      }))).filter(exists)
-      blockPayloads.push(...fundedTransfers)
+      const [fundedNextBlockTransactions, fundedTransfers] = await this.filterByFunded(head, nextBlockTransactions, transactionTransfers, validateBalances)
+
+      blockPayloads.push(...fundedTransfers, timePayload)
 
       // Build the block
-      this.logger?.info(`buildNextBlock: Building block ${head.block + 1} (${new Date().toISOString()})`)
+      this.logger?.info(`Building block ${head.block + 1}`)
+      const startBuild = Date.now()
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account])
-      this.logger?.info(`buildNextBlock: Built block ${block[0].block} with ${block[1].length} payloads (${new Date().toISOString()})`)
-      this.logger?.info(`validateHydratedBlockState: Validating block ${block[0].block} with ${block[1].length} payloads (${new Date().toISOString()})`)
+
+      this.logger?.info(
+        `Built block ${block[0].block} in ${Date.now() - startBuild}ms with ${block[1].length} payloads`,
+      )
+
+      this.logger?.info(`Validating block ${block[0].block} with ${block[1].length} payloads`)
+      const startValidate = Date.now()
       const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceService })
-      this.logger?.info(`validateHydratedBlockState: Validated block ${block[0].block} with ${block[1].length} payloads (${new Date().toISOString()})`)
+      this.logger?.info(`Validated block ${block[0].block} in ${Date.now() - startValidate}ms with ${block[1].length} payloads`)
+
       if (errors.length > 0) {
         this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)
         const rejectedTransactions = block[1]
@@ -229,4 +230,43 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
       }
     })
   }
+
+  // remove unfunded transactions and block transfers
+  private async filterByFunded(
+    head: WithStorageMeta<BlockBoundWitness>,
+    txs: SignedHydratedTransaction[],
+    transfers: Transfer[],
+    validateBalances = false,
+  ): Promise<[SignedHydratedTransaction[], Transfer[]]> {
+    const start = Date.now()
+    const fundedTransfers: Transfer[] = []
+    const fundedTransactions = (await Promise.all(txs.map(async (tx) => {
+      const transfer: Transfer | undefined = transfers.find(transfer => transfer.from === tx[0].from)
+      if (!transfer) return
+      const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? '00' as Hex), 0n)
+      if (validateBalances) {
+        const balance = (await this.balanceService.balances(head._hash, [transfer.from]))[transfer.from] ?? AttoXL1(0n)
+        if (balance >= totalTransferCost) {
+          fundedTransfers.push(transfer)
+          return tx
+        }
+      } else {
+        fundedTransfers.push(transfer)
+        return tx
+      }
+    }))).filter(exists)
+    this.logger?.info(`Filtered ${txs.length} transactions to ${fundedTransactions.length} funded transactions in ${Date.now() - start}ms`)
+    return [fundedTransactions, fundedTransfers]
+  }
+
+  private async generateTimePayload(nextBlock: number) {
+    const timePayload: TimePayload = {
+      schema: TimeSchema,
+      xl1: nextBlock,
+      // TODO: Change to entire tuple for time in ETH
+      ethereum: (await this.time.currentTime('ethereum'))[1],
+      epoch: Date.now(),
+    }
+    return timePayload
+  }
 }

package/src/BlockProducer/spec/BaseBlockProducerService.spec.ts

@@ -23,6 +23,7 @@ import type {
   HydratedBlock,
   HydratedBlockStateValidationFunctionV2,
   StakeIntentService,
+  TimeSyncViewInterface,
 } from '@xyo-network/xl1-protocol'
 import {
   asBlockBoundWitness,
@@ -60,6 +61,7 @@ describe('XyoBlockProducer', () => {
   let rewardAddress = '1111111111111111111111111111111111111111' as Address
   let rewardService: BlockRewardService
   let stakeIntentService: ReturnType<typeof mock<StakeIntentService>>
+  let time: TimeSyncViewInterface
   let transactionAccount: AccountInstance
   const validPendingTransactions = Math.ceil(BaseBlockProducerService.DefaultBlockSize)
   let config: Config
@@ -93,6 +95,7 @@ describe('XyoBlockProducer', () => {
 
     stakeIntentService = mock<StakeIntentService>()
     stakeIntentService.getDeclaredCandidateRanges.mockResolvedValue([])
+    time = mock<TimeSyncViewInterface>()
     rewardService = await MemoryBlockRewardService.create()
     const balanceService = await accountBalanceServiceFromArchivist(chainArchivist)
     const params: BaseBlockProducerServiceParams = {
@@ -109,6 +112,7 @@ describe('XyoBlockProducer', () => {
       rewardAddress,
       rewardService,
       stakeIntentService,
+      time,
       validateHydratedBlockState,
     }
     blockProducer = await BaseBlockProducerService.create(params)
@@ -194,6 +198,7 @@ describe('XyoBlockProducer', () => {
             rewardAddress,
             rewardService,
             stakeIntentService,
+            time,
             validateHydratedBlockState,
           }
           blockProducer = await BaseBlockProducerService.create(params)

package/src/BlockReward/spec/MemoryBlockRewardService.spec.ts

@@ -0,0 +1,64 @@
+import '@xylabs/vitest-extended'
+
+import { toFixedPoint } from '@xylabs/decimal-precision'
+import {
+  beforeAll, describe, expect, it,
+} from 'vitest'
+
+import { MemoryBlockRewardService } from '../index.ts'
+
+describe('MemoryBlockRewardService', () => {
+  let sut: MemoryBlockRewardService
+  // const genesisReward = toFixedPoint(18_000_000_000n)
+  // const initialReward = toFixedPoint(500n)
+  // const minRewardPerBlock = toFixedPoint(10n)
+  const genesisReward = 18_000_000_000_000_000_000_000_000_000n
+  const initialReward = 500_000_000_000_000_000_000n
+  const minRewardPerBlock = 10_000_000_000_000_000_000n
+  const stepFactorDenominator = 100n
+  const stepFactorNumerator = 95n
+  const stepSize = 1_000_000n
+  beforeAll(async () => {
+    sut = await MemoryBlockRewardService.create({
+      stepFactorNumerator,
+      stepFactorDenominator,
+      stepSize,
+      initialStepReward: initialReward,
+      minRewardPerBlock,
+      creatorReward: genesisReward,
+    })
+  })
+
+  describe('rewards', () => {
+    it('for block 0', async () => {
+      const reward = await sut.getRewardForBlock(0n)
+      expect(reward).toEqual(18_000_000_000_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(18_000_000_000n))
+    })
+    it('for block 1', async () => {
+      const reward = await sut.getRewardForBlock(1n)
+      expect(reward).toEqual(500_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(500n))
+    })
+    it('for block 2', async () => {
+      const reward = await sut.getRewardForBlock(2n)
+      expect(reward).toEqual(500_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(500n))
+    })
+    it('for block 3', async () => {
+      const reward = await sut.getRewardForBlock(3n)
+      expect(reward).toEqual(500_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(500n))
+    })
+    it('for block 4', async () => {
+      const reward = await sut.getRewardForBlock(4n)
+      expect(reward).toEqual(500_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(500n))
+    })
+    it('for block 1000000', async () => {
+      const reward = await sut.getRewardForBlock(1_000_000n)
+      expect(reward).toEqual(475_000_000_000_000_000_000n)
+      expect(reward).toEqual(toFixedPoint(475n))
+    })
+  })
+})

package/src/Bridge/BaseBridgeService.ts

@@ -0,0 +1,35 @@
+import { creatable } from '@xylabs/creatable'
+import { Promisable } from '@xylabs/promise'
+import { ReadArchivist } from '@xyo-network/archivist-model'
+import {
+  BridgeBack,
+  BridgeComplete,
+  BridgeRequest,
+  BridgeService,
+} from '@xyo-network/xl1-protocol'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseBridgeServiceParams extends BaseServiceParams {
+  chainArchivist: ReadArchivist
+}
+
+@creatable()
+export class BaseBridgeService extends BaseService<BaseBridgeServiceParams> implements BridgeService {
+  completedBridgeBack(): Promisable<BridgeBack[]> {
+    throw new Error('Method not implemented.')
+  }
+
+  completedBridgeRequests(): Promisable<[BridgeRequest, BridgeComplete][]> {
+    throw new Error('Method not implemented.')
+  }
+
+  pendingBridgeBack(): Promisable<BridgeBack[]> {
+    throw new Error('Method not implemented.')
+  }
+
+  pendingBridgeRequests(): Promisable<BridgeRequest[]> {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/Bridge/index.ts

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

package/src/StepStake/BaseStepStakeService.ts

@@ -0,0 +1,26 @@
+import { creatable } from '@xylabs/creatable'
+import { Address } from '@xylabs/hex'
+import { Promisable } from '@xylabs/promise'
+import { ReadArchivist } from '@xyo-network/archivist-model'
+import {
+  CompletedStep,
+  StepStakeService,
+} from '@xyo-network/xl1-protocol'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseStepStakeServiceParams extends BaseServiceParams {
+  chainArchivist: ReadArchivist
+}
+
+@creatable()
+export class BaseStepStakeService extends BaseService<BaseStepStakeServiceParams> implements StepStakeService {
+  stepStake(_step: CompletedStep): Promisable<Record<Address, bigint>> {
+    throw new Error('Method not implemented.')
+  }
+
+  stepStakeForAddress(_address: Address, _step: CompletedStep): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+}

package/src/StepStake/index.ts

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

package/src/Time/BaseTimeSyncService.ts

@@ -0,0 +1,79 @@
+import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
+import { ReadArchivist } from '@xyo-network/archivist-model'
+import {
+  asTimePayload,
+  EventingChainBlockNumberIteratorService, TimeDomain, TimeSchema, TimeSyncService,
+} from '@xyo-network/xl1-protocol'
+import { Provider } from 'ethers'
+
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../model/index.ts'
+
+export interface BaseTimeServiceParams extends BaseServiceParams {
+  chainArchivist: ReadArchivist
+  chainIterator: EventingChainBlockNumberIteratorService
+  ethProvider?: Provider
+}
+
+@creatable()
+export class BaseTimeSyncService extends BaseService<BaseTimeServiceParams> implements TimeSyncService {
+  get chainArchivist() {
+    return this.params.chainArchivist
+  }
+
+  get chainIterator() {
+    return this.params.chainIterator
+  }
+
+  get ethProvider() {
+    return this.params.ethProvider
+  }
+
+  async convertTime(fromDomain: TimeDomain, toDomain: TimeDomain, from: number): Promise<number> {
+    switch (fromDomain) {
+      case 'xl1': {
+        const block = assertEx(await this.chainIterator.get(from), () => 'Block not found')
+        const timeSchemaIndex = block.payload_schemas.indexOf(TimeSchema)
+        const hash = timeSchemaIndex === -1 ? undefined : block.payload_hashes[timeSchemaIndex]
+        const [payload] = hash === undefined ? [] : await this.chainArchivist.get([hash])
+        const timePayload = asTimePayload(payload)
+        if (timePayload === undefined) return 0
+        switch (toDomain) {
+          case 'xl1': {
+            return timePayload.xl1 ?? 0
+          }
+          case 'epoch': {
+            return timePayload.epoch ?? 0
+          }
+          case 'ethereum': {
+            return timePayload.ethereum ?? 0
+          }
+          default: {
+            throw new Error(`Unsupported to toDomain: ${toDomain}`)
+          }
+        }
+      }
+      default: {
+        throw new Error(`Unsupported from fromDomain: ${fromDomain}`)
+      }
+    }
+  }
+
+  async currentTime(domain: TimeDomain): Promise<[string, number]> {
+    switch (domain) {
+      case 'xl1': {
+        return ['xl1', (await this.chainIterator.head()).block]
+      }
+      case 'epoch': {
+        return ['epoch', Date.now()]
+      }
+      case 'ethereum': {
+        return ['ethereum', (await this.ethProvider?.getBlockNumber()) ?? 0]
+      }
+      default: {
+        throw new Error(`Unknown time domain: ${domain}`)
+      }
+    }
+  }
+}

package/src/Time/index.ts

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

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './AccountBalance/index.ts'
 export * from './BaseService.ts'
 export * from './BlockProducer/index.ts'
 export * from './BlockReward/index.ts'
+export * from './Bridge/index.ts'
 export * from './ChainBlockNumberIteration/index.ts'
 export * from './ChainService/index.ts'
 export * from './ChainValidator/index.ts'
@@ -9,3 +10,5 @@ export * from './Election/index.ts'
 export * from './model/index.ts'
 export * from './PendingTransactions/index.ts'
 export * from './StakeIntent/index.ts'
+export * from './StepStake/index.ts'
+export * from './Time/index.ts'