@xyo-network/chain-services 1.15.2 → 1.15.4

package/src/NetworkStakeStepReward/BaseNetworkStakeStepRewardService.ts

@@ -2,7 +2,9 @@ import { creatable } from '@xylabs/creatable'
 import { Address } from '@xylabs/hex'
 import { Promisable } from '@xylabs/promise'
 import { ReadArchivist } from '@xyo-network/archivist-model'
-import { EventingChainBlockNumberIteratorService, NetworkStakeStepRewardService } from '@xyo-network/xl1-protocol'
+import {
+  EventingChainBlockNumberIteratorService, NetworkStakeStepRewardService, StepIdentity,
+} from '@xyo-network/xl1-protocol'
 import { Provider } from 'ethers'
 
 import { BaseService } from '../BaseService.ts'
@@ -16,55 +18,63 @@ export interface BaseNetworkStakeStepRewardServiceParams extends BaseServicePara
 
 @creatable()
 export class BaseNetworkStakeStepRewardService extends BaseService<BaseNetworkStakeStepRewardServiceParams> implements NetworkStakeStepRewardService {
-  claimedRewards(_address: Address): Promisable<bigint> {
+  networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepAddressReward(_address: Address, _step: number, _block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardAddressReward(_context: StepIdentity, _address: Address): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewardShares(_step: number, _block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardAddressShare(_context: StepIdentity, _address: Address): Promisable<[bigint, bigint]> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepPoolRewards(_step: number, _block: number): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardClaimedByAddress(_address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressHistory(_address: Address): Promisable<Record<Address, bigint>> {
+  networkStakeStepRewardForPosition(_position: number, _range: [number, number]): Promisable<[bigint, bigint]> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardForStep(_context: StepIdentity): Promisable<bigint> {
+    throw new Error('Method not implemented.')
+  }
+
+  networkStakeStepRewardForStepForPosition(_context: StepIdentity, _position: number): Promisable<[bigint, bigint]> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardAddressShare(_address: Address, _step: number, _block: number): Promisable<[bigint, bigint]> {
+  networkStakeStepRewardPoolRewards(_context: StepIdentity): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardForStep(_step: number): Promisable<bigint> {
+  networkStakeStepRewardPoolShares(_context: StepIdentity): Promisable<Record<Address, bigint>> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPositionWeight(_position: bigint, _step: number): Promisable<number> {
+  networkStakeStepRewardPositionWeight(_context: StepIdentity, _position: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardPotentialPositionLoss(_position: bigint, _step: number): Promisable<bigint> {
+  networkStakeStepRewardPotentialPositionLoss(_context: StepIdentity, _position: number): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardRandomizer(_step: number, _block: number): Promisable<bigint> {
+  networkStakeStepRewardRandomizer(_context: StepIdentity): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardStakerCount(_step: number, _block: number): Promisable<number> {
+  networkStakeStepRewardStakerCount(_context: StepIdentity): Promisable<number> {
     throw new Error('Method not implemented.')
   }
 
-  networkStakeStepRewardWeightForAddress(_address: Address, _step: number): Promisable<bigint> {
+  networkStakeStepRewardUnclaimedByAddress(_address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 
-  unclaimedRewards(_address: Address): Promisable<bigint> {
+  networkStakeStepRewardWeightForAddress(_context: StepIdentity, _address: Address): Promisable<bigint> {
     throw new Error('Method not implemented.')
   }
 }

package/src/PendingTransactions/BasePendingTransactions.ts

@@ -13,7 +13,7 @@ import {
   Payload, PayloadBundle, Sequence, WithStorageMeta,
 } from '@xyo-network/payload-model'
 import {
-  asBlockBoundWitnessWithHashStorageMeta, Chain, isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
+  asBlockBoundWitnessWithHashStorageMeta, ChainId, isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
   SignedHydratedTransactionWithStorageMeta,
 } from '@xyo-network/xl1-protocol'
 import { TransactionJsonSchemaValidator, validateTransaction } from '@xyo-network/xl1-validation'
@@ -26,7 +26,7 @@ import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPaylo
 
 export interface BasePendingTransactionsServiceParams extends BaseServiceParams {
   chainArchivist?: ArchivistInstance
-  chainId?: Chain
+  chainId?: ChainId
   pendingBundledTransactionsArchivist?: ArchivistInstance
   rejectedTransactionsArchivist?: ArchivistInstance
 }

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -25,6 +25,7 @@ import {
   isChainIndexingServiceState,
   StakeIntentService,
 } from '@xyo-network/xl1-protocol'
+import { readPayloadMapFromStore } from '@xyo-network/xl1-protocol-sdk'
 import { Mutex } from 'async-mutex'
 import { LRUCache } from 'lru-cache'
 
@@ -138,7 +139,7 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
         const stake = this._stakeCache.get(candidate)
         if (stake === undefined) {
           // Fetch from chainStakeViewer if not cached
-          const activeStake = await chainStakeViewer.activeByAddressStaked(`${candidate}`)
+          const activeStake = await chainStakeViewer.activeByStaked(candidate)
           if (activeStake > 0n) {
             // Store result in cache
             this._stakeCache.set(candidate, activeStake, { ttl: ACTIVE_STAKE_TTL })
@@ -206,7 +207,8 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
         const currentHead = await this.chainIterator.head()
         if (isUndefined(currentHead)) return
         const currentHeadHash = await PayloadBuilder.hash(currentHead)
-        const result = await analyzeChain(this.chainArchivist, [new ChainStakeIntentAnalyzer('producer')], currentHeadHash, this._lastIndexedBlockHash)
+        const chainMap = readPayloadMapFromStore<WithStorageMeta<Payload>>(this.chainArchivist)
+        const result = await analyzeChain({ chainMap }, [new ChainStakeIntentAnalyzer('producer')], currentHeadHash, this._lastIndexedBlockHash)
         const signedDeclarations = filterAs(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent)
         if (currentHead.block === undefined) return
         const currentHeadBlockNum = currentHead.block

package/src/StepStake/BaseStepStakeService.ts

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