@xyo-network/crypto-nft-diviner-score-plugin 2.99.4 → 2.99.5

package/dist/browser/Plugin.d.cts

@@ -1,4 +1,4 @@
-import { NftScoreDiviner } from './Diviner.js';
+import { NftScoreDiviner } from './Diviner.ts';
 export declare const NftScoreDivinerPlugin: () => import("@xyo-network/payloadset-plugin").PayloadSetDivinerPlugin<NftScoreDiviner<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random";
     addToResolvers?: boolean;

package/dist/browser/Plugin.d.mts

@@ -1,4 +1,4 @@
-import { NftScoreDiviner } from './Diviner.js';
+import { NftScoreDiviner } from './Diviner.ts';
 export declare const NftScoreDivinerPlugin: () => import("@xyo-network/payloadset-plugin").PayloadSetDivinerPlugin<NftScoreDiviner<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random";
     addToResolvers?: boolean;

package/dist/browser/Plugin.d.ts

@@ -1,4 +1,4 @@
-import { NftScoreDiviner } from './Diviner.js';
+import { NftScoreDiviner } from './Diviner.ts';
 export declare const NftScoreDivinerPlugin: () => import("@xyo-network/payloadset-plugin").PayloadSetDivinerPlugin<NftScoreDiviner<import("@xylabs/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random";
     addToResolvers?: boolean;

package/dist/browser/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -37,37 +38,43 @@ var import_payload_builder = require("@xyo-network/payload-builder");
 // src/lib/rating/criteria/scoring/contract.ts
 var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
 var import_ethers = require("ethers");
-var scoreContractAddress = (nft) => {
+var scoreContractAddress = /* @__PURE__ */ __name((nft) => {
   if (!nft.address) return import_crypto_nft_score_model.FAIL;
   if (typeof nft.address !== "string") return import_crypto_nft_score_model.FAIL;
   if (!(0, import_ethers.isAddress)(nft.address)) return import_crypto_nft_score_model.FAIL;
   return import_crypto_nft_score_model.PASS;
-};
+}, "scoreContractAddress");
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
 var import_crypto_nft_score_model2 = require("@xyo-network/crypto-nft-score-model");
 
 // src/lib/rating/criteria/scoring/metadata/lib/urlHelpers.ts
 var import_url = require("@xylabs/url");
-var web3Protocols = ["ipfs:", "ar:"];
-var toUrl = (url) => {
+var web3Protocols = [
+  "ipfs:",
+  "ar:"
+];
+var toUrl = /* @__PURE__ */ __name((url) => {
   if (!url) return void 0;
   try {
     return new import_url.URL(url);
   } catch {
     return void 0;
   }
-};
-var isValidUrl = (url) => toUrl(url) !== void 0;
-var isWeb3 = (url) => web3Protocols.some((protocol) => protocol === toUrl(url)?.protocol);
-var isSecure = (url) => isWeb3(url) || toUrl(url)?.protocol === "https:";
+}, "toUrl");
+var isValidUrl = /* @__PURE__ */ __name((url) => toUrl(url) !== void 0, "isValidUrl");
+var isWeb3 = /* @__PURE__ */ __name((url) => web3Protocols.some((protocol) => protocol === toUrl(url)?.protocol), "isWeb3");
+var isSecure = /* @__PURE__ */ __name((url) => isWeb3(url) || toUrl(url)?.protocol === "https:", "isSecure");
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
-var scoreNftAnimationUrl = (nft) => {
+var scoreNftAnimationUrl = /* @__PURE__ */ __name((nft) => {
   return scoreAnimationUrl(nft.metadata?.animation_url);
-};
-var scoreAnimationUrl = (animation_url) => {
-  const score = [0, 0];
+}, "scoreNftAnimationUrl");
+var scoreAnimationUrl = /* @__PURE__ */ __name((animation_url) => {
+  const score = [
+    0,
+    0
+  ];
   if (animation_url === void 0 || animation_url === null) return import_crypto_nft_score_model2.PASS;
   (0, import_crypto_nft_score_model2.incrementPossible)(score);
   if (typeof animation_url !== "string") return score;
@@ -78,11 +85,11 @@ var scoreAnimationUrl = (animation_url) => {
   (0, import_crypto_nft_score_model2.incrementTotalAndPossible)(score);
   if (!isWeb3(animation_url)) return score;
   return (0, import_crypto_nft_score_model2.incrementTotal)(score);
-};
+}, "scoreAnimationUrl");
 
 // src/lib/rating/criteria/scoring/metadata/attributes/evaluateAttributes.ts
 var import_crypto_nft_score_model3 = require("@xyo-network/crypto-nft-score-model");
-var isDate = (value) => {
+var isDate = /* @__PURE__ */ __name((value) => {
   if (isNumber(value)) {
     try {
       new Date(value);
@@ -92,23 +99,38 @@ var isDate = (value) => {
     }
   }
   return false;
-};
-var isNumber = (value) => typeof value === "number";
-var isPercentage = (value) => isNumber(value) && value >= 0 && value <= 100;
-var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
-var isNonEmptyStringOrNumber = (value) => value === "number" || isNonEmptyString(value);
-var evaluateNftAttributes = (nft) => nft?.metadata?.attributes ? evaluateAttributes(nft?.metadata?.attributes) : [0, 1];
-var evaluateAttributes = (attributes) => {
-  if (!attributes || !Array.isArray(attributes) || attributes.length === 0) return [0, 1];
-  const score = [0, 0];
+}, "isDate");
+var isNumber = /* @__PURE__ */ __name((value) => typeof value === "number", "isNumber");
+var isPercentage = /* @__PURE__ */ __name((value) => isNumber(value) && value >= 0 && value <= 100, "isPercentage");
+var isNonEmptyString = /* @__PURE__ */ __name((value) => typeof value === "string" && value.length > 0, "isNonEmptyString");
+var isNonEmptyStringOrNumber = /* @__PURE__ */ __name((value) => value === "number" || isNonEmptyString(value), "isNonEmptyStringOrNumber");
+var evaluateNftAttributes = /* @__PURE__ */ __name((nft) => nft?.metadata?.attributes ? evaluateAttributes(nft?.metadata?.attributes) : [
+  0,
+  1
+], "evaluateNftAttributes");
+var evaluateAttributes = /* @__PURE__ */ __name((attributes) => {
+  if (!attributes || !Array.isArray(attributes) || attributes.length === 0) return [
+    0,
+    1
+  ];
+  const score = [
+    0,
+    0
+  ];
   for (const attribute of attributes) {
     const [attributeTotal, attributePossible] = evaluateAttribute(attribute);
     (0, import_crypto_nft_score_model3.incrementTotalAndPossible)(score, attributeTotal, attributePossible);
   }
-  return [1, 1];
-};
-var evaluateAttribute = (attribute) => {
-  const score = [0, 1];
+  return [
+    1,
+    1
+  ];
+}, "evaluateAttributes");
+var evaluateAttribute = /* @__PURE__ */ __name((attribute) => {
+  const score = [
+    0,
+    1
+  ];
   const max_value = attribute?.max_value;
   const trait_type = attribute?.trait_type;
   const value = attribute?.value;
@@ -121,8 +143,8 @@ var evaluateAttribute = (attribute) => {
     if (isNumber(max_value) && isNumber(value) && value <= max_value) (0, import_crypto_nft_score_model3.incrementTotal)(score);
   }
   return score;
-};
-var validDisplayType = (attribute) => {
+}, "evaluateAttribute");
+var validDisplayType = /* @__PURE__ */ __name((attribute) => {
   switch (attribute?.display_type) {
     case "number":
     case "boost_number": {
@@ -147,60 +169,75 @@ var validDisplayType = (attribute) => {
     }
   }
   return false;
-};
+}, "validDisplayType");
 
 // src/lib/rating/criteria/scoring/metadata/backgroundColor.ts
 var import_crypto_nft_score_model4 = require("@xyo-network/crypto-nft-score-model");
 var isHexColor = /^[\da-f]{6}$/i;
-var scoreNftBackgroundColor = (nft) => {
+var scoreNftBackgroundColor = /* @__PURE__ */ __name((nft) => {
   return scoreBackgroundColor(nft.metadata?.background_color);
-};
-var scoreBackgroundColor = (background_color) => {
-  const score = [0, 0];
+}, "scoreNftBackgroundColor");
+var scoreBackgroundColor = /* @__PURE__ */ __name((background_color) => {
+  const score = [
+    0,
+    0
+  ];
   if (background_color === void 0 || background_color === null) return import_crypto_nft_score_model4.PASS;
   (0, import_crypto_nft_score_model4.incrementPossible)(score);
   if (typeof background_color !== "string") return score;
   (0, import_crypto_nft_score_model4.incrementTotalAndPossible)(score);
   if (!isHexColor.test(background_color.toUpperCase())) return score;
   return (0, import_crypto_nft_score_model4.incrementTotal)(score);
-};
+}, "scoreBackgroundColor");
 
 // src/lib/rating/criteria/scoring/metadata/description.ts
 var import_crypto_nft_score_model5 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftDescription = (nft) => {
+var scoreNftDescription = /* @__PURE__ */ __name((nft) => {
   return scoreDescription(nft.metadata?.description);
-};
-var scoreDescription = (description) => {
-  const score = [0, 1];
+}, "scoreNftDescription");
+var scoreDescription = /* @__PURE__ */ __name((description) => {
+  const score = [
+    0,
+    1
+  ];
   if (!description || typeof description !== "string") return score;
   return (0, import_crypto_nft_score_model5.incrementTotal)(score);
-};
+}, "scoreDescription");
 
 // src/lib/rating/criteria/scoring/metadata/externalUrl.ts
 var import_crypto_nft_score_model6 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftExternalUrl = (nft) => {
+var scoreNftExternalUrl = /* @__PURE__ */ __name((nft) => {
   return scoreExternalUrl(nft?.metadata?.external_url);
-};
-var scoreExternalUrl = (external_url) => {
-  const score = [0, 2];
+}, "scoreNftExternalUrl");
+var scoreExternalUrl = /* @__PURE__ */ __name((external_url) => {
+  const score = [
+    0,
+    2
+  ];
   if (external_url === void 0 || external_url === null || typeof external_url !== "string" || !isValidUrl(external_url)) return score;
   (0, import_crypto_nft_score_model6.incrementTotal)(score);
   if (!isSecure(external_url)) return score;
   return (0, import_crypto_nft_score_model6.incrementTotal)(score);
-};
+}, "scoreExternalUrl");
 
 // src/lib/rating/criteria/scoring/metadata/image.ts
 var import_crypto_nft_score_model7 = require("@xyo-network/crypto-nft-score-model");
 var MaxPossibleImageScore = 3;
-var scoreNftImage = (nft) => {
+var scoreNftImage = /* @__PURE__ */ __name((nft) => {
   if (nft?.metadata?.image) {
     return scoreImage(nft.metadata?.image);
   } else {
-    return nft.metadata?.image_data ? import_crypto_nft_score_model7.PASS : [0, MaxPossibleImageScore];
+    return nft.metadata?.image_data ? import_crypto_nft_score_model7.PASS : [
+      0,
+      MaxPossibleImageScore
+    ];
   }
-};
-var scoreImage = (image) => {
-  const score = [0, MaxPossibleImageScore];
+}, "scoreNftImage");
+var scoreImage = /* @__PURE__ */ __name((image) => {
+  const score = [
+    0,
+    MaxPossibleImageScore
+  ];
   if (!image || typeof image !== "string" || !isValidUrl(image)) return score;
   (0, import_crypto_nft_score_model7.incrementTotal)(score);
   if (!isSecure(image)) return score;
@@ -208,13 +245,13 @@ var scoreImage = (image) => {
   if (!isWeb3(image)) return score;
   (0, import_crypto_nft_score_model7.incrementTotal)(score);
   return score;
-};
+}, "scoreImage");
 
 // src/lib/rating/criteria/scoring/metadata/imageData.ts
 var import_crypto_nft_score_model8 = require("@xyo-network/crypto-nft-score-model");
 var import_svg_parser = require("svg-parser");
 var MaxPossibleImageDataScore = 1;
-var isValidImageData = (image_data) => {
+var isValidImageData = /* @__PURE__ */ __name((image_data) => {
   if (!image_data.startsWith("<svg")) return false;
   try {
     (0, import_svg_parser.parse)(image_data);
@@ -222,46 +259,61 @@ var isValidImageData = (image_data) => {
   } catch {
     return false;
   }
-};
-var scoreNftImageData = (nft) => {
+}, "isValidImageData");
+var scoreNftImageData = /* @__PURE__ */ __name((nft) => {
   if (nft?.metadata?.image_data) {
     return scoreImageData(nft.metadata?.image_data);
   } else {
-    return nft.metadata?.image ? import_crypto_nft_score_model8.PASS : [0, MaxPossibleImageDataScore];
+    return nft.metadata?.image ? import_crypto_nft_score_model8.PASS : [
+      0,
+      MaxPossibleImageDataScore
+    ];
   }
-};
-var scoreImageData = (image_data) => {
-  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [0, MaxPossibleImageDataScore] : [MaxPossibleImageDataScore, MaxPossibleImageDataScore];
-};
+}, "scoreNftImageData");
+var scoreImageData = /* @__PURE__ */ __name((image_data) => {
+  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [
+    0,
+    MaxPossibleImageDataScore
+  ] : [
+    MaxPossibleImageDataScore,
+    MaxPossibleImageDataScore
+  ];
+}, "scoreImageData");
 
 // src/lib/rating/criteria/scoring/metadata/name.ts
 var import_crypto_nft_score_model9 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftName = (nft) => {
+var scoreNftName = /* @__PURE__ */ __name((nft) => {
   return scoreName(nft.metadata?.name);
-};
-var scoreName = (name) => {
-  const score = [0, 1];
+}, "scoreNftName");
+var scoreName = /* @__PURE__ */ __name((name) => {
+  const score = [
+    0,
+    1
+  ];
   if (!name || typeof name !== "string") return score;
   return (0, import_crypto_nft_score_model9.incrementTotal)(score);
-};
+}, "scoreName");
 
 // src/lib/rating/criteria/scoring/metadata/youtubeUrl.ts
 var import_crypto_nft_score_model10 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftYoutubeUrl = (nft) => {
+var scoreNftYoutubeUrl = /* @__PURE__ */ __name((nft) => {
   return scoreYoutubeUrl(nft?.metadata?.youtube_url);
-};
-var scoreYoutubeUrl = (youtube_url) => {
+}, "scoreNftYoutubeUrl");
+var scoreYoutubeUrl = /* @__PURE__ */ __name((youtube_url) => {
   if (youtube_url === void 0 || youtube_url === null) return import_crypto_nft_score_model10.PASS;
-  const score = [0, 2];
+  const score = [
+    0,
+    2
+  ];
   if (typeof youtube_url !== "string" || !isValidUrl(youtube_url)) return score;
   (0, import_crypto_nft_score_model10.incrementTotal)(score);
   if (!isSecure(youtube_url)) return score;
   return (0, import_crypto_nft_score_model10.incrementTotal)(score);
-};
+}, "scoreYoutubeUrl");
 
 // src/lib/rating/criteria/scoring/supply.ts
 var import_crypto_nft_score_model11 = require("@xyo-network/crypto-nft-score-model");
-var scoreSupply = (nft) => {
+var scoreSupply = /* @__PURE__ */ __name((nft) => {
   if (!nft.supply) return import_crypto_nft_score_model11.FAIL;
   if (typeof nft.supply !== "string") return import_crypto_nft_score_model11.FAIL;
   try {
@@ -269,11 +321,11 @@ var scoreSupply = (nft) => {
   } catch {
     return import_crypto_nft_score_model11.FAIL;
   }
-};
+}, "scoreSupply");
 
 // src/lib/rating/criteria/scoring/tokenId.ts
 var import_crypto_nft_score_model12 = require("@xyo-network/crypto-nft-score-model");
-var scoreTokenId = (nft) => {
+var scoreTokenId = /* @__PURE__ */ __name((nft) => {
   if (!nft.tokenId) return import_crypto_nft_score_model12.FAIL;
   if (typeof nft.tokenId !== "string") return import_crypto_nft_score_model12.FAIL;
   try {
@@ -281,92 +333,147 @@ var scoreTokenId = (nft) => {
   } catch {
     return import_crypto_nft_score_model12.FAIL;
   }
-};
+}, "scoreTokenId");
 
 // src/lib/rating/criteria/scoring/type.ts
 var import_crypto_nft_score_model13 = require("@xyo-network/crypto-nft-score-model");
-var scoreType = (nft) => {
+var scoreType = /* @__PURE__ */ __name((nft) => {
   if (!nft.type) return import_crypto_nft_score_model13.FAIL;
   if (typeof nft.type !== "string") return import_crypto_nft_score_model13.FAIL;
   const type = nft.type.toUpperCase();
   if (type !== "ERC721" && type !== "ERC1155") return import_crypto_nft_score_model13.FAIL;
   return import_crypto_nft_score_model13.PASS;
-};
+}, "scoreType");
 
 // src/lib/rating/criteria/scoringCriteria.ts
 var attributesScoringCriteria = {
-  Attributes: { score: evaluateNftAttributes, weight: 1 }
+  Attributes: {
+    score: evaluateNftAttributes,
+    weight: 1
+  }
 };
 var metadataScoringCriteria = {
-  "Animation URL": { score: scoreNftAnimationUrl, weight: 1 },
-  "Background Color": { score: scoreNftBackgroundColor, weight: 1 },
-  Description: { score: scoreNftDescription, weight: 1 },
-  "External Url": { score: scoreNftExternalUrl, weight: 1 },
-  Image: { score: scoreNftImage, weight: 1 },
-  "Image Data": { score: scoreNftImageData, weight: 1 },
-  Name: { score: scoreNftName, weight: 1 },
-  "YouTube URL": { score: scoreNftYoutubeUrl, weight: 1 },
+  "Animation URL": {
+    score: scoreNftAnimationUrl,
+    weight: 1
+  },
+  "Background Color": {
+    score: scoreNftBackgroundColor,
+    weight: 1
+  },
+  "Description": {
+    score: scoreNftDescription,
+    weight: 1
+  },
+  "External Url": {
+    score: scoreNftExternalUrl,
+    weight: 1
+  },
+  "Image": {
+    score: scoreNftImage,
+    weight: 1
+  },
+  "Image Data": {
+    score: scoreNftImageData,
+    weight: 1
+  },
+  "Name": {
+    score: scoreNftName,
+    weight: 1
+  },
+  "YouTube URL": {
+    score: scoreNftYoutubeUrl,
+    weight: 1
+  },
   ...attributesScoringCriteria
 };
 var scoringCriteria = {
-  "Contract Address": { score: scoreContractAddress, weight: 1 },
-  Supply: { score: scoreSupply, weight: 1 },
-  "Token Id": { score: scoreTokenId, weight: 1 },
-  Type: { score: scoreType, weight: 1 },
+  "Contract Address": {
+    score: scoreContractAddress,
+    weight: 1
+  },
+  "Supply": {
+    score: scoreSupply,
+    weight: 1
+  },
+  "Token Id": {
+    score: scoreTokenId,
+    weight: 1
+  },
+  "Type": {
+    score: scoreType,
+    weight: 1
+  },
   ...metadataScoringCriteria
 };
 
 // src/lib/rating/analyzeNft.ts
-var analyzeNft = async (nft) => {
-  const result = Object.fromEntries(
-    await Promise.all(
-      Object.entries(scoringCriteria).map(async ([key, { score, weight }]) => {
-        const rawScore = await score(nft);
-        const weighted = rawScore.map((v) => v * weight);
-        return [key, weighted];
-      })
-    )
-  );
+var analyzeNft = /* @__PURE__ */ __name(async (nft) => {
+  const result = Object.fromEntries(await Promise.all(Object.entries(scoringCriteria).map(async ([key, { score, weight }]) => {
+    const rawScore = await score(nft);
+    const weighted = rawScore.map((v) => v * weight);
+    return [
+      key,
+      weighted
+    ];
+  })));
   return result;
-};
+}, "analyzeNft");
 
 // src/Diviner.ts
-var toNftScorePayload = (nftInfo, scores) => {
+var toNftScorePayload = /* @__PURE__ */ __name((nftInfo, scores) => {
   const { address, chainId, type } = nftInfo;
-  return { address, chainId, schema: import_crypto_nft_payload_plugin.NftScoreSchema, scores, type };
-};
-var isNftScore = (payload) => payload.schema === import_crypto_nft_payload_plugin.NftScoreSchema;
+  return {
+    address,
+    chainId,
+    schema: import_crypto_nft_payload_plugin.NftScoreSchema,
+    scores,
+    type
+  };
+}, "toNftScorePayload");
+var isNftScore = /* @__PURE__ */ __name((payload) => payload.schema === import_crypto_nft_payload_plugin.NftScoreSchema, "isNftScore");
 var NftScoreDiviner = class extends import_diviner_abstract.AbstractDiviner {
-  static configSchemas = [...super.configSchemas, import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema];
+  static {
+    __name(this, "NftScoreDiviner");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema
+  ];
   static defaultConfigSchema = import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema;
-  divineHandler = async (payloads) => {
+  divineHandler = /* @__PURE__ */ __name(async (payloads) => {
     const nftInfos = payloads?.filter(import_crypto_nft_payload_plugin.isNftInfo) ?? [];
-    const results = await Promise.all(
-      nftInfos.map(async (nftInfo) => {
-        const [score, sourceHash] = await Promise.all([
-          // Analyze the NFT
-          toNftScorePayload(nftInfo, await analyzeNft(nftInfo)),
-          // Hash the source payload
-          import_payload_builder.PayloadBuilder.dataHash(nftInfo)
-        ]);
-        return { ...score, sources: [sourceHash] };
-      })
-    );
+    const results = await Promise.all(nftInfos.map(async (nftInfo) => {
+      const [score, sourceHash] = await Promise.all([
+        // Analyze the NFT
+        toNftScorePayload(nftInfo, await analyzeNft(nftInfo)),
+        // Hash the source payload
+        import_payload_builder.PayloadBuilder.dataHash(nftInfo)
+      ]);
+      return {
+        ...score,
+        sources: [
+          sourceHash
+        ]
+      };
+    }));
     return results;
-  };
+  }, "divineHandler");
 };
 
 // src/Plugin.ts
 var import_crypto_nft_payload_plugin2 = require("@xyo-network/crypto-nft-payload-plugin");
 var import_payload_model = require("@xyo-network/payload-model");
 var import_payloadset_plugin = require("@xyo-network/payloadset-plugin");
-var NftScoreDivinerPlugin = () => (0, import_payloadset_plugin.createPayloadSetDivinerPlugin)(
-  { required: { [import_crypto_nft_payload_plugin2.NftSchema]: 1 }, schema: import_payload_model.PayloadSetSchema },
-  {
-    diviner: async (params) => {
-      const result = await NftScoreDiviner.create(params);
-      return result;
-    }
-  }
-);
+var NftScoreDivinerPlugin = /* @__PURE__ */ __name(() => (0, import_payloadset_plugin.createPayloadSetDivinerPlugin)({
+  required: {
+    [import_crypto_nft_payload_plugin2.NftSchema]: 1
+  },
+  schema: import_payload_model.PayloadSetSchema
+}, {
+  diviner: /* @__PURE__ */ __name(async (params) => {
+    const result = await NftScoreDiviner.create(params);
+    return result;
+  }, "diviner")
+}), "NftScoreDivinerPlugin");
 //# sourceMappingURL=index.cjs.map