@xyo-network/chain-services 1.14.0 → 1.14.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/chain-services",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "XYO Layer One SDK Services",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -54,17 +54,17 @@
     "@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.0",
-    "@xyo-network/chain-modules": "~1.14.0",
-    "@xyo-network/chain-protocol": "~1.14.0",
-    "@xyo-network/chain-utils": "~1.14.0",
+    "@xyo-network/chain-analyze": "~1.14.2",
+    "@xyo-network/chain-modules": "~1.14.2",
+    "@xyo-network/chain-protocol": "~1.14.2",
+    "@xyo-network/chain-utils": "~1.14.2",
     "@xyo-network/payload-builder": "~5.1.0",
     "@xyo-network/payload-model": "~5.1.0",
-    "@xyo-network/typechain": "~4.0.1",
-    "@xyo-network/xl1-protocol": "~1.11.0",
-    "@xyo-network/xl1-protocol-sdk": "~1.14.0",
-    "@xyo-network/xl1-validation": "~1.14.0",
-    "@xyo-network/xl1-wrappers": "~1.14.0",
+    "@xyo-network/typechain": "~4.0.6",
+    "@xyo-network/xl1-protocol": "~1.12.14",
+    "@xyo-network/xl1-protocol-sdk": "~1.14.2",
+    "@xyo-network/xl1-validation": "~1.14.2",
+    "@xyo-network/xl1-wrappers": "~1.14.2",
     "async-mutex": "~0.5.0",
     "ethers": "6.15.0",
     "lru-cache": "~11.1.0"
@@ -77,7 +77,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.0",
+    "@xyo-network/chain-validation": "~1.14.2",
     "@xyo-network/wallet": "~5.1.0",
     "eslint": "^9.34.0",
     "tslib": "~2.8.1",

package/src/AccountBalance/BaseAccountBalanceService.ts

@@ -1,5 +1,6 @@
 import { creatable } from '@xylabs/creatable'
 import { Address, Hash } from '@xylabs/hex'
+import { spanAsync } 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 spanAsync('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 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() {
@@ -38,6 +39,10 @@ export class BaseService<TParams extends BaseServiceParams = BaseServiceParams,
   async spanAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
     return await spanAsync(name, fn, this.tracer)
   }
+
+  sync(_head: Hash): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
 }
 
 export abstract class BaseAccountableService<
@@ -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,8 @@ import {
   AccountBalanceServiceV2,
   AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumber, BlockNumberSchema,
   BlockProducerService, ChainStakeIntent,
-  HydratedBlock, PendingTransactionsService, StakeIntentService, Transfer,
+  defaultRewardRatio,
+  HydratedBlock, PendingTransactionsService, SignedHydratedTransaction, StakeIntentService, TimePayload, TimeSchema, TimeSyncViewInterface, TransactionBoundWitness, Transfer,
 } from '@xyo-network/xl1-protocol'
 
 import { BaseService } from '../BaseService.ts'
@@ -43,6 +44,7 @@ export interface BaseBlockProducerServiceParams extends XyoValidatorParams {
   pendingTransactionsService: PendingTransactionsService
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
+  time: TimeSyncViewInterface
 }
 
 @creatable()
@@ -116,6 +118,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 +145,7 @@ export class BaseBlockProducerService extends BaseService<BaseBlockProducerServi
         blockRewardService: this.rewardService,
         config: {
           rewardAddress: this.rewardAddress,
-          rewardPercentageRatio: 0.5,
+          rewardPercentageRatio: defaultRewardRatio,
           schema: FixedPercentageBlockRewardDivinerConfigSchema,
         },
       })
@@ -194,24 +200,11 @@ 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()})`)
@@ -229,4 +222,40 @@ 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 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)
+    return [fundedTransactions, fundedTransfers]
+  }
+
+  private async generateTimePayload(nextBlock: number) {
+    const timePayload: TimePayload = {
+      schema: TimeSchema,
+      xl1: nextBlock,
+      ethereum: await this.time.currentTime('ethereum'),
+      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/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<number> {
+    switch (domain) {
+      case 'xl1': {
+        return (await this.chainIterator.head()).block
+      }
+      case 'epoch': {
+        return Date.now()
+      }
+      case 'ethereum': {
+        return 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'