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

package/dist/neutral/index.mjs

@@ -1,51 +1,45 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/Diviner.ts
-import { isNftInfo, NftScoreDivinerConfigSchema, NftScoreSchema } from "@xyo-network/crypto-nft-payload-plugin";
+import {
+  isNftInfo,
+  NftScoreDivinerConfigSchema,
+  NftScoreSchema
+} from "@xyo-network/crypto-nft-payload-plugin";
 import { AbstractDiviner } from "@xyo-network/diviner-abstract";
 import { PayloadBuilder } from "@xyo-network/payload-builder";
 
 // src/lib/rating/criteria/scoring/contract.ts
 import { FAIL, PASS } from "@xyo-network/crypto-nft-score-model";
 import { isAddress } from "ethers";
-var scoreContractAddress = /* @__PURE__ */ __name((nft) => {
+var scoreContractAddress = (nft) => {
   if (!nft.address) return FAIL;
   if (typeof nft.address !== "string") return FAIL;
   if (!isAddress(nft.address)) return FAIL;
   return PASS;
-}, "scoreContractAddress");
+};
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
 import { incrementPossible, incrementTotal, incrementTotalAndPossible, PASS as PASS2 } from "@xyo-network/crypto-nft-score-model";
 
 // src/lib/rating/criteria/scoring/metadata/lib/urlHelpers.ts
-import { URL } from "@xylabs/url";
-var web3Protocols = [
-  "ipfs:",
-  "ar:"
-];
-var toUrl = /* @__PURE__ */ __name((url) => {
+var web3Protocols = ["ipfs:", "ar:"];
+var toUrl = (url) => {
   if (!url) return void 0;
   try {
     return new URL(url);
   } catch {
     return void 0;
   }
-}, "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");
+};
+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:";
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
-var scoreNftAnimationUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftAnimationUrl = (nft) => {
   return scoreAnimationUrl(nft.metadata?.animation_url);
-}, "scoreNftAnimationUrl");
-var scoreAnimationUrl = /* @__PURE__ */ __name((animation_url) => {
-  const score = [
-    0,
-    0
-  ];
+};
+var scoreAnimationUrl = (animation_url) => {
+  const score = [0, 0];
   if (animation_url === void 0 || animation_url === null) return PASS2;
   incrementPossible(score);
   if (typeof animation_url !== "string") return score;
@@ -56,11 +50,11 @@ var scoreAnimationUrl = /* @__PURE__ */ __name((animation_url) => {
   incrementTotalAndPossible(score);
   if (!isWeb3(animation_url)) return score;
   return incrementTotal(score);
-}, "scoreAnimationUrl");
+};
 
 // src/lib/rating/criteria/scoring/metadata/attributes/evaluateAttributes.ts
 import { incrementPossible as incrementPossible2, incrementTotal as incrementTotal2, incrementTotalAndPossible as incrementTotalAndPossible2 } from "@xyo-network/crypto-nft-score-model";
-var isDate = /* @__PURE__ */ __name((value) => {
+var isDate = (value) => {
   if (isNumber(value)) {
     try {
       new Date(value);
@@ -70,38 +64,23 @@ var isDate = /* @__PURE__ */ __name((value) => {
     }
   }
   return false;
-}, "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
-  ];
+};
+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];
   for (const attribute of attributes) {
     const [attributeTotal, attributePossible] = evaluateAttribute(attribute);
     incrementTotalAndPossible2(score, attributeTotal, attributePossible);
   }
-  return [
-    1,
-    1
-  ];
-}, "evaluateAttributes");
-var evaluateAttribute = /* @__PURE__ */ __name((attribute) => {
-  const score = [
-    0,
-    1
-  ];
+  return [1, 1];
+};
+var evaluateAttribute = (attribute) => {
+  const score = [0, 1];
   const max_value = attribute?.max_value;
   const trait_type = attribute?.trait_type;
   const value = attribute?.value;
@@ -114,8 +93,8 @@ var evaluateAttribute = /* @__PURE__ */ __name((attribute) => {
     if (isNumber(max_value) && isNumber(value) && value <= max_value) incrementTotal2(score);
   }
   return score;
-}, "evaluateAttribute");
-var validDisplayType = /* @__PURE__ */ __name((attribute) => {
+};
+var validDisplayType = (attribute) => {
   switch (attribute?.display_type) {
     case "number":
     case "boost_number": {
@@ -140,75 +119,60 @@ var validDisplayType = /* @__PURE__ */ __name((attribute) => {
     }
   }
   return false;
-}, "validDisplayType");
+};
 
 // src/lib/rating/criteria/scoring/metadata/backgroundColor.ts
 import { incrementPossible as incrementPossible3, incrementTotal as incrementTotal3, incrementTotalAndPossible as incrementTotalAndPossible3, PASS as PASS3 } from "@xyo-network/crypto-nft-score-model";
 var isHexColor = /^[\da-f]{6}$/i;
-var scoreNftBackgroundColor = /* @__PURE__ */ __name((nft) => {
+var scoreNftBackgroundColor = (nft) => {
   return scoreBackgroundColor(nft.metadata?.background_color);
-}, "scoreNftBackgroundColor");
-var scoreBackgroundColor = /* @__PURE__ */ __name((background_color) => {
-  const score = [
-    0,
-    0
-  ];
+};
+var scoreBackgroundColor = (background_color) => {
+  const score = [0, 0];
   if (background_color === void 0 || background_color === null) return PASS3;
   incrementPossible3(score);
   if (typeof background_color !== "string") return score;
   incrementTotalAndPossible3(score);
   if (!isHexColor.test(background_color.toUpperCase())) return score;
   return incrementTotal3(score);
-}, "scoreBackgroundColor");
+};
 
 // src/lib/rating/criteria/scoring/metadata/description.ts
 import { incrementTotal as incrementTotal4 } from "@xyo-network/crypto-nft-score-model";
-var scoreNftDescription = /* @__PURE__ */ __name((nft) => {
+var scoreNftDescription = (nft) => {
   return scoreDescription(nft.metadata?.description);
-}, "scoreNftDescription");
-var scoreDescription = /* @__PURE__ */ __name((description) => {
-  const score = [
-    0,
-    1
-  ];
+};
+var scoreDescription = (description) => {
+  const score = [0, 1];
   if (!description || typeof description !== "string") return score;
   return incrementTotal4(score);
-}, "scoreDescription");
+};
 
 // src/lib/rating/criteria/scoring/metadata/externalUrl.ts
 import { incrementTotal as incrementTotal5 } from "@xyo-network/crypto-nft-score-model";
-var scoreNftExternalUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftExternalUrl = (nft) => {
   return scoreExternalUrl(nft?.metadata?.external_url);
-}, "scoreNftExternalUrl");
-var scoreExternalUrl = /* @__PURE__ */ __name((external_url) => {
-  const score = [
-    0,
-    2
-  ];
+};
+var scoreExternalUrl = (external_url) => {
+  const score = [0, 2];
   if (external_url === void 0 || external_url === null || typeof external_url !== "string" || !isValidUrl(external_url)) return score;
   incrementTotal5(score);
   if (!isSecure(external_url)) return score;
   return incrementTotal5(score);
-}, "scoreExternalUrl");
+};
 
 // src/lib/rating/criteria/scoring/metadata/image.ts
 import { incrementTotal as incrementTotal6, PASS as PASS4 } from "@xyo-network/crypto-nft-score-model";
 var MaxPossibleImageScore = 3;
-var scoreNftImage = /* @__PURE__ */ __name((nft) => {
+var scoreNftImage = (nft) => {
   if (nft?.metadata?.image) {
     return scoreImage(nft.metadata?.image);
   } else {
-    return nft.metadata?.image_data ? PASS4 : [
-      0,
-      MaxPossibleImageScore
-    ];
+    return nft.metadata?.image_data ? PASS4 : [0, MaxPossibleImageScore];
   }
-}, "scoreNftImage");
-var scoreImage = /* @__PURE__ */ __name((image) => {
-  const score = [
-    0,
-    MaxPossibleImageScore
-  ];
+};
+var scoreImage = (image) => {
+  const score = [0, MaxPossibleImageScore];
   if (!image || typeof image !== "string" || !isValidUrl(image)) return score;
   incrementTotal6(score);
   if (!isSecure(image)) return score;
@@ -216,13 +180,13 @@ var scoreImage = /* @__PURE__ */ __name((image) => {
   if (!isWeb3(image)) return score;
   incrementTotal6(score);
   return score;
-}, "scoreImage");
+};
 
 // src/lib/rating/criteria/scoring/metadata/imageData.ts
 import { PASS as PASS5 } from "@xyo-network/crypto-nft-score-model";
 import { parse } from "svg-parser";
 var MaxPossibleImageDataScore = 1;
-var isValidImageData = /* @__PURE__ */ __name((image_data) => {
+var isValidImageData = (image_data) => {
   if (!image_data.startsWith("<svg")) return false;
   try {
     parse(image_data);
@@ -230,61 +194,46 @@ var isValidImageData = /* @__PURE__ */ __name((image_data) => {
   } catch {
     return false;
   }
-}, "isValidImageData");
-var scoreNftImageData = /* @__PURE__ */ __name((nft) => {
+};
+var scoreNftImageData = (nft) => {
   if (nft?.metadata?.image_data) {
     return scoreImageData(nft.metadata?.image_data);
   } else {
-    return nft.metadata?.image ? PASS5 : [
-      0,
-      MaxPossibleImageDataScore
-    ];
+    return nft.metadata?.image ? PASS5 : [0, MaxPossibleImageDataScore];
   }
-}, "scoreNftImageData");
-var scoreImageData = /* @__PURE__ */ __name((image_data) => {
-  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [
-    0,
-    MaxPossibleImageDataScore
-  ] : [
-    MaxPossibleImageDataScore,
-    MaxPossibleImageDataScore
-  ];
-}, "scoreImageData");
+};
+var scoreImageData = (image_data) => {
+  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [0, MaxPossibleImageDataScore] : [MaxPossibleImageDataScore, MaxPossibleImageDataScore];
+};
 
 // src/lib/rating/criteria/scoring/metadata/name.ts
 import { incrementTotal as incrementTotal7 } from "@xyo-network/crypto-nft-score-model";
-var scoreNftName = /* @__PURE__ */ __name((nft) => {
+var scoreNftName = (nft) => {
   return scoreName(nft.metadata?.name);
-}, "scoreNftName");
-var scoreName = /* @__PURE__ */ __name((name) => {
-  const score = [
-    0,
-    1
-  ];
+};
+var scoreName = (name) => {
+  const score = [0, 1];
   if (!name || typeof name !== "string") return score;
   return incrementTotal7(score);
-}, "scoreName");
+};
 
 // src/lib/rating/criteria/scoring/metadata/youtubeUrl.ts
 import { incrementTotal as incrementTotal8, PASS as PASS6 } from "@xyo-network/crypto-nft-score-model";
-var scoreNftYoutubeUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftYoutubeUrl = (nft) => {
   return scoreYoutubeUrl(nft?.metadata?.youtube_url);
-}, "scoreNftYoutubeUrl");
-var scoreYoutubeUrl = /* @__PURE__ */ __name((youtube_url) => {
+};
+var scoreYoutubeUrl = (youtube_url) => {
   if (youtube_url === void 0 || youtube_url === null) return PASS6;
-  const score = [
-    0,
-    2
-  ];
+  const score = [0, 2];
   if (typeof youtube_url !== "string" || !isValidUrl(youtube_url)) return score;
   incrementTotal8(score);
   if (!isSecure(youtube_url)) return score;
   return incrementTotal8(score);
-}, "scoreYoutubeUrl");
+};
 
 // src/lib/rating/criteria/scoring/supply.ts
 import { FAIL as FAIL2, PASS as PASS7 } from "@xyo-network/crypto-nft-score-model";
-var scoreSupply = /* @__PURE__ */ __name((nft) => {
+var scoreSupply = (nft) => {
   if (!nft.supply) return FAIL2;
   if (typeof nft.supply !== "string") return FAIL2;
   try {
@@ -292,11 +241,11 @@ var scoreSupply = /* @__PURE__ */ __name((nft) => {
   } catch {
     return FAIL2;
   }
-}, "scoreSupply");
+};
 
 // src/lib/rating/criteria/scoring/tokenId.ts
 import { FAIL as FAIL3, PASS as PASS8 } from "@xyo-network/crypto-nft-score-model";
-var scoreTokenId = /* @__PURE__ */ __name((nft) => {
+var scoreTokenId = (nft) => {
   if (!nft.tokenId) return FAIL3;
   if (typeof nft.tokenId !== "string") return FAIL3;
   try {
@@ -304,149 +253,94 @@ var scoreTokenId = /* @__PURE__ */ __name((nft) => {
   } catch {
     return FAIL3;
   }
-}, "scoreTokenId");
+};
 
 // src/lib/rating/criteria/scoring/type.ts
 import { FAIL as FAIL4, PASS as PASS9 } from "@xyo-network/crypto-nft-score-model";
-var scoreType = /* @__PURE__ */ __name((nft) => {
+var scoreType = (nft) => {
   if (!nft.type) return FAIL4;
   if (typeof nft.type !== "string") return FAIL4;
   const type = nft.type.toUpperCase();
   if (type !== "ERC721" && type !== "ERC1155") return FAIL4;
   return PASS9;
-}, "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 = /* @__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
-    ];
-  })));
+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];
+      })
+    )
+  );
   return result;
-}, "analyzeNft");
+};
 
 // src/Diviner.ts
-var toNftScorePayload = /* @__PURE__ */ __name((nftInfo, scores) => {
+var toNftScorePayload = (nftInfo, scores) => {
   const { address, chainId, type } = nftInfo;
-  return {
-    address,
-    chainId,
-    schema: NftScoreSchema,
-    scores,
-    type
-  };
-}, "toNftScorePayload");
-var isNftScore = /* @__PURE__ */ __name((payload) => payload.schema === NftScoreSchema, "isNftScore");
+  return { address, chainId, schema: NftScoreSchema, scores, type };
+};
+var isNftScore = (payload) => payload.schema === NftScoreSchema;
 var NftScoreDiviner = class extends AbstractDiviner {
-  static {
-    __name(this, "NftScoreDiviner");
-  }
-  static configSchemas = [
-    ...super.configSchemas,
-    NftScoreDivinerConfigSchema
-  ];
+  static configSchemas = [...super.configSchemas, NftScoreDivinerConfigSchema];
   static defaultConfigSchema = NftScoreDivinerConfigSchema;
-  divineHandler = /* @__PURE__ */ __name(async (payloads) => {
+  divineHandler = async (payloads) => {
     const nftInfos = payloads?.filter(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
-        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
+          PayloadBuilder.dataHash(nftInfo)
+        ]);
+        return { ...score, sources: [sourceHash] };
+      })
+    );
     return results;
-  }, "divineHandler");
+  };
 };
 
 // src/Plugin.ts
 import { NftSchema } from "@xyo-network/crypto-nft-payload-plugin";
 import { PayloadSetSchema } from "@xyo-network/payload-model";
 import { createPayloadSetDivinerPlugin } from "@xyo-network/payloadset-plugin";
-var NftScoreDivinerPlugin = /* @__PURE__ */ __name(() => createPayloadSetDivinerPlugin({
-  required: {
-    [NftSchema]: 1
-  },
-  schema: PayloadSetSchema
-}, {
-  diviner: /* @__PURE__ */ __name(async (params) => {
-    const result = await NftScoreDiviner.create(params);
-    return result;
-  }, "diviner")
-}), "NftScoreDivinerPlugin");
+var NftScoreDivinerPlugin = () => createPayloadSetDivinerPlugin(
+  { required: { [NftSchema]: 1 }, schema: PayloadSetSchema },
+  {
+    diviner: async (params) => {
+      const result = await NftScoreDiviner.create(params);
+      return result;
+    }
+  }
+);
 export {
   NftScoreDiviner,
   NftScoreDivinerPlugin,