@xyo-network/chain-services 1.5.35 → 1.5.36

package/src/PendingTransactions/PendingTransactions.ts

@@ -1,37 +1,39 @@
 import { ValueType } from '@opentelemetry/api'
-import { filterAsync } from '@xylabs/array'
+import { filterAs, filterAsync } from '@xylabs/array'
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import { exists } from '@xylabs/exists'
 import { forget } from '@xylabs/forget'
-import { Hash } from '@xylabs/hex'
+import { Address, Hash } from '@xylabs/hex'
+import { isDefined, isUndefined } from '@xylabs/typeof'
 import { MemoryArchivist } from '@xyo-network/archivist-memory'
 import { ArchivistInstance } from '@xyo-network/archivist-model'
+import { findMostRecentBlock } from '@xyo-network/chain-protocol'
 import { globalAttributes } from '@xyo-network/chain-telemetry'
 import { validateTransaction } from '@xyo-network/chain-validation'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
 import {
   Payload, PayloadBundle, Sequence, WithStorageMeta,
 } from '@xyo-network/payload-model'
 import {
-  asTransactionBoundWitnessWithStorageMeta, BaseServiceParams, ChainIdentification, HydratedTransaction,
-  isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
+  asBlockBoundWitnessWithHashStorageMeta, HydratedTransaction, isTransactionBoundWitnessWithStorageMeta, PendingTransactionsService,
 } from '@xyo-network/xl1-protocol'
 import { Mutex } from 'async-mutex'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../Params.ts'
 import { bundledPayloadToHydratedTransaction } from './bundledPayloadToHydratedTransaction.ts'
 import { hydratedTransactionToPayloadBundle } from './hydratedTransactionToPayloadBundle.ts'
 
 export interface XyoPendingTransactionsServiceParams extends BaseServiceParams {
   chainArchivist?: ArchivistInstance
-  chainIdentification?: ChainIdentification
+  chainId?: Address
   pendingBundledTransactionsArchivist?: ArchivistInstance
   rejectedTransactionsArchivist?: ArchivistInstance
 }
 
 globalAttributes.setAttribute('XyoPendingTransactionsService:status', 'unknown')
 
-@creatableService()
+@creatable()
 export class XyoPendingTransactionsService extends BaseService<XyoPendingTransactionsServiceParams> implements PendingTransactionsService {
   private static readonly MutexPriority = {
     /**
@@ -43,13 +45,9 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
      */
     ReadTransactions: 3,
     /**
-     * Priority for removing rejected transactions
+     * Priority for removing finalized/expired/rejected transactions
      */
-    RemoveRejectedTransactions: 2,
-    /**
-     * Priority for removing finalized transactions
-     */
-    RemoveFinalizedTransactions: 1,
+    PurgeTransactions: 1,
   } as const
 
   /**
@@ -86,8 +84,8 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
     return assertEx(this.params.chainArchivist, () => 'No completed blocks with data archivist')
   }
 
-  private get chainIdentification() {
-    return assertEx(this.params.chainIdentification, () => 'No chain id')
+  private get chainId() {
+    return assertEx(this.params.chainId, () => 'No chain id')
   }
 
   private get pendingBundledTransactionsArchivist() {
@@ -112,18 +110,20 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
     this._curatedPendingBundledTransactionsArchivist = await MemoryArchivist.create({ account: 'random' })
 
     // On new pending transactions, insert them into the curated archivist
-    this.pendingBundledTransactionsArchivist.on('inserted', async ({ payloads }) => {
-      await this.insertNewTransactions(payloads as WithStorageMeta<PayloadBundle>[])
+    this.pendingBundledTransactionsArchivist.on('inserted', ({ payloads }) => {
+      forget(this.insertNewTransactions(payloads as WithStorageMeta<PayloadBundle>[]))
     })
 
     // On new finalized blocks, remove the transactions from the curated archivist
     this.chainArchivist.on('inserted', ({ payloads }) => {
       this.markAnyIncludedTransactionsForRemoval(payloads)
+      forget(this.cleanupWorker())
     })
 
     // On new rejected transactions, remove the transactions from the curated archivist
     this.rejectedTransactionsArchivist.on('inserted', ({ payloads }) => {
       this.markAnyIncludedTransactionsForRemoval(payloads)
+      forget(this.cleanupWorker())
     })
 
     const pendingTransactionsCounter = this.meter?.createObservableUpDownCounter(
@@ -142,37 +142,32 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
     return await this.spanAsync('getPendingTransactions', async () => {
     // Acquires an exclusive mutex to ensure no race conditions while accessing pending transactions.
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        const foundPendingTransactions: HydratedTransaction[] = []
-        const foundPendingTransactionsToDeleteHashes: Hash[] = []
+        // Find the supplied head
+        let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashStorageMeta)
+        if (isUndefined(lastHead)) return []
+
+        await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)
 
+        const foundPendingTransactions: HydratedTransaction[] = []
         let cursor: Sequence | undefined
 
         // Continue fetching until the desired number of transactions is reached.
         while (foundPendingTransactions.length < limit) {
         // Fetch the next batch of payloads
-          const payloads = await this.pendingBundledTransactionsLocalArchivist.next({
+          const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
             limit: 100,
             order: 'asc',
             cursor,
           }) as WithStorageMeta<PayloadBundle>[]
 
           // Exit if no more payloads are available.
-          if (payloads.length === 0) break
+          if (pendingBundledTransactions.length === 0) break
 
           // Update the cursor for the next iteration to fetch subsequent payloads.
-          cursor = payloads.at(-1)?._sequence
-
-          // Filter out bundles that are marked as removable.
-          const deletedTransactionBundles = payloads.filter(tx =>
-            this._removablePendingTransactionHashes.has(tx.root))
-
-          // Queue the hashes of deletable transactions for deletion and cleanup.
-          foundPendingTransactionsToDeleteHashes.push(
-            ...deletedTransactionBundles.map(tx => tx._hash).filter(exists),
-          )
+          cursor = pendingBundledTransactions.at(-1)?._sequence
 
           // Keep only those payloads that are not marked for deletion.
-          const undeletedTransactionBundles = payloads.filter(tx =>
+          const undeletedTransactionBundles = pendingBundledTransactions.filter(tx =>
             !this._removablePendingTransactionHashes.has(tx.root))
 
           // Convert each undeleted payload bundle into a hydrated transaction.
@@ -180,23 +175,12 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
             undeletedTransactionBundles.map(p => bundledPayloadToHydratedTransaction(p)),
           )).filter(exists)
 
-          // Add the valid hydrated transactions to the result set.
-          foundPendingTransactions.push(...transactions)
-        }
-
-        // Actually delete the marked payload bundles from the archivist
-        await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes)
+          // Filter transactions to only include those that are active for the next
+          // potential block based on the last supplied head.
+          const activeTransactions = transactions.filter(isTransactionActive(lastHead.block + 1))
 
-        // Remove deleted hashes from the "pending delete" set now that they are deleted
-        for (const hash of foundPendingTransactionsToDeleteHashes) {
-          this._removablePendingTransactionHashes.delete(hash)
-        }
-
-        if (foundPendingTransactionsToDeleteHashes.length > 0) {
-          this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${foundPendingTransactionsToDeleteHashes.length} deletable transactions`)
-          for (const hash of foundPendingTransactionsToDeleteHashes) {
-            this.logger?.log(hash)
-          }
+          // Add the valid hydrated transactions to the result set.
+          foundPendingTransactions.push(...activeTransactions)
         }
 
         if (foundPendingTransactions.length > 0) {
@@ -211,6 +195,13 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
     })
   }
 
+  private async cleanupWorker() {
+    return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
+      const lastHead = await findMostRecentBlock(this.chainArchivist)
+      if (isDefined(lastHead)) await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash)
+    }, XyoPendingTransactionsService.MutexPriority.PurgeTransactions)
+  }
+
   private async countPendingTransactions() {
     if (this._countPendingTransactionsMutex.isLocked()) return
     await this._countPendingTransactionsMutex.runExclusive(async () => {
@@ -241,7 +232,7 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
         }))).filter(exists)
         // Filter to only valid transactions
         const validTransactions = await filterAsync(hydratedUnprocessedTransactions, async (tx) => {
-          const errors = await validateTransaction(tx, this.chainIdentification.id)
+          const errors = await validateTransaction(tx, this.chainId)
           if (errors.length > 0) {
             this.logger?.warn('validateTransaction', errors)
           }
@@ -268,19 +259,92 @@ export class XyoPendingTransactionsService extends BaseService<XyoPendingTransac
     }
   }
 
-  private async removeBundledTransactions(
-    bundledPayloads: WithStorageMeta<PayloadBundle>[],
-    priority: keyof typeof XyoPendingTransactionsService.MutexPriority,
-  ) {
-    return await this.spanAsync(priority, async () => {
-      return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        const bundledTransactions = (await Promise.all(bundledPayloads.map(async (payload) => {
-          const withStorageMeta = await PayloadBuilder.addStorageMeta(payload.payloads)
-          const tx = asTransactionBoundWitnessWithStorageMeta(withStorageMeta.find(p => p._hash === payload.root))
-          return tx !== undefined && payload._hash !== undefined ? tx : undefined
-        }))).filter(exists)
-        await this.pendingBundledTransactionsLocalArchivist.delete(bundledTransactions.map(btx => btx._hash))
-      }, XyoPendingTransactionsService.MutexPriority[priority])
+  private async pruneCuratedPendingTransactionsArchivist(head: Hash) {
+    return await this.spanAsync('pruneCuratedPendingTransactionsArchivist', async () => {
+      const foundPendingTransactionsToDeleteHashes: Hash[] = []
+
+      let cursor: Sequence | undefined
+      let [lastHead] = filterAs(await this.chainArchivist.get([head]), asBlockBoundWitnessWithHashStorageMeta)
+
+      // Continue fetching until the desired number of transactions is reached.
+      while (isDefined(lastHead)) {
+        // Fetch the next batch of payloads
+        const pendingBundledTransactions = await this.pendingBundledTransactionsLocalArchivist.next({
+          limit: 100,
+          order: 'asc',
+          cursor,
+        }) as WithStorageMeta<PayloadBundle>[]
+
+        // Exit if no more payloads are available.
+        if (pendingBundledTransactions.length === 0) {
+          break
+        }
+
+        // Update the cursor for the next iteration to fetch subsequent payloads.
+        cursor = pendingBundledTransactions.at(-1)?._sequence
+
+        // Filter out bundles that are marked as removable.
+        const deletedTransactionBundles = pendingBundledTransactions.filter(tx =>
+          this._removablePendingTransactionHashes.has(tx.root))
+
+        // Queue the hashes of deletable transactions for deletion and cleanup.
+        foundPendingTransactionsToDeleteHashes.push(
+          ...deletedTransactionBundles.map(tx => tx._hash).filter(exists),
+        )
+
+        // Keep only those payloads that are not marked for deletion.
+        const undeletedTransactionBundles = pendingBundledTransactions.filter(tx =>
+          !this._removablePendingTransactionHashes.has(tx.root))
+
+        // Convert each undeleted payload bundle into a hydrated transaction.
+        const transactions = (await Promise.all(
+          undeletedTransactionBundles.map(p => bundledPayloadToHydratedTransaction(p)),
+        )).filter(exists)
+
+        // Find expired transactions based on the last supplied head
+        const expiredTransactions = transactions.filter(isTransactionExpired(lastHead.block + 1))
+        // Find the corresponding bundle hashes for the expired transactions
+        const expiredBundleHashes = expiredTransactions
+          .map(expiredHydratedTx =>
+          // Find the corresponding payload bundle hash for the expired transaction
+            pendingBundledTransactions.find(bundledTx => bundledTx.root === expiredHydratedTx[0]._hash)?._hash)
+          .filter(exists)
+          // Mark all expired bundled transactions for deletion.
+        foundPendingTransactionsToDeleteHashes.push(...expiredBundleHashes)
+      }
+
+      // Actually delete the marked payload bundles from the archivist
+      const deletedHashes = await this.pendingBundledTransactionsLocalArchivist.delete(foundPendingTransactionsToDeleteHashes)
+
+      // Remove all deleted hashes from the "pending delete" set now that they are deleted
+      for (const payload of deletedHashes) {
+        this._removablePendingTransactionHashes.delete(payload._hash)
+      }
+
+      if (deletedHashes.length > 0) {
+        this.logger?.log(`foundPendingTransactionsToDeleteHashes: Found ${deletedHashes.length} deletable transactions`)
+        for (const payload of deletedHashes) {
+          this.logger?.log(payload._hash)
+        }
+      }
     })
   }
 }
+
+/**
+ * Checks if a transaction is expired for a given block.
+ * @param block The block number to check against the transaction's validity period.
+ * @returns True if the transaction is expired for the given block, false otherwise.
+ */
+const isTransactionExpired = (block: number) =>
+  ([txBw]: HydratedTransaction): boolean =>
+    txBw.exp < block
+
+/**
+ * Checks if a transaction is active for a given block.
+ * @param block The block number to check against the transaction's validity period.
+ * @returns True if the transaction is active for the given block, false otherwise.
+ */
+const isTransactionActive = (block: number) =>
+  ([txBw]: HydratedTransaction): boolean =>
+    txBw.nbf <= block && txBw.exp >= block

package/src/StakeIntent/XyoStakeIntentService.ts

@@ -1,8 +1,10 @@
 import { filterAs } from '@xylabs/array'
 import { assertEx } from '@xylabs/assert'
+import { creatable } from '@xylabs/creatable'
 import {
   Address, asAddress, Hash,
 } from '@xylabs/hex'
+import { isDefined, isUndefined } from '@xylabs/typeof'
 import { ArchivistInstance, ArchivistNextOptions } from '@xyo-network/archivist-model'
 import {
   analyzeChain, ChainStakeIntentAnalyzer,
@@ -15,9 +17,7 @@ import {
 } from '@xyo-network/chain-utils'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import type {
-  BaseServiceParams, EventingChainBlockNumberIterator, Intent,
-} from '@xyo-network/xl1-protocol'
+import type { EventingChainBlockNumberIterator, Intent } from '@xyo-network/xl1-protocol'
 import {
   asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta,
   asChainIndexingServiceStateWithStorageMeta,
@@ -28,7 +28,8 @@ import {
 import { Mutex } from 'async-mutex'
 import { LRUCache } from 'lru-cache'
 
-import { BaseService, creatableService } from '../BaseService.ts'
+import { BaseService } from '../BaseService.ts'
+import { BaseServiceParams } from '../Params.ts'
 
 export interface XyoStakeIntentServiceParams extends BaseServiceParams {
   chainArchivist?: ArchivistInstance
@@ -46,7 +47,7 @@ const ACTIVE_STAKE_TTL = 1000 * 60 * 60 * 2 // 2 hours in milliseconds
 const NO_ACTIVE_STAKE_TTL = 1000 * 2 // 2 seconds in milliseconds
 const STAKE_CACHE_MAX_ENTRIES = 10_000
 
-@creatableService()
+@creatable()
 export class XyoStakeIntentService extends BaseService<XyoStakeIntentServiceParams> implements StakeIntentService {
   // TODO: Use hash instead of block number to handle chain reorgs
   protected _lastIndexedBlockHash: Hash | undefined = undefined
@@ -61,13 +62,6 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
   protected _stakeCache = new LRUCache<Address, bigint>({ max: STAKE_CACHE_MAX_ENTRIES })
   protected _updateMutex = new Mutex()
 
-  constructor(params: XyoStakeIntentServiceParams) {
-    super(params)
-    this.chainIterator.on('headUpdated', async () => {
-      await this.updateIndex()
-    })
-  }
-
   protected get chainArchivist() {
     return assertEx(this.params.chainArchivist, () => 'chainArchivist not set')
   }
@@ -84,12 +78,14 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
     return assertEx(this.params.stakeIntentStateArchivist, () => 'stakeIntentStateArchivist not set')
   }
 
-  override async createHandler(): Promise<void> {
+  override async createHandler() {
+    this.chainIterator.on('headUpdated', async () => {
+      await this.updateIndex()
+    })
     const head = await this.chainIterator.head()
+    if (isUndefined(head)) return
     const headHash = await PayloadBuilder.hash(head)
-    if (head?.block === undefined) return
     await this.recoverState(headHash)
-    await this.updateIndex(true)
   }
 
   async getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>> {
@@ -104,20 +100,36 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
       assertEx(intent === 'producer', () => `Error: Support not yet added for intent ${intent}`)
       const results = this._producers.findAllContaining(block)
       const candidates = [...results]
-      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer)
+      const requiredMinimumStake = this.getRequiredMinimumStakeForIntent(intent)
+      const validCandidates = await this.filterToValidStake(candidates, this.chainStakeViewer, requiredMinimumStake)
       return validCandidates
     })
   }
 
+  getRequiredMinimumStakeForIntent(intent: Intent): bigint {
+    switch (intent) {
+      case 'producer': {
+        const requiredMinimumStake = isDefined(process.env.XYO_PRODUCER_MIN_STAKE)
+          ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE)
+          : 1n
+        return requiredMinimumStake
+      }
+    }
+  }
+
   async isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean> {
     const candidates = await this.getDeclaredCandidatesForBlock(block, intent)
     return candidates.includes(address)
   }
 
+  override async startHandler(): Promise<void> {
+    await this.updateIndex(true)
+  }
+
   private async filterToValidStake(
     candidates: Address[],
     chainStakeViewer: ChainStakeViewer,
-    requiredMinimumStake: bigint = 1n,
+    requiredMinimumStake: bigint,
   ): Promise<Address[]> {
     type CandidateStake = { candidate: Address; stake: bigint }
 
@@ -194,6 +206,7 @@ export class XyoStakeIntentService extends BaseService<XyoStakeIntentServicePara
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync('updateIndex', async () => {
         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 signedDeclarations = filterAs(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent)

package/src/Staker/Evm/Evm.ts

@@ -4,36 +4,37 @@ import { toAddress } from '@xylabs/hex'
 import { toEthAddress } from '@xyo-network/chain-ethereum'
 import type { StakedXyoChain } from '@xyo-network/typechain'
 import { StakedXyoChain__factory as StakedXyoChainFactory } from '@xyo-network/typechain'
-import type { BaseServiceParams, ChainService } from '@xyo-network/xl1-protocol'
+import type { ChainService } from '@xyo-network/xl1-protocol'
 import { getAddress } from 'ethers/address'
 import type { ContractRunner } from 'ethers/providers'
 
 import { BaseService } from '../../BaseService.ts'
+import type { BaseServiceParams } from '../../Params.ts'
 
-export type EvmChainServiceParams = BaseServiceParams<{
+export interface EvmChainServiceParams extends BaseServiceParams {
   contract: StakedXyoChain
   id: Address
   runner: ContractRunner
-}>
+}
 
 /**
  * A class that represents a chain stake as backed by an EVM smart contract
  */
 export class EvmChainService extends BaseService<EvmChainServiceParams> implements ChainService {
+  get chainId(): Address {
+    return assertEx(this.params.id)
+  }
+
   get contract() {
     if (this.params.contract === undefined) {
       this.params.contract = StakedXyoChainFactory.connect(
-        toEthAddress(this.id),
+        toEthAddress(this.chainId),
         this.params.runner,
       ) as StakedXyoChain
     }
     return assertEx(this.params.contract)
   }
 
-  get id(): Address {
-    return assertEx(this.params.id)
-  }
-
   get runner(): ContractRunner {
     return assertEx(this.params.runner)
   }
@@ -56,10 +57,6 @@ export class EvmChainService extends BaseService<EvmChainServiceParams> implemen
     return true
   }
 
-  async chainId(): Promise<Address> {
-    return toAddress(await this.contract.chainId())
-  }
-
   async forkedAtBlockNumber(): Promise<bigint> {
     return await this.contract.forkedAtBlockNumber()
   }

package/src/Staker/Memory/Memory.ts

@@ -0,0 +1,90 @@
+import type { Address } from '@xylabs/hex'
+import { ZERO_ADDRESS } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import type { ChainService } from '@xyo-network/xl1-protocol'
+
+import { BaseService } from '../../BaseService.ts'
+import type { BaseServiceParams } from '../../Params.ts'
+
+export interface MemoryChainServiceParams extends BaseServiceParams {}
+
+/**
+ * A class that represents a chain stake as backed in memory
+ */
+export class MemoryChainService extends BaseService<MemoryChainServiceParams> implements ChainService {
+  protected _simulatedStake: bigint = 1n
+
+  get chainId(): Address {
+    return ZERO_ADDRESS
+  }
+
+  async active(): Promise<bigint> {
+    return await Promise.resolve(this._simulatedStake)
+  }
+
+  async activeByAddressStaked(_address: string): Promise<bigint> {
+    return await Promise.resolve(this._simulatedStake)
+  }
+
+  async activeByStaker(_address: string): Promise<bigint> {
+    return await Promise.resolve(this._simulatedStake)
+  }
+
+  async addStake(_staked: string, _amount: bigint): Promise<boolean> {
+    return await Promise.resolve(true)
+  }
+
+  override createHandler(): void {
+    this._simulatedStake = isDefined(process.env.XYO_PRODUCER_MIN_STAKE)
+      ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE)
+      : 1n
+  }
+
+  async forkedAtBlockNumber(): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+
+  async forkedAtHash(): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+
+  async forkedChainId(): Promise<Address> {
+    return await Promise.resolve(ZERO_ADDRESS)
+  }
+
+  async minWithdrawalBlocks(): Promise<bigint> {
+    return await Promise.resolve(1n)
+  }
+
+  async pending(): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+
+  async pendingByStaker(_staker: string): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+
+  async removeStake(_slot: bigint): Promise<boolean> {
+    return await Promise.resolve(true)
+  }
+
+  async rewardsContract(): Promise<string> {
+    return await Promise.resolve('')
+  }
+
+  async stakingTokenAddress(): Promise<string> {
+    return await Promise.resolve('')
+  }
+
+  async withdrawStake(_slot: bigint): Promise<boolean> {
+    return await Promise.resolve(true)
+  }
+
+  async withdrawn(): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+
+  async withdrawnByStaker(_staker: string): Promise<bigint> {
+    return await Promise.resolve(0n)
+  }
+}

package/src/Staker/Memory/index.ts

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

package/src/Staker/index.ts

@@ -1 +1,2 @@
 export * from './Evm/index.ts'
+export * from './Memory/index.ts'

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './BlockReward/index.ts'
 export * from './ChainBlockNumberIteration/index.ts'
 export * from './ChainValidator/index.ts'
 export * from './Election/index.ts'
+export * from './Params.ts'
 export * from './PendingTransactions/index.ts'
 export * from './StakeIntent/index.ts'
 export * from './Staker/index.ts'