@xyo-network/chain-services 1.16.22 → 1.16.23

package/dist/neutral/index.mjs

@@ -159,8 +159,11 @@ var BaseAccountBalanceService = class extends BaseService {
       return result;
     });
   }
-  async accountBalancesHistories(addresses, headOrRange) {
-    return await this.accountBalanceViewer.accountBalancesHistories(addresses, headOrRange);
+  accountsBalances(address, headOrRange) {
+    throw new Error("Method not implemented.");
+  }
+  async accountsBalancesHistory(addresses, headOrRange) {
+    return await this.accountBalanceViewer.accountsBalancesHistory(addresses, headOrRange);
   }
   createHandler() {
     this.blockViewer = blockViewerFromChainIteratorAndArchivist(this.params.chainIterator, this.params.chainArchivist);
@@ -441,7 +444,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       blockPayloads.push(...fundedTransfers, timePayload);
       this.logger?.info(`Building block ${head.block + 1}`);
       const startBuild = Date.now();
-      const stepRewardPoolBalance = (await this.balanceService.accountBalances([
+      const stepRewardPoolBalance = (await this.balanceService.accountsBalances([
         XYO_STEP_REWARD_ADDRESS
       ]))[XYO_STEP_REWARD_ADDRESS];
       const block = await buildNextBlock(head, fundedNextBlockTransactions, blockPayloads, [
@@ -471,7 +474,7 @@ var BaseBlockProducerService = class _BaseBlockProducerService extends BaseServi
       if (!transfer) return;
       const totalTransferCost = Object.values(transfer?.transfers).reduce((acc, t) => acc + hexToBigInt(t ?? "00"), 0n);
       if (validateBalances) {
-        const balance = (await this.balanceService.accountBalances([
+        const balance = (await this.balanceService.accountsBalances([
           transfer.from
         ]))[transfer.from] ?? AttoXL13(0n);
         if (balance >= totalTransferCost) {
@@ -807,14 +810,15 @@ var EvmChainService = class extends BaseService {
 };
 
 // src/ChainService/Memory/Memory.ts
-import { ZERO_ADDRESS } from "@xylabs/sdk-js";
+import { assertEx as assertEx8, toAddress as toAddress2, ZERO_ADDRESS } from "@xylabs/sdk-js";
 var MemoryChainService = class extends BaseService {
   static {
     __name(this, "MemoryChainService");
   }
+  _chainId;
   _simulatedStake = 1n;
   get chainId() {
-    return ZERO_ADDRESS;
+    return assertEx8(this._chainId, () => "Chain ID not set");
   }
   async active() {
     return await Promise.resolve(this._simulatedStake);
@@ -829,7 +833,7 @@ var MemoryChainService = class extends BaseService {
     return await Promise.resolve(true);
   }
   createHandler() {
-    const { minStake } = this.params.config.producer;
+    const { minStake = 1 } = this.params.config.producer ?? {};
     this._simulatedStake = BigInt(minStake);
   }
   async forkedAtBlockNumber() {
@@ -868,10 +872,14 @@ var MemoryChainService = class extends BaseService {
   async withdrawnByStaker(_staker) {
     return await Promise.resolve(0n);
   }
+  async startHandler() {
+    await super.startHandler();
+    this._chainId = this.params.chainId ?? toAddress2(1n);
+  }
 };
 
 // src/ChainValidator/XyoValidator.ts
-import { assertEx as assertEx8, creatable as creatable8 } from "@xylabs/sdk-js";
+import { assertEx as assertEx9, creatable as creatable8 } from "@xylabs/sdk-js";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -887,22 +895,22 @@ var XyoValidator = class extends BaseService {
     return this.account.address;
   }
   get account() {
-    return assertEx8(this.params.account, () => "account is required");
+    return assertEx9(this.params.account, () => "account is required");
   }
   get chainArchivist() {
-    return assertEx8(this.params.chainArchivist, () => "chainArchivist is required");
+    return assertEx9(this.params.chainArchivist, () => "chainArchivist is required");
   }
   get chainInfo() {
-    return assertEx8(this.params.chainId, () => "chainInfo is required");
+    return assertEx9(this.params.chainId, () => "chainInfo is required");
   }
   get electionService() {
-    return assertEx8(this.params.electionService, () => "electionService is required");
+    return assertEx9(this.params.electionService, () => "electionService is required");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx8(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
+    return assertEx9(this.params.pendingBundledTransactionsArchivist, () => "pendingBundledTransactions is required");
   }
   get rewardService() {
-    return assertEx8(this.params.rewardService, () => "rewardService is required");
+    return assertEx9(this.params.rewardService, () => "rewardService is required");
   }
   validatePendingBlock(_block) {
     return [];
@@ -921,7 +929,7 @@ XyoValidator = _ts_decorate8([
 ], XyoValidator);
 
 // src/Election/BaseElectionService.ts
-import { assertEx as assertEx9, creatable as creatable9 } from "@xylabs/sdk-js";
+import { assertEx as assertEx10, creatable as creatable9 } from "@xylabs/sdk-js";
 import { hexToLast4BytesInt, shuffleWithSeed } from "@xyo-network/chain-utils";
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -935,13 +943,13 @@ var BaseElectionService = class extends BaseService {
     __name(this, "BaseElectionService");
   }
   get chainIterator() {
-    return assertEx9(this.params.chainIterator, () => "No chain iterator");
+    return assertEx10(this.params.chainIterator, () => "No chain iterator");
   }
   get chainStakeViewer() {
-    return assertEx9(this.params.chainStakeViewer, () => "No chain stake viewer");
+    return assertEx10(this.params.chainStakeViewer, () => "No chain stake viewer");
   }
   get stakeIntentService() {
-    return assertEx9(this.params.stakeIntentService, () => "No staked intent service");
+    return assertEx10(this.params.stakeIntentService, () => "No staked intent service");
   }
   async getCreatorCommitteeForNextBlock(current) {
     return await this.spanAsync("getCreatorCommitteeForNextBlock", async () => {
@@ -1036,7 +1044,7 @@ BaseNetworkStakeStepRewardService = _ts_decorate10([
 
 // src/PendingTransactions/BasePendingTransactions.ts
 import { ValueType } from "@opentelemetry/api";
-import { assertEx as assertEx10, creatable as creatable11, exists as exists2, filterAs, filterAsync, forget, isDefined as isDefined4, isUndefined as isUndefined2 } from "@xylabs/sdk-js";
+import { assertEx as assertEx11, 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, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol";
@@ -1130,23 +1138,23 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
     return this.params.additionalPendingTransactionValidators ?? [];
   }
   get chainArchivist() {
-    return assertEx10(this.params.chainArchivist, () => "No completed blocks with data archivist");
+    return assertEx11(this.params.chainArchivist, () => "No completed blocks with data archivist");
   }
   get chainId() {
-    return assertEx10(this.params.chainId, () => "No chain id");
+    return assertEx11(this.params.chainId, () => "No chain id");
   }
   get pendingBundledTransactionsArchivist() {
-    return assertEx10(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
+    return assertEx11(this.params.pendingBundledTransactionsArchivist, () => "No pending bundled transactions archivist");
   }
   get pendingBundledTransactionsLocalArchivist() {
-    return assertEx10(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
+    return assertEx11(this._curatedPendingBundledTransactionsArchivist, () => "No pending bundled transactions curated archivist");
   }
   get pendingTransactionsCount() {
     forget(this.countPendingTransactions());
     return this._pendingTransactionsCount;
   }
   get rejectedTransactionsArchivist() {
-    return assertEx10(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
+    return assertEx11(this.params.rejectedTransactionsArchivist, () => "No rejected transactions archivist");
   }
   async createHandler() {
     await super.createHandler();
@@ -1201,6 +1209,13 @@ var BasePendingTransactionsService = class _BasePendingTransactionsService exten
             }, this.additionalPendingTransactionValidators)
           ]));
           const validTransactions = txValidationResults.filter(([, errors]) => errors.length === 0).map(([tx]) => tx);
+          const invalidTransactions = txValidationResults.filter(([, errors]) => errors.length > 0).map(([tx]) => tx);
+          if (invalidTransactions.length > 0) {
+            this.logger?.warn(`getPendingTransactions: Found ${invalidTransactions.length} invalid pending transactions`);
+            for (const tx of invalidTransactions) {
+              this.logger?.warn(tx[0]._hash);
+            }
+          }
           foundPendingTransactions.push(...validTransactions);
         }
         if (foundPendingTransactions.length > 0) {
@@ -1318,6 +1333,42 @@ BasePendingTransactionsService = _ts_decorate11([
 var isTransactionExpired = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.exp < block, "isTransactionExpired");
 var isTransactionActive = /* @__PURE__ */ __name((block) => ([txBw]) => txBw.nbf <= block && txBw.exp >= block, "isTransactionActive");
 
+// src/Schemas/BaseSchemasService.ts
+import { creatable as creatable12 } from "@xylabs/sdk-js";
+import { spanRootAsync as spanRootAsync4 } from "@xylabs/telemetry";
+import { schemasSummary } from "@xyo-network/xl1-protocol-sdk";
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+var BaseSchemasService = class extends BaseService {
+  static {
+    __name(this, "BaseSchemasService");
+  }
+  async schema(head, schema) {
+    return (await this.schemas(head, [
+      schema
+    ]))[schema] ?? 0;
+  }
+  async schemas(head, schemas) {
+    return await spanRootAsync4("transfers", async () => {
+      const summary = await schemasSummary(this.params.context);
+      const result = {};
+      for (const schema of schemas) {
+        const count = summary[schema] ?? 0;
+        result[schema] = count;
+      }
+      return result;
+    });
+  }
+};
+BaseSchemasService = _ts_decorate12([
+  creatable12()
+], BaseSchemasService);
+
 // src/StakeIntent/lib/getBlockSignedStakeDeclarations.ts
 import { exists as exists3, filterAs as filterAs2 } from "@xylabs/sdk-js";
 import { asOptionalBoundWitness } from "@xyo-network/boundwitness-model";
@@ -1345,21 +1396,21 @@ var mapBoundWitnessToStakeIntentHashes = /* @__PURE__ */ __name((bw) => {
 }, "mapBoundWitnessToStakeIntentHashes");
 
 // src/StakeIntent/XyoStakeIntentService.ts
-import { asAddress, assertEx as assertEx11, creatable as creatable12, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
+import { asAddress, assertEx as assertEx12, creatable as creatable13, filterAs as filterAs3, isUndefined as isUndefined3 } from "@xylabs/sdk-js";
 import { analyzeChain, ChainStakeIntentAnalyzer, isChainSummaryStakeIntent } from "@xyo-network/chain-analyze";
 import { DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS, findFirstMatching, IntervalMap } from "@xyo-network/chain-utils";
 import { PayloadBuilder as PayloadBuilder7 } from "@xyo-network/payload-builder";
 import { asBlockBoundWitness as asBlockBoundWitness3, asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3, asChainStakeIntent as asChainStakeIntent2 } from "@xyo-network/xl1-protocol";
-import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2 } from "@xyo-network/xl1-protocol-sdk";
+import { asChainIndexingServiceStateWithStorageMeta, ChainIndexingServiceStateSchema, isChainIndexingServiceState, readPayloadMapFromStore as readPayloadMapFromStore2, timeBudget } from "@xyo-network/xl1-protocol-sdk";
 import { Mutex as Mutex3 } from "async-mutex";
 import { LRUCache as LRUCache2 } from "lru-cache";
-function _ts_decorate12(decorators, target, key, desc) {
+function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var ACTIVE_STAKE_TTL = 1e3 * 60 * 60 * 2;
 var NO_ACTIVE_STAKE_TTL = 1e3 * 2;
 var STAKE_CACHE_MAX_ENTRIES = 1e4;
@@ -1382,16 +1433,16 @@ var XyoStakeIntentService = class extends BaseService {
   });
   _updateMutex = new Mutex3();
   get chainArchivist() {
-    return assertEx11(this.params.chainArchivist, () => "chainArchivist not set");
+    return assertEx12(this.params.chainArchivist, () => "chainArchivist not set");
   }
   get chainIterator() {
-    return assertEx11(this.params.chainIterator, () => "chainIterator not set");
+    return assertEx12(this.params.chainIterator, () => "chainIterator not set");
   }
   get chainStakeViewer() {
-    return assertEx11(this.params.chainStakeViewer, () => "chainStakeViewer not set");
+    return assertEx12(this.params.chainStakeViewer, () => "chainStakeViewer not set");
   }
   get stakeIntentStateArchivist() {
-    return assertEx11(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
+    return assertEx12(this.params.stakeIntentStateArchivist, () => "stakeIntentStateArchivist not set");
   }
   async createHandler() {
     this.chainIterator.on("headUpdated", async () => {
@@ -1404,13 +1455,13 @@ var XyoStakeIntentService = class extends BaseService {
   }
   async getDeclaredCandidateRanges(address, intent) {
     await Promise.resolve();
-    assertEx11(intent === "producer", () => `Support not yet added for intent ${intent}`);
+    assertEx12(intent === "producer", () => `Support not yet added for intent ${intent}`);
     const results = this._producers.get(address);
     return results ?? [];
   }
   async getDeclaredCandidatesForBlock(block, intent) {
     return await this.spanAsync("getDeclaredCandidatesForBlock", async () => {
-      assertEx11(intent === "producer", () => `Support not yet added for intent ${intent}`);
+      assertEx12(intent === "producer", () => `Support not yet added for intent ${intent}`);
       const results = this._producers.findAllContaining(block);
       const candidates = [
         ...results
@@ -1475,38 +1526,40 @@ var XyoStakeIntentService = class extends BaseService {
     ]);
   }
   async recoverState(current) {
-    const currentBlock = assertEx11(asBlockBoundWitness3((await this.chainArchivist.get([
-      current
-    ]))?.[0]), () => `Block ${current} not found`);
-    const currentBlockNum = currentBlock.block;
-    const opts = {
-      ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
-    };
-    while (true) {
-      const predicate = /* @__PURE__ */ __name((p) => {
-        const state2 = asChainIndexingServiceStateWithStorageMeta(p);
-        return state2 ? true : false;
-      }, "predicate");
-      const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
-      if (isChainIndexingServiceState(state)) {
-        const indexed = (await this.chainArchivist.get([
-          state.endBlockHash
-        ]))?.[0];
-        const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
-        if (indexedBlock) {
-          const indexedBlockNum = indexedBlock.block;
-          if (indexedBlockNum <= currentBlockNum) {
-            const data = state.state;
-            this._producers = new IntervalMap(data);
-            this._lastIndexedBlockHash = indexedBlock._hash;
-            break;
+    return await timeBudget("XyoStakeIntentService.recoverState", console, async () => {
+      const currentBlock = assertEx12(asBlockBoundWitness3((await this.chainArchivist.get([
+        current
+      ]))?.[0]), () => `Block ${current} not found`);
+      const currentBlockNum = currentBlock.block;
+      const opts = {
+        ...DEFAULT_FIND_FIRST_MATCHING_NEXT_OPTIONS
+      };
+      while (true) {
+        const predicate = /* @__PURE__ */ __name((p) => {
+          const state2 = asChainIndexingServiceStateWithStorageMeta(p);
+          return state2 ? true : false;
+        }, "predicate");
+        const state = await findFirstMatching(this.stakeIntentStateArchivist, predicate, opts);
+        if (isChainIndexingServiceState(state)) {
+          const indexed = (await this.chainArchivist.get([
+            state.endBlockHash
+          ]))?.[0];
+          const indexedBlock = asBlockBoundWitnessWithStorageMeta3(indexed);
+          if (indexedBlock) {
+            const indexedBlockNum = indexedBlock.block;
+            if (indexedBlockNum <= currentBlockNum) {
+              const data = state.state;
+              this._producers = new IntervalMap(data);
+              this._lastIndexedBlockHash = indexedBlock._hash;
+              break;
+            }
           }
+        } else {
+          break;
         }
-      } else {
-        break;
+        opts.open = true;
       }
-      opts.open = true;
-    }
+    }, 2e3, true);
   }
   async updateIndex(displayProgress = false) {
     if (this._updateMutex.isLocked()) {
@@ -1516,44 +1569,46 @@ var XyoStakeIntentService = class extends BaseService {
       return await this.spanAsync("updateIndex", async () => {
         const currentHead = await this.chainIterator.head();
         if (isUndefined3(currentHead)) return;
-        const currentHeadHash = await PayloadBuilder7.hash(currentHead);
-        const chainMap = readPayloadMapFromStore2(this.chainArchivist);
-        const result = await analyzeChain({
-          chainMap
-        }, [
-          new ChainStakeIntentAnalyzer("producer")
-        ], currentHeadHash, this._lastIndexedBlockHash);
-        const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
-        if (currentHead.block === void 0) return;
-        const currentHeadBlockNum = currentHead.block;
-        if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`);
-        for (const signedDeclaration of signedDeclarations) {
-          const { exp, nbf } = signedDeclaration;
-          const start = nbf;
-          const stop = exp;
-          const address = asAddress(signedDeclaration?.from);
-          if (start !== void 0 && stop !== void 0 && address !== void 0) {
-            this._producers.insert(address, start, stop);
+        return await timeBudget("XyoStakeIntentService.updateIndex", console, async () => {
+          const currentHeadHash = currentHead._hash;
+          const chainMap = readPayloadMapFromStore2(this.chainArchivist);
+          const result = await analyzeChain({
+            chainMap
+          }, [
+            new ChainStakeIntentAnalyzer("producer")
+          ], currentHeadHash, this._lastIndexedBlockHash);
+          const signedDeclarations = filterAs3(result.find(isChainSummaryStakeIntent)?.intents ?? [], asChainStakeIntent2);
+          if (currentHead.block === void 0) return;
+          const currentHeadBlockNum = currentHead.block;
+          if (displayProgress) this.logger?.log(`Updating index through 0x${currentHeadBlockNum}`);
+          for (const signedDeclaration of signedDeclarations) {
+            const { exp, nbf } = signedDeclaration;
+            const start = nbf;
+            const stop = exp;
+            const address = asAddress(signedDeclaration?.from);
+            if (start !== void 0 && stop !== void 0 && address !== void 0) {
+              this._producers.insert(address, start, stop);
+            }
           }
-        }
-        this._lastIndexedBlockHash = currentHeadHash;
+          this._lastIndexedBlockHash = currentHeadHash;
+        }, 2e3, true);
       });
     });
   }
 };
-XyoStakeIntentService = _ts_decorate12([
-  creatable12()
+XyoStakeIntentService = _ts_decorate13([
+  creatable13()
 ], XyoStakeIntentService);
 
 // src/StepStake/BaseStepStakeService.ts
-import { creatable as creatable13 } from "@xylabs/sdk-js";
-function _ts_decorate13(decorators, target, key, desc) {
+import { creatable as creatable14 } from "@xylabs/sdk-js";
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate13, "_ts_decorate");
+__name(_ts_decorate14, "_ts_decorate");
 var BaseStepStakeService = class extends BaseService {
   static {
     __name(this, "BaseStepStakeService");
@@ -1565,20 +1620,20 @@ var BaseStepStakeService = class extends BaseService {
     throw new Error("Method not implemented.");
   }
 };
-BaseStepStakeService = _ts_decorate13([
-  creatable13()
+BaseStepStakeService = _ts_decorate14([
+  creatable14()
 ], BaseStepStakeService);
 
 // src/Time/BaseTimeSyncService.ts
-import { creatable as creatable14 } from "@xylabs/sdk-js";
+import { creatable as creatable15 } from "@xylabs/sdk-js";
 import { SimpleTimeSyncViewer } from "@xyo-network/xl1-protocol-sdk";
-function _ts_decorate14(decorators, target, key, desc) {
+function _ts_decorate15(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate14, "_ts_decorate");
+__name(_ts_decorate15, "_ts_decorate");
 var BaseTimeSyncService = class extends BaseService {
   static {
     __name(this, "BaseTimeSyncService");
@@ -1611,8 +1666,8 @@ var BaseTimeSyncService = class extends BaseService {
     return await this.timeSyncViewer.currentTimePayload();
   }
 };
-BaseTimeSyncService = _ts_decorate14([
-  creatable14()
+BaseTimeSyncService = _ts_decorate15([
+  creatable15()
 ], BaseTimeSyncService);
 export {
   BaseAccountBalanceService,
@@ -1623,6 +1678,7 @@ export {
   BaseElectionService,
   BaseNetworkStakeStepRewardService,
   BasePendingTransactionsService,
+  BaseSchemasService,
   BaseService,
   BaseStepStakeService,
   BaseTimeSyncService,