@xyo-network/xl1-protocol-sdk 1.26.6 → 1.26.8

package/dist/neutral/index.mjs

@@ -4681,7 +4681,10 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingBlockMap.length === remainingBlocks.length,
         () => `remainingBlockMap length should match remainingBlocks length [${remainingBlockMap.length}/${remainingBlocks.length}]`
       );
-      const validationResults = await this.blockValidationViewer.validateBlocks(remainingBlocks, { value: true, state: true });
+      const validationResults = await Promise.all(remainingBlocks.map((remainingBlock) => this.blockValidationViewer.validateBlock(
+        remainingBlock,
+        { value: true, state: true }
+      )));
       for (const [i, r] of validationResults.entries()) {
         const validated = isHydratedBlockWithHashMeta(r);
         if (!validated) {
@@ -4738,7 +4741,10 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         remainingTransactionMap.length === remainingTransactions.length,
         () => `remainingTransactionMap length should match remainingTransactions length [${remainingTransactionMap.length}/${remainingTransactions.length}]`
       );
-      const validationResults = await this.transactionValidationViewer.validateTransactions(remainingTransactions, { value: true, state: true });
+      const validationResults = await Promise.all(remainingTransactions.map((remainingTransaction) => this.transactionValidationViewer.validateTransaction(
+        remainingTransaction,
+        { value: true, state: true }
+      )));
       for (const [i, r] of validationResults.entries()) {
         const validated = isHydratedTransactionWithHashMeta(r);
         if (!validated) {
@@ -5712,16 +5718,133 @@ SimpleTimeSyncViewer = __decorateClass([
   creatableProvider()
 ], SimpleTimeSyncViewer);
 
+// src/simple/transactionValidation/SimpleTransactionValidationViewer.ts
+import { assertEx as assertEx45 } from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder23 } from "@xyo-network/sdk-js";
+import {
+  AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
+  asXL1BlockRange as asXL1BlockRange12,
+  BlockViewerMoniker as BlockViewerMoniker5,
+  ChainContractViewerMoniker as ChainContractViewerMoniker5,
+  isChainQualifiedHeadConfig as isChainQualifiedHeadConfig6,
+  isHydratedTransaction,
+  TransactionValidationViewerMoniker as TransactionValidationViewerMoniker2
+} from "@xyo-network/xl1-protocol-lib";
+var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider {
+  moniker = SimpleTransactionValidationViewer.defaultMoniker;
+  _accountBalanceViewer;
+  _blockViewer;
+  _chainContractViewer;
+  get blockViewer() {
+    return this._blockViewer;
+  }
+  get chainContractViewer() {
+    return this._chainContractViewer;
+  }
+  get maxUncleWindowSize() {
+    return this.params.maxUncleWindowSize;
+  }
+  static async paramsHandler(params) {
+    return {
+      ...await super.paramsHandler(params),
+      protocol: params.protocol,
+      state: params.state,
+      maxUncleWindowSize: params.maxUncleWindowSize ?? 100
+    };
+  }
+  async createHandler() {
+    await super.createHandler();
+    this._accountBalanceViewer = await this.locator.getInstance(AccountBalanceViewerMoniker3);
+    this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker5);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker5);
+  }
+  async qualifiedValidateTransaction(block, config) {
+    const result = await this.qualifiedValidateTransactions([block], config);
+    return [result[0][0], result[1]];
+  }
+  async qualifiedValidateTransactions(transactions, config) {
+    const { value, state } = config ?? {
+      shape: true,
+      links: true,
+      state: true,
+      head: void 0
+    };
+    const transactionsWithMeta = await Promise.all(transactions.map((b) => Promise.all([PayloadBuilder23.addHashMeta(b[0]), PayloadBuilder23.addHashMeta(b[1])])));
+    const head = isChainQualifiedHeadConfig6(config) ? assertEx45(
+      (await this.blockViewer.blockByHash(config.head))?.[0],
+      () => `Specified a head that is not in the chain [${config.head}]`
+    ) : void 0;
+    const headBlock = head ?? (await this.blockViewer.currentBlock())[0];
+    const validateProtocol = value ? this.doValidateProtocol.bind(this) : void 0;
+    const validateState = state ? this.doValidateState.bind(this) : void 0;
+    const chainId = headBlock.chain;
+    const qualification = { head: headBlock._hash, range: asXL1BlockRange12([0, headBlock.block], true) };
+    const [protocolResults, stateResults] = await Promise.all([
+      validateProtocol?.(transactionsWithMeta, chainId),
+      validateState?.(transactionsWithMeta, chainId)
+    ]);
+    const blockResults = transactionsWithMeta.map((r, i) => {
+      const errors = [];
+      if (protocolResults && !isHydratedTransaction(protocolResults[i])) {
+        errors.push(...protocolResults[i]);
+      }
+      if (stateResults && !isHydratedTransaction(stateResults[i])) {
+        errors.push(...stateResults[i]);
+      }
+      return errors.length === 0 ? r : errors;
+    });
+    return [blockResults, qualification];
+  }
+  qualifiedValidateUncle(_transactions, _config) {
+    throw new Error("Method not implemented.");
+  }
+  async validateTransaction(block, config) {
+    return (await this.validateTransactions([block], config))[0];
+  }
+  async validateTransactions(transactions, config) {
+    return (await this.qualifiedValidateTransactions(transactions, config))[0];
+  }
+  async doValidateProtocol(transactions, chainId) {
+    return await Promise.all(transactions.map(async (tx) => {
+      const errors = await this.params.protocol(
+        { ...this.context, chainId },
+        tx
+      );
+      return errors.length === 0 ? tx : errors;
+    }));
+  }
+  async doValidateState(transactions, chainId) {
+    return await Promise.all(transactions.map(async (tx) => {
+      const errors = await this.params.state(
+        {
+          ...this.context,
+          chainId,
+          accountBalanceViewer: this._accountBalanceViewer,
+          blockViewer: this.blockViewer
+        },
+        tx
+      );
+      return errors.length === 0 ? tx : errors;
+    }));
+  }
+};
+__publicField(SimpleTransactionValidationViewer, "defaultMoniker", TransactionValidationViewerMoniker2);
+__publicField(SimpleTransactionValidationViewer, "dependencies", [AccountBalanceViewerMoniker3, ChainContractViewerMoniker5, BlockViewerMoniker5]);
+__publicField(SimpleTransactionValidationViewer, "monikers", [TransactionValidationViewerMoniker2]);
+SimpleTransactionValidationViewer = __decorateClass([
+  creatableProvider()
+], SimpleTransactionValidationViewer);
+
 // src/simple/TransactionViewer/SimpleTransactionViewer.ts
 import {
-  assertEx as assertEx45,
+  assertEx as assertEx46,
   exists as exists10
 } from "@xylabs/sdk-js";
 import { BoundWitnessSchema } from "@xyo-network/sdk-js";
 import {
   asSignedHydratedTransactionWithHashMeta,
   asSignedTransactionBoundWitness,
-  BlockViewerMoniker as BlockViewerMoniker5,
+  BlockViewerMoniker as BlockViewerMoniker6,
   isTransactionBoundWitnessWithHashMeta,
   TransactionViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
@@ -5733,7 +5856,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
   async byBlockHashAndIndex(blockHash, transactionIndex) {
     return await this.spanAsync("byBlockHashAndIndex", async () => {
-      assertEx45(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
+      assertEx46(transactionIndex >= 0, () => "transactionIndex must be greater than or equal to 0");
       try {
         const block = await this.blockViewer.blockByHash(blockHash);
         if (!block) return null;
@@ -5776,7 +5899,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker5);
+    this._blockViewer = await this.locator.getInstance(BlockViewerMoniker6);
   }
   async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
     return await this.byBlockHashAndIndex(blockHash, transactionIndex);
@@ -5789,7 +5912,7 @@ var SimpleTransactionViewer = class extends AbstractCreatableProvider {
   }
 };
 __publicField(SimpleTransactionViewer, "defaultMoniker", TransactionViewerMoniker);
-__publicField(SimpleTransactionViewer, "dependencies", [BlockViewerMoniker5]);
+__publicField(SimpleTransactionViewer, "dependencies", [BlockViewerMoniker6]);
 __publicField(SimpleTransactionViewer, "monikers", [TransactionViewerMoniker]);
 SimpleTransactionViewer = __decorateClass([
   creatableProvider()
@@ -5797,13 +5920,13 @@ SimpleTransactionViewer = __decorateClass([
 
 // src/simple/windowedBlock/SimpleWindowedBlockViewer.ts
 import {
-  assertEx as assertEx46,
+  assertEx as assertEx47,
   exists as exists11,
   isNull as isNull2
 } from "@xylabs/sdk-js";
 import {
   asXL1BlockNumber as asXL1BlockNumber12,
-  BlockViewerMoniker as BlockViewerMoniker6,
+  BlockViewerMoniker as BlockViewerMoniker7,
   WindowedBlockViewerMoniker as WindowedBlockViewerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 import { Mutex as Mutex2 } from "async-mutex";
@@ -5868,8 +5991,8 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   }
   async createHandler() {
     await super.createHandler();
-    this._blockViewer = assertEx46(
-      this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker6),
+    this._blockViewer = assertEx47(
+      this.params.blockViewer ?? await this.locator.getInstance(BlockViewerMoniker7),
       () => "BlockViewer instance is required"
     );
     this._blockHashMap = new MemoryMap();
@@ -5877,13 +6000,13 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
     this._transactionHashMap = new MemoryMap();
   }
   currentBlock() {
-    return assertEx46(this._chain.at(-1));
+    return assertEx47(this._chain.at(-1));
   }
   currentBlockHash() {
-    return assertEx46(this._chain.at(-1)?.[0]._hash);
+    return assertEx47(this._chain.at(-1)?.[0]._hash);
   }
   currentBlockNumber() {
-    return assertEx46(this._chain.at(-1)?.[0].block);
+    return assertEx47(this._chain.at(-1)?.[0].block);
   }
   async payloadByHash(hash) {
     const payloads = await this.payloadsByHash([hash]);
@@ -5954,7 +6077,7 @@ var SimpleWindowedBlockViewer = class extends AbstractCreatableProvider {
   }
 };
 __publicField(SimpleWindowedBlockViewer, "defaultMoniker", WindowedBlockViewerMoniker2);
-__publicField(SimpleWindowedBlockViewer, "dependencies", [BlockViewerMoniker6]);
+__publicField(SimpleWindowedBlockViewer, "dependencies", [BlockViewerMoniker7]);
 __publicField(SimpleWindowedBlockViewer, "monikers", [WindowedBlockViewerMoniker2]);
 SimpleWindowedBlockViewer = __decorateClass([
   creatableProvider()
@@ -6042,13 +6165,13 @@ var RuntimeStatusMonitor = class extends LoggerStatusReporter {
 };
 
 // src/time/primitives/xl1BlockNumberToEthBlockNumber.ts
-import { assertEx as assertEx47 } from "@xylabs/sdk-js";
+import { assertEx as assertEx48 } from "@xylabs/sdk-js";
 import { asTimePayload as asTimePayload3, TimeSchema as TimeSchema2 } from "@xyo-network/xl1-protocol-lib";
 async function xl1BlockNumberToEthBlockNumber(context, xl1BlockNumber) {
   const blockHash = await hashFromBlockNumber(context, xl1BlockNumber);
   const hydratedBlock = await hydrateBlock(context, blockHash);
   const timePayload = asTimePayload3(hydratedBlock[1].find((p) => p.schema === TimeSchema2), { required: true });
-  return assertEx47(timePayload.ethereum, () => "No ethereum timestamp found on block");
+  return assertEx48(timePayload.ethereum, () => "No ethereum timestamp found on block");
 }
 
 // src/wallet/generateXyoBaseWalletFromPhrase.ts
@@ -6140,6 +6263,7 @@ export {
   SimpleStakeTotalsViewer,
   SimpleStakeViewer,
   SimpleTimeSyncViewer,
+  SimpleTransactionValidationViewer,
   SimpleTransactionViewer,
   SimpleWindowedBlockViewer,
   SimpleXyoClient,