@xyo-network/chain-services 1.16.25 → 1.17.0

package/dist/neutral/index.mjs

@@ -3,9 +3,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/AccountBalance/accountBalanceServiceFromArchivist.ts
 import { assertEx as assertEx2 } from "@xylabs/sdk-js";
-import { findMostRecentBlock } from "@xyo-network/chain-protocol";
 import { StepSizes } from "@xyo-network/xl1-protocol";
-import { LruCacheMap, readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
+import { findMostRecentBlock, LruCacheMap, readPayloadMapFromStore } from "@xyo-network/xl1-protocol-sdk";
 import { Semaphore } from "async-mutex";
 
 // src/AccountBalance/BaseAccountBalanceService.ts
@@ -129,7 +128,7 @@ var BaseAccountBalanceService = class extends BaseService {
   async createHandler() {
     this.accountBalanceViewer = await SimpleAccountBalanceViewer.create({
       context: this.params.context,
-      transferContext: this.params.transferContext,
+      transfersSummaryContext: this.params.transfersSummaryContext,
       blockViewer: this.blockViewer
     });
   }
@@ -309,8 +308,8 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
   get balanceService() {
     return assertEx4(this.params.balanceService, () => "balanceService is required");
   }
-  get chainArchivist() {
-    return assertEx4(this.params.chainArchivist, () => "chainArchivist is required");
+  get blockViewer() {
+    return assertEx4(this.params.blockViewer, () => "blockViewer is required");
   }
   get chainId() {
     return assertEx4(this.params.chainId, () => "chainId is required");
@@ -401,7 +400,9 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       const { block: previousBlock } = assertEx4(asBlockBoundWitness(head), () => "Invalid head block");
       const nextBlock = previousBlock + 1;
       const nextBlockTransactionsStart = Date.now();
-      const nextBlockTransactions = await this.pendingTransactionsService.getPendingTransactions(head._hash, _BaseBlockProducerService.DefaultBlockSize);
+      const nextBlockTransactions = await this.pendingTransactionsService.pendingTransactions({
+        limit: _BaseBlockProducerService.DefaultBlockSize
+      });
       const nextBlockTransactionsDuration = Date.now() - nextBlockTransactionsStart;
       if (nextBlockTransactionsDuration > 200) {
         this.logger?.warn(`[Slow] Fetched ${nextBlockTransactions.length} pending transactions in ${nextBlockTransactionsDuration}ms}`);
@@ -664,6 +665,18 @@ function blockViewerFromChainIteratorAndArchivist(chainIterator, chainArchivist)
       }
       return results;
     }, "blocksByHash"),
+    blocksByNumber: /* @__PURE__ */ __name(async function(number, limit = 10) {
+      const results = [];
+      for (let i = 0; i < limit; i++) {
+        const block = await this.blockByNumber(number);
+        if (block) {
+          results.push(block);
+        } else {
+          break;
+        }
+      }
+      return results;
+    }, "blocksByNumber"),
     currentBlock: /* @__PURE__ */ __name(async function() {
       const head = await chainIterator.head();
       return this.blockByHash(head._hash);
@@ -684,7 +697,8 @@ __name(blockViewerFromChainIteratorAndArchivist, "blockViewerFromChainIteratorAn
 // src/ChainBlockNumberIteration/ChainBlockNumberIterationService.ts
 import { assertEx as assertEx7, isDefined as isDefined3, isNull, isUndefined } from "@xylabs/sdk-js";
 import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/payload-builder";
-import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitness as asBlockBoundWitness2, asBlockBoundWitnessWithStorageMeta, asSignedHydratedBlockWithHashMeta, asXL1BlockNumber, isBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol";
+import { hydrateBlock } from "@xyo-network/xl1-protocol-sdk";
 import { LRUCache } from "lru-cache";
 var ChainBlockNumberIterationService = class extends BaseService {
   static {
@@ -700,6 +714,50 @@ var ChainBlockNumberIterationService = class extends BaseService {
   get chainMap() {
     return assertEx7(this.params.chainMap);
   }
+  get chainStoreRead() {
+    return {
+      chainMap: this.chainMap
+    };
+  }
+  async blockByHash(hash) {
+    return asSignedHydratedBlockWithHashMeta(await hydrateBlock(this.chainStoreRead, hash)) ?? null;
+  }
+  async blockByNumber(block) {
+    return asSignedHydratedBlockWithHashMeta(await this.get(block)) ?? null;
+  }
+  async blocksByHash(hash, limit = 100) {
+    const results = [];
+    let currentBlock = await this.blockByHash(hash);
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock);
+      const previousHash = currentBlock[0].previous;
+      if (isNull(previousHash)) break;
+      currentBlock = await this.blockByHash(previousHash);
+    }
+    return results;
+  }
+  async blocksByNumber(blockNumber, limit = 100) {
+    const results = [];
+    let currentBlock = await this.blockByNumber(blockNumber);
+    while (currentBlock !== null && (isUndefined(limit) || results.length < limit)) {
+      results.push(currentBlock);
+      if (currentBlock[0].block === 0) break;
+      const previousNumber = asXL1BlockNumber(currentBlock[0].block - 1, true);
+      currentBlock = await this.blockByNumber(previousNumber);
+    }
+    return results;
+  }
+  async currentBlock() {
+    return assertEx7(await this.blockByHash(await this.currentBlockHash()), () => "Current block not found");
+  }
+  async currentBlockHash() {
+    const head = assertEx7(await this.head(), () => "Head is not set");
+    return head._hash;
+  }
+  async currentBlockNumber() {
+    const head = assertEx7(await this.head(), () => "Head is not set");
+    return head.block;
+  }
   async get(block) {
     const head = await this.head();
     assertEx7(head.block >= block, () => `Block requested is newer than the current head [${block}]`);
@@ -781,71 +839,71 @@ var EvmChainService = class extends BaseService {
   static {
     __name(this, "EvmChainService");
   }
-  get chainId() {
-    return assertEx8(this.params.id);
-  }
-  get contract() {
-    if (this.params.contract === void 0) {
-      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(this.chainId), this.params.runner);
-    }
-    return assertEx8(this.params.contract);
-  }
   get runner() {
     return assertEx8(this.params.runner);
   }
   async active() {
-    return await this.contract.active();
+    return await (await this.contract()).active();
   }
   async activeByStaked(staked) {
-    return await this.contract.activeByAddressStaked(getAddress(toEthAddress2(staked)));
+    return await (await this.contract()).activeByAddressStaked(getAddress(toEthAddress2(staked)));
   }
   async activeByStaker(address) {
-    return await this.contract.activeByStaker(getAddress(toEthAddress2(address)));
+    return await (await this.contract()).activeByStaker(getAddress(toEthAddress2(address)));
   }
   async addStake(staked, amount) {
-    const result = await this.contract.addStake(getAddress(toEthAddress2(staked)), amount);
+    const result = await (await this.contract()).addStake(getAddress(toEthAddress2(staked)), amount);
     await result.wait();
     return true;
   }
+  chainId() {
+    return assertEx8(this.params.id);
+  }
+  async contract() {
+    if (this.params.contract === void 0) {
+      this.params.contract = StakedXyoChainFactory.connect(toEthAddress2(await this.chainId()), this.params.runner);
+    }
+    return assertEx8(this.params.contract);
+  }
   async forkedAtBlockNumber() {
-    return await this.contract.forkedAtBlockNumber();
+    return await (await this.contract()).forkedAtBlockNumber();
   }
   async forkedAtHash() {
-    return await this.contract.forkedAtHash();
+    return await (await this.contract()).forkedAtHash();
   }
   async forkedChainId() {
-    return toAddress(await this.contract.forkedChainId());
+    return toAddress(await (await this.contract()).forkedChainId());
   }
   async minWithdrawalBlocks() {
-    return await this.contract.minWithdrawalBlocks();
+    return await (await this.contract()).minWithdrawalBlocks();
   }
   async pending() {
-    return await this.contract.pending();
+    return await (await this.contract()).pending();
   }
   async pendingByStaker(staker) {
-    return await this.contract.pendingByStaker(getAddress(toEthAddress2(staker)));
+    return await (await this.contract()).pendingByStaker(getAddress(toEthAddress2(staker)));
   }
   async removeStake(slot) {
-    const result = await this.contract.removeStake(slot);
+    const result = await (await this.contract()).removeStake(slot);
     await result.wait();
     return true;
   }
   async rewardsContract() {
-    return await this.contract.rewardsContract();
+    return await (await this.contract()).rewardsContract();
   }
   async stakingTokenAddress() {
-    return await this.contract.stakingTokenAddress();
+    return await (await this.contract()).stakingTokenAddress();
   }
   async withdrawStake(slot) {
-    const result = await this.contract.withdrawStake(slot);
+    const result = await (await this.contract()).withdrawStake(slot);
     await result.wait();
     return true;
   }
   async withdrawn() {
-    return await this.contract.withdrawn();
+    return await (await this.contract()).withdrawn();
   }
   async withdrawnByStaker(staker) {
-    return await this.contract.withdrawnByStaker(getAddress(staker));
+    return await (await this.contract()).withdrawnByStaker(getAddress(staker));
   }
 };
 
@@ -857,9 +915,6 @@ var MemoryChainService = class extends BaseService {
   }
   _chainId;
   _simulatedStake = 1n;
-  get chainId() {
-    return assertEx9(this._chainId, () => "Chain ID not set");
-  }
   async active() {
     return await Promise.resolve(this._simulatedStake);
   }
@@ -872,6 +927,9 @@ var MemoryChainService = class extends BaseService {
   async addStake(_staked, _amount) {
     return await Promise.resolve(true);
   }
+  chainId() {
+    return assertEx9(this._chainId, () => "Chain ID not set");
+  }
   createHandler() {
     const { minStake = 1 } = this.params.config.producer ?? {};
     this._simulatedStake = BigInt(minStake);
@@ -937,8 +995,8 @@ var XyoValidator = class extends BaseService {
   get account() {
     return assertEx10(this.params.account, () => "account is required");
   }
-  get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "chainArchivist is required");
+  get blockViewer() {
+    return assertEx10(this.params.blockViewer, () => "blockViewer is required");
   }
   get chainInfo() {
     return assertEx10(this.params.chainId, () => "chainInfo is required");
@@ -958,9 +1016,7 @@ var XyoValidator = class extends BaseService {
   // TODO: Move to validator and inherit this class from validator
   async validatePendingTransaction(hydratedTransaction) {
     const [tx] = hydratedTransaction;
-    if ((await this.chainArchivist.get([
-      tx._hash
-    ])).length > 0) return false;
+    if (await this.blockViewer.blockByHash(tx._hash) !== void 0) return false;
     return await Promise.resolve(true);
   }
 };
@@ -982,8 +1038,8 @@ var BaseElectionService = class extends BaseService {
   static {
     __name(this, "BaseElectionService");
   }
-  get chainIterator() {
-    return assertEx11(this.params.chainIterator, () => "No chain iterator");
+  get blockViewer() {
+    return assertEx11(this.params.blockViewer, () => "No block viewer");
   }
   get chainStakeViewer() {
     return assertEx11(this.params.chainStakeViewer, () => "No chain stake viewer");
@@ -1086,8 +1142,8 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 import { ValueType } from "@opentelemetry/api";
 import { assertEx as assertEx12, creatable as creatable11, exists as exists2, filterAs, filterAsync, forget, isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
 import { MemoryArchivist } from "@xyo-network/archivist-memory";
-import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/chain-protocol";
-import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { asBlockBoundWitnessWithHashMeta, asXL1BlockNumber as asXL1BlockNumber2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
+import { findMostRecentBlock as findMostRecentBlock2 } from "@xyo-network/xl1-protocol-sdk";
 import { TransactionJsonSchemaValidator, validateTransaction } from "@xyo-network/xl1-validation";
 import { Mutex as Mutex2 } from "async-mutex";
 
@@ -1221,12 +1277,12 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
       observer.observe(this.pendingTransactionsCount);
     });
   }
-  async getPendingTransactions(head, limit) {
+  async pendingTransactions({ limit = 100 } = {}) {
     return await this.spanAsync("getPendingTransactions", async () => {
       return await this._updateCuratedPendingTransactionsArchivistMutex.runExclusive(async () => {
-        let [lastHead] = filterAs(await this.chainArchivist.get([
-          head
-        ]), (x) => asBlockBoundWitnessWithHashMeta(x));
+        let lastHead = filterAs(await this.chainArchivist.next({
+          limit: 100
+        }), (x) => asBlockBoundWitnessWithHashMeta(x)).at(-1);
         if (isUndefined2(lastHead)) return [];
         await this.pruneCuratedPendingTransactionsArchivist(lastHead._hash);
         const foundPendingTransactions = [];
@@ -1241,7 +1297,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
           cursor = pendingBundledTransactions.at(-1)?._sequence;
           const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
           const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber(lastHead.block + 1, true)));
+          const activeTransactions = transactions.filter(isTransactionActive(asXL1BlockNumber2(lastHead.block + 1, true)));
           const txValidationResults = await Promise.all(activeTransactions.map(async (tx) => [
             tx,
             await validateTransaction(tx, {
@@ -1347,7 +1403,7 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
         foundPendingTransactionsToDeleteHashes.push(...deletedTransactionBundles.map((tx) => tx._hash).filter(exists2));
         const undeletedTransactionBundles = pendingBundledTransactions.filter((tx) => !this._removablePendingTransactionHashes.has(tx.root));
         const transactions = (await Promise.all(undeletedTransactionBundles.map((p) => bundledPayloadToHydratedTransaction(p)))).filter(exists2);
-        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber(lastHead.block + 1, true)));
+        const expiredTransactions = transactions.filter(isTransactionExpired(asXL1BlockNumber2(lastHead.block + 1, true)));
         const expiredBundleHashes = expiredTransactions.map((expiredHydratedTx) => (
           // Find the corresponding payload bundle hash for the expired transaction
           pendingBundledTransactions.find((bundledTx) => bundledTx.root === expiredHydratedTx[0]._hash)?._hash
@@ -1472,12 +1528,12 @@ var XyoStakeIntentService = class extends BaseService {
     max: STAKE_CACHE_MAX_ENTRIES
   });
   _updateMutex = new Mutex3();
+  get blockViewer() {
+    return assertEx13(this.params.blockViewer, () => "blockViewer not set");
+  }
   get chainArchivist() {
     return assertEx13(this.params.chainArchivist, () => "chainArchivist not set");
   }
-  get chainIterator() {
-    return assertEx13(this.params.chainIterator, () => "chainIterator not set");
-  }
   get chainStakeViewer() {
     return assertEx13(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
@@ -1485,13 +1541,9 @@ var XyoStakeIntentService = class extends BaseService {
     return assertEx13(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
-    this.chainIterator.on("headUpdated", async () => {
-      await this.updateIndex();
-    });
-    const head = await this.chainIterator.head();
+    const head = await this.blockViewer.currentBlock();
     if (isUndefined3(head)) return;
-    const headHash = await PayloadBuilder7.hash(head);
-    await this.recoverState(headHash);
+    await this.recoverState(head[0]._hash);
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
@@ -1607,7 +1659,7 @@ var XyoStakeIntentService = class extends BaseService {
     }
     await this._updateMutex.runExclusive(async () => {
       return await this.spanAsync("updateIndex", async () => {
-        const currentHead = await this.chainIterator.head();
+        const currentHead = (await this.blockViewer.currentBlock())[0];
         if (isUndefined3(currentHead)) return;
         return await timeBudget("XyoStakeIntentService.updateIndex", console, async () => {
           const currentHeadHash = currentHead._hash;
@@ -1679,11 +1731,8 @@ var BaseTimeSyncService = class extends BaseService {
     __name(this, "BaseTimeSyncService");
   }
   timeSyncViewer;
-  get chainArchivist() {
-    return this.params.chainArchivist;
-  }
-  get chainIterator() {
-    return this.params.chainIterator;
+  get blockViewer() {
+    return this.params.blockViewer;
   }
   get ethProvider() {
     return this.params.ethProvider;
@@ -1693,8 +1742,7 @@ var BaseTimeSyncService = class extends BaseService {
   }
   async createHandler() {
     await super.createHandler();
-    const blockViewer = blockViewerFromChainIteratorAndArchivist(this.chainIterator, this.chainArchivist);
-    this.timeSyncViewer = new SimpleTimeSyncViewer(blockViewer, this.ethProvider);
+    this.timeSyncViewer = new SimpleTimeSyncViewer(this.blockViewer, this.ethProvider);
   }
   async currentTime(domain) {
     return await this.timeSyncViewer.currentTime(domain);