@xyo-network/chain-services 1.5.35 → 1.5.36

package/src/BlockProducer/XyoBlockProducer.ts

@@ -1,23 +1,25 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { exists } from '@xylabs/exists'
 import {
   Address, hexToBigInt, toHex,
 } from '@xylabs/hex'
-import { isUndefined } from '@xylabs/typeof'
+import { isDefined } from '@xylabs/typeof'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
 import {
   BlockRewardDiviner, FixedPercentageBlockRewardDiviner, FixedPercentageBlockRewardDivinerConfigSchema,
 } from '@xyo-network/chain-modules'
-import { buildBlock } from '@xyo-network/chain-protocol'
+import { buildNextBlock, createDeclarationIntent } from '@xyo-network/chain-protocol'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { WithStorageMeta } from '@xyo-network/payload-model'
 import {
-  AccountBalanceService,
-  AllowedBlockPayload, asBlockBoundWitness, BlockBoundWitness, BlockNumber, BlockNumberSchema, BlockProducerService, ChainStakeIntent, ChainStakeIntentSchema,
+  AccountBalanceServiceV2,
+  AllowedBlockPayload, asBlockBoundWitness, AttoXL1, BlockBoundWitness, BlockNumber, BlockNumberSchema,
+  BlockProducerService, ChainStakeIntent,
   HydratedBlock, PendingTransactionsService, StakeIntentService, Transfer,
 } from '@xyo-network/xl1-protocol'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
 import { XyoValidatorParams } from '../ChainValidator/index.ts'
 import { generateTransactionFeeTransfers } from './generateTransactionFeeTransfers.ts'
 
@@ -29,29 +31,56 @@ export const DEFAULT_BLOCK_SIZE = 10
 // /**
 //  * The amount of time for which a producer will restake their intent
 //  */
-export const XYO_PRODUCER_RESTAKE_DURATION = 10_000
+export const XYO_PRODUCER_REDECLARATION_DURATION = 10_000
 
 /**
  * The number of blocks within which a producer will redeclare
  * their intent to produce blocks
  */
-export const XYO_PRODUCER_RESTAKE_WINDOW = 500n
+export const XYO_PRODUCER_REDECLARATION_WINDOW = 500
 
 export interface XyoBlockProducerParams extends XyoValidatorParams {
-  balanceService: AccountBalanceService
+  balanceService: AccountBalanceServiceV2
   pendingTransactionsService: PendingTransactionsService
   rejectedTransactionsArchivist: ArchivistInstance
   rewardAddress: Address
 }
 
-@creatableService()
+@creatable()
 export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implements BlockProducerService {
   protected _blockRewardDiviner: BlockRewardDiviner | undefined
 
+  /**
+   * The default block size for a block
+   */
   static get DefaultBlockSize(): number {
     return DEFAULT_BLOCK_SIZE
   }
 
+  /**
+   * The amount of time for which the producer will redeclare
+   * their intent to continue producing blocks
+   */
+  static get RedeclarationDuration(): number {
+    return XYO_PRODUCER_REDECLARATION_DURATION
+  }
+
+  /**
+   * The number of blocks within which the producer will redeclare
+   * their intent to continue producing blocks
+   */
+  static get RedeclarationWindow(): number {
+    return XYO_PRODUCER_REDECLARATION_WINDOW
+  }
+
+  /**
+   * Should the producer should redeclare
+   * their intent to continue producing blocks
+   */
+  static get RedeclareIntent(): boolean {
+    return isDefined(process.env.XYO_PRODUCER_SKIP_REDECLARE_INTENT) ? false : true
+  }
+
   get address() {
     return this.account.address
   }
@@ -68,8 +97,8 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
     return assertEx(this.params.chainArchivist, () => 'chainArchivist is required')
   }
 
-  protected get chainInfo() {
-    return assertEx(this.params.chainInformation, () => 'chainInfo is required')
+  protected get chainId() {
+    return assertEx(this.params.chainId, () => 'chainId is required')
   }
 
   protected get electionService() {
@@ -102,12 +131,12 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
 
   async next(head: WithStorageMeta<BlockBoundWitness>): Promise<HydratedBlock | undefined> {
     // If the block is for another chain, ignore
-    if (head.chain !== this.chainInfo.id) return
+    if (head.chain !== this.chainId) return
     const leaders = await this.electionService.getCreatorCommitteeForNextBlock(head)
     // TODO: Should we propose block if creator committee is empty?
     // TODO: Handle the case where we're not the 1st leader but they're not responding
     // at a higher level than here as that's a network issue
-    if (leaders?.[0] !== this.address) return
+    if (!leaders.includes(this.address)) return
     return this.proposeNextValidBlock(head)
   }
 
@@ -137,9 +166,9 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
    * @returns
    */
   protected async getProducerRedeclaration(head: WithStorageMeta<BlockBoundWitness>): Promise<ChainStakeIntent | undefined> {
-    const redeclareIntent = process.env.XYO_PRODUCER_REDECLARE_INTENT
-    if (isUndefined(redeclareIntent)) return
-    // Decide if we need to redeclare
+    // Decide if we should redeclare intent
+    if (!XyoBlockProducer.RedeclareIntent) return
+    // Decide if we need to redeclare intent
     const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.address, 'producer')
     // TODO: This doesn't handle the case where the producer had declared a range for the future
     // but we're in a range that's not the future
@@ -149,15 +178,8 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
     const [, currentDeclarationEnd] = lastRange
     const currentBlock = head.block
     const timeToProducerExpiration = currentDeclarationEnd - currentBlock
-    if (timeToProducerExpiration > XYO_PRODUCER_RESTAKE_WINDOW) return
-    // Create redeclaration
-    const intent = new PayloadBuilder<ChainStakeIntent>({ schema: ChainStakeIntentSchema }).fields({
-      from: this.address,
-      intent: 'producer',
-      nbf: currentBlock,
-      exp: currentBlock + XYO_PRODUCER_RESTAKE_DURATION,
-    }).build()
-    return intent
+    if (timeToProducerExpiration > XyoBlockProducer.RedeclarationWindow) return
+    return createDeclarationIntent(this.address, 'producer', currentBlock, currentBlock + XyoBlockProducer.RedeclarationDuration)
   }
 
   protected async proposeNextValidBlock(head: WithStorageMeta<BlockBoundWitness>, validateBalances = false): Promise<HydratedBlock | undefined> {
@@ -183,12 +205,13 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
       const transactionTransfers = await generateTransactionFeeTransfers(this.address, nextBlockTransactions)
 
       const fundedTransfers: Transfer[] = []
-      const fundedNextBlockTransactions = nextBlockTransactions.map((tx) => {
+      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'), 0n)
         if (validateBalances) {
-          if (hexToBigInt(this.balanceService.getBalance(transfer.from)) >= totalTransferCost) {
+          const balance = (await this.balanceService.balances(head._hash, [transfer.from]))[transfer.from] ?? AttoXL1(0n)
+          if (balance >= totalTransferCost) {
             fundedTransfers.push(transfer)
             return tx
           }
@@ -196,13 +219,13 @@ export class XyoBlockProducer extends BaseService<XyoBlockProducerParams> implem
           fundedTransfers.push(transfer)
           return tx
         }
-      }).filter(exists)
+      }))).filter(exists)
       blockPayloads.push(...fundedTransfers)
 
       // Build the block
-      const block = await buildBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account])
+      const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [this.account])
       this.logger?.warn(`buildBlock: ${block[0].block} with ${block[1].length} payloads`)
-      const errors = await this.validateHydratedBlockState(block, this.chainInfo.id, { accountBalance: this.balanceService })
+      const errors = await this.validateHydratedBlockState(block, this.chainId, { accountBalance: this.balanceService })
       if (errors.length > 0) {
         this.logger?.warn(`Validation of produced block failed: ${errors.at(0)?.message}`)
         const rejectedTransactions = block[1]

package/src/BlockReward/EvmBlockRewardService.ts

@@ -1,19 +1,19 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { toEthAddress } from '@xyo-network/chain-ethereum'
 import { XyoChainRewards__factory as XyoChainRewardsFactory } from '@xyo-network/typechain'
-import {
-  BaseAccountableServiceParams, BlockRewardService, ChainService,
-} from '@xyo-network/xl1-protocol'
+import { BlockRewardService, ChainService } from '@xyo-network/xl1-protocol'
 import { Provider } from 'ethers/providers'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseAccountableServiceParams } from '../Params.ts'
 
 export interface EvmBlockRewardServiceParams extends BaseAccountableServiceParams {
   chainService?: ChainService
   provider?: Provider
 }
 
-@creatableService<EvmBlockRewardService>()
+@creatable()
 export class EvmBlockRewardService extends BaseService<EvmBlockRewardServiceParams> implements BlockRewardService {
   protected _contractAddress: string | undefined
 

package/src/BlockReward/XyoBlockRewardService.ts

@@ -1,10 +1,12 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { toFixedPoint } from '@xylabs/decimal-precision'
 import { Promisable } from '@xylabs/promise'
 import { rewardFromBlockNumber } from '@xyo-network/chain-protocol'
-import { BaseServiceParams, BlockRewardService } from '@xyo-network/xl1-protocol'
+import { BlockRewardService } from '@xyo-network/xl1-protocol'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../Params.ts'
 
 export interface XyoBlockRewardServiceParams extends BaseServiceParams {
   creatorReward?: bigint
@@ -15,7 +17,7 @@ export interface XyoBlockRewardServiceParams extends BaseServiceParams {
   stepSize?: bigint
 }
 
-@creatableService()
+@creatable()
 export class XyoBlockRewardService extends BaseService<XyoBlockRewardServiceParams> implements BlockRewardService {
   protected readonly rewardFromBlockNumber = rewardFromBlockNumber(18)
 

package/src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts

@@ -1,12 +1,12 @@
 import { assertEx } from '@xylabs/assert'
+import type { Address } from '@xylabs/hex'
 import { isDefined, isNull } from '@xylabs/typeof'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type {
-  BlockBoundWitness, ChainIdentification,
+  BlockBoundWitness,
   ChainIteratorEventData,
   EventingChainBlockNumberIterator,
-  XyoChainIteratorParams,
 } from '@xyo-network/xl1-protocol'
 import {
   asBlockBoundWitness,
@@ -15,16 +15,18 @@ import {
 import { LRUCache } from 'lru-cache'
 
 import { BaseService } from '../BaseService.ts'
+import type { XyoChainIteratorParams } from './model/Params.ts'
 
 export class ChainBlockNumberIterationService extends BaseService<XyoChainIteratorParams, ChainIteratorEventData> implements EventingChainBlockNumberIterator {
   protected _blocksByBlockNumber = new LRUCache<number, BlockBoundWitness>({ max: 10_000 })
 
   get chainArchivist(): ArchivistInstance { return assertEx(this.params.chainArchivist) }
 
-  get chainIdentification(): ChainIdentification { return { id: assertEx(this.params.head?.chain) } }
+  get chainId(): Address { return assertEx(this.params.head?.chain) }
 
   async get(block: number): Promise<BlockBoundWitness> {
     const head = await this.head()
+    // if(isUndefined(head)) return undefined
     // Bail early if the block requested is newer than the current head
     assertEx(head.block >= block, () => `Block requested is newer than the current head [${block}]`)
     const cached = this._blocksByBlockNumber.get(block)

package/src/ChainBlockNumberIteration/model/Params.ts

@@ -0,0 +1,9 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
+
+import type { BaseServiceParams } from '../../Params.ts'
+
+export interface XyoChainIteratorParams extends BaseServiceParams {
+  chainArchivist: ArchivistInstance
+  head: BlockBoundWitness
+}

package/src/ChainBlockNumberIteration/model/index.ts

@@ -1 +1,2 @@
 export * from './BlockNumberIteration.ts'
+export * from './Params.ts'

package/src/ChainIndexService.ts

@@ -1,13 +1,13 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { Hash, Hex } from '@xylabs/hex'
 import { Promisable } from '@xylabs/promise'
 import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  BaseServiceParams, HydratedBlock, Service,
-} from '@xyo-network/xl1-protocol'
+import { HydratedBlock, Service } from '@xyo-network/xl1-protocol'
 
-import { BaseService, creatableService } from './BaseService.ts'
+import { BaseService } from './BaseService.ts'
+import { BaseServiceParams } from './Params.ts'
 
 export interface ChainIndexServiceParams extends BaseServiceParams {
   archivist?: ArchivistInstance
@@ -18,7 +18,7 @@ export interface ChainIndexService extends Service {
   updateHead(head: Hash | null): Promisable<void>
 }
 
-@creatableService()
+@creatable()
 export class XyoChainIndexService extends BaseService<ChainIndexServiceParams> implements ChainIndexService {
   private _head: Hash | null = null
   private _internalArchivist: ArchivistInstance | undefined

package/src/ChainValidator/XyoValidator.ts

@@ -1,33 +1,34 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
+import { Address } from '@xylabs/hex'
 import { Promisable } from '@xylabs/promise'
 import { AccountInstance } from '@xyo-network/account-model'
 import { ArchivistInstance, ReadArchivist } from '@xyo-network/archivist-model'
 import {
-  BaseServiceParams,
   BlockBoundWitness,
   BlockRewardService,
-  ChainInformation,
   ElectionService,
-  HydratedBlockStateValidationFunction,
+  HydratedBlockStateValidationFunctionV2,
   HydratedTransaction,
   StakeIntentService,
 } from '@xyo-network/xl1-protocol'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../Params.ts'
 import { Validator } from './model/index.ts'
 
 export interface XyoValidatorParams extends BaseServiceParams {
   account: AccountInstance
   chainArchivist: ReadArchivist
-  chainInformation: ChainInformation
+  chainId: Address
   electionService: ElectionService
   pendingBundledTransactionsArchivist: ArchivistInstance
   rewardService: BlockRewardService
   stakeIntentService: StakeIntentService
-  validateHydratedBlockState: HydratedBlockStateValidationFunction
+  validateHydratedBlockState: HydratedBlockStateValidationFunctionV2
 }
 
-@creatableService()
+@creatable()
 export class XyoValidator<TParams extends XyoValidatorParams = XyoValidatorParams> extends BaseService<TParams> implements Validator {
   get address() {
     return this.account.address
@@ -42,7 +43,7 @@ export class XyoValidator<TParams extends XyoValidatorParams = XyoValidatorParam
   }
 
   protected get chainInfo() {
-    return assertEx(this.params.chainInformation, () => 'chainInfo is required')
+    return assertEx(this.params.chainId, () => 'chainInfo is required')
   }
 
   protected get electionService() {

package/src/Election/XyoElectionService.ts

@@ -1,13 +1,15 @@
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { Address, Hash } from '@xylabs/hex'
 import { hexToLast4BytesInt, shuffleWithSeed } from '@xyo-network/chain-utils'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type {
-  BaseServiceParams, ChainBlockNumberIterator, ChainStakeViewer, StakeIntentService,
+  ChainBlockNumberIterator, ChainStakeViewer, StakeIntentService,
 } from '@xyo-network/xl1-protocol'
 import { BlockBoundWitness, ElectionService } from '@xyo-network/xl1-protocol'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../Params.ts'
 
 export interface XyoElectionServicesParams extends BaseServiceParams {
   chainIterator?: ChainBlockNumberIterator
@@ -15,12 +17,8 @@ export interface XyoElectionServicesParams extends BaseServiceParams {
   stakeIntentService?: StakeIntentService
 }
 
-@creatableService()
+@creatable()
 export class XyoElectionService extends BaseService<XyoElectionServicesParams> implements ElectionService {
-  constructor(params: XyoElectionServicesParams) {
-    super(params)
-  }
-
   get chainIterator() {
     return assertEx(this.params.chainIterator, () => 'No chain iterator')
   }

package/src/Params.ts

@@ -0,0 +1,9 @@
+import type { CreatableParams } from '@xylabs/creatable'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { OpenTelemetryProviders } from '@xyo-network/xl1-protocol'
+
+export interface BaseServiceParams extends CreatableParams, OpenTelemetryProviders {}
+
+export interface BaseAccountableServiceParams extends BaseServiceParams {
+  account: AccountInstance
+}