@xyo-network/crypto-nft-collection-diviner-score-plugin 2.75.0 → 2.75.3

package/dist/node/lib/rating/criteria/scoring/metadata/metadata.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/metadata.ts"],"sourcesContent":["import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreIndividualAttributes } from './scoreIndividualAttributes'\nimport { scoreTotalAttributes } from './scoreTotalAttributes'\n\nexport const attributeScoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  'Metadata Attributes Individual': { score: scoreIndividualAttributes, weight: 2 },\n  'Metadata Attributes Total': { score: scoreTotalAttributes, weight: 2 },\n}\n\nexport const scoreMetadata: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...attributeScoringCriteria,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,uCAA0C;AAC1C,kCAAqC;AAE9B,MAAM,2BAA0F;AAAA,EACrG,kCAAkC,EAAE,OAAO,4DAA2B,QAAQ,EAAE;AAAA,EAChF,6BAA6B,EAAE,OAAO,kDAAsB,QAAQ,EAAE;AACxE;AAEO,MAAM,gBAA+E;AAAA,EAC1F,GAAG;AACL;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/metadata.ts","../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts","../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"sourcesContent":["import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreIndividualAttributes } from './scoreIndividualAttributes'\nimport { scoreTotalAttributes } from './scoreTotalAttributes'\n\nexport const attributeScoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  'Metadata Attributes Individual': { score: scoreIndividualAttributes, weight: 2 },\n  'Metadata Attributes Total': { score: scoreTotalAttributes, weight: 2 },\n}\n\nexport const scoreMetadata: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...attributeScoringCriteria,\n}\n","import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n","import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,oCAAiC;AAEjC,IAAM,WAAW;AAEV,IAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,aAAO,yCAAU,OAAO,QAAQ;AAClC;;;AClBA,IAAAA,iCAAiC;AAEjC,IAAMC,YAAW;AAKjB,IAAM,YAAY;AAKlB,IAAM,eAAe;AASrB,IAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,IAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,IAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,aAAO,0CAAU,OAAOA,SAAQ;AAClC;;;AF1DO,IAAM,2BAA0F;AAAA,EACrG,kCAAkC,EAAE,OAAO,2BAA2B,QAAQ,EAAE;AAAA,EAChF,6BAA6B,EAAE,OAAO,sBAAsB,QAAQ,EAAE;AACxE;AAEO,IAAM,gBAA+E;AAAA,EAC1F,GAAG;AACL;","names":["import_crypto_nft_score_model","maxScore"]}

package/dist/node/lib/rating/criteria/scoring/metadata/metadata.mjs

@@ -1,10 +1,49 @@
-import { scoreIndividualAttributes } from "./scoreIndividualAttributes";
-import { scoreTotalAttributes } from "./scoreTotalAttributes";
-const attributeScoringCriteria = {
+// src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts
+import { normalize } from "@xyo-network/crypto-nft-score-model";
+var maxScore = 10;
+var scoreIndividualAttributes = (info) => {
+  const { attributes } = info.metrics.metadata;
+  const entries = Object.entries(attributes);
+  if (entries.length === 0)
+    return [0, maxScore];
+  const scores = Object.entries(attributes).map(([_trait, { values }]) => {
+    return Object.entries(values).map(([_traitValue, metrics]) => {
+      const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore);
+      return [rarity, maxScore];
+    });
+  }).flat();
+  const total = scores.reduce(([a, b], [c, d]) => [a + c, b + d], [0, 0]);
+  return normalize(total, maxScore);
+};
+
+// src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts
+import { normalize as normalize2 } from "@xyo-network/crypto-nft-score-model";
+var maxScore2 = 10;
+var defaultMu = 0.15;
+var defaultSigma = 0.1;
+var gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+  const sqrtTwoPi = Math.sqrt(2 * Math.PI);
+  const denominator = sigma * sqrtTwoPi;
+  const power = -0.5 * Math.pow((x - mu) / sigma, 2);
+  return 1 / denominator * Math.exp(power);
+};
+var maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
+var scoreTotalAttributes = (info) => {
+  const { attributes } = info.metrics.metadata;
+  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {
+    return acc * metrics.binomial.p;
+  }, 1);
+  const probabilityDensity = gaussianProbabilityDensity(jointProbability);
+  const score = [probabilityDensity, maxProbabilityDensity];
+  return normalize2(score, maxScore2);
+};
+
+// src/lib/rating/criteria/scoring/metadata/metadata.ts
+var attributeScoringCriteria = {
   "Metadata Attributes Individual": { score: scoreIndividualAttributes, weight: 2 },
   "Metadata Attributes Total": { score: scoreTotalAttributes, weight: 2 }
 };
-const scoreMetadata = {
+var scoreMetadata = {
   ...attributeScoringCriteria
 };
 export {

package/dist/node/lib/rating/criteria/scoring/metadata/metadata.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/metadata.ts"],"sourcesContent":["import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreIndividualAttributes } from './scoreIndividualAttributes'\nimport { scoreTotalAttributes } from './scoreTotalAttributes'\n\nexport const attributeScoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  'Metadata Attributes Individual': { score: scoreIndividualAttributes, weight: 2 },\n  'Metadata Attributes Total': { score: scoreTotalAttributes, weight: 2 },\n}\n\nexport const scoreMetadata: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...attributeScoringCriteria,\n}\n"],"mappings":"AAGA,SAAS,iCAAiC;AAC1C,SAAS,4BAA4B;AAE9B,MAAM,2BAA0F;AAAA,EACrG,kCAAkC,EAAE,OAAO,2BAA2B,QAAQ,EAAE;AAAA,EAChF,6BAA6B,EAAE,OAAO,sBAAsB,QAAQ,EAAE;AACxE;AAEO,MAAM,gBAA+E;AAAA,EAC1F,GAAG;AACL;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts","../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts","../../../../../../../src/lib/rating/criteria/scoring/metadata/metadata.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n","import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n","import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreIndividualAttributes } from './scoreIndividualAttributes'\nimport { scoreTotalAttributes } from './scoreTotalAttributes'\n\nexport const attributeScoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  'Metadata Attributes Individual': { score: scoreIndividualAttributes, weight: 2 },\n  'Metadata Attributes Total': { score: scoreTotalAttributes, weight: 2 },\n}\n\nexport const scoreMetadata: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...attributeScoringCriteria,\n}\n"],"mappings":";AACA,SAAS,iBAAwB;AAEjC,IAAM,WAAW;AAEV,IAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,SAAO,UAAU,OAAO,QAAQ;AAClC;;;AClBA,SAAS,aAAAA,kBAAwB;AAEjC,IAAMC,YAAW;AAKjB,IAAM,YAAY;AAKlB,IAAM,eAAe;AASrB,IAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,IAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,IAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,SAAOD,WAAU,OAAOC,SAAQ;AAClC;;;AC1DO,IAAM,2BAA0F;AAAA,EACrG,kCAAkC,EAAE,OAAO,2BAA2B,QAAQ,EAAE;AAAA,EAChF,6BAA6B,EAAE,OAAO,sBAAsB,QAAQ,EAAE;AACxE;AAEO,IAAM,gBAA+E;AAAA,EAC1F,GAAG;AACL;","names":["normalize","maxScore"]}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.d.cts

@@ -0,0 +1,4 @@
+import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin';
+import { Score } from '@xyo-network/crypto-nft-score-model';
+export declare const scoreIndividualAttributes: (info: NftCollectionAttributeMetrics) => Score;
+//# sourceMappingURL=scoreIndividualAttributes.d.ts.map

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoreIndividualAttributes.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mDAAmD,CAAA;AACjG,OAAO,EAAa,KAAK,EAAE,MAAM,qCAAqC,CAAA;AAItE,eAAO,MAAM,yBAAyB,SAAU,6BAA6B,KAAG,KAc/E,CAAA"}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.js

@@ -16,14 +16,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts
 var scoreIndividualAttributes_exports = {};
 __export(scoreIndividualAttributes_exports, {
   scoreIndividualAttributes: () => scoreIndividualAttributes
 });
 module.exports = __toCommonJS(scoreIndividualAttributes_exports);
 var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
-const maxScore = 10;
-const scoreIndividualAttributes = (info) => {
+var maxScore = 10;
+var scoreIndividualAttributes = (info) => {
   const { attributes } = info.metrics.metadata;
   const entries = Object.entries(attributes);
   if (entries.length === 0)

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAEjC,MAAM,WAAW;AAEV,MAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAEjC,IAAM,WAAW;AAEV,IAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.mjs

@@ -1,6 +1,7 @@
+// src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts
 import { normalize } from "@xyo-network/crypto-nft-score-model";
-const maxScore = 10;
-const scoreIndividualAttributes = (info) => {
+var maxScore = 10;
+var scoreIndividualAttributes = (info) => {
   const { attributes } = info.metrics.metadata;
   const entries = Object.entries(attributes);
   if (entries.length === 0)

package/dist/node/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n"],"mappings":"AACA,SAAS,iBAAwB;AAEjC,MAAM,WAAW;AAEV,MAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n"],"mappings":";AACA,SAAS,iBAAwB;AAEjC,IAAM,WAAW;AAEV,IAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.d.cts

@@ -0,0 +1,24 @@
+import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin';
+import { Score } from '@xyo-network/crypto-nft-score-model';
+/**
+ * We're working on some assumptions here:
+ *
+ * - If you have a 100% chance of getting a trait, everyone get's a trophy
+ * - If you have a 50% chance of getting a trait, it's not rare
+ * - If you have a 0% chance of getting a trait, it's not fun
+ *
+ * So we're looking for something Pareto-ish (somewhere between
+ * 80/20 or 90/10) as that's a good & sustainable model for the
+ * distribution of many traits in real life.
+ * However, we also don't want to maximally reward collections
+ * that have a lot of single attributes distributed uniformly
+ * (basically a 0% trait probably) as that's perfectly entropic
+ * but not very interesting (some overlap is desirable).
+ * So we're using a Gaussian distribution to model the
+ * probability density of the joint probability of all traits
+ * centered around 15%.
+ * @param info
+ * @returns
+ */
+export declare const scoreTotalAttributes: (info: NftCollectionAttributeMetrics) => Score;
+//# sourceMappingURL=scoreTotalAttributes.d.ts.map

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoreTotalAttributes.d.ts","sourceRoot":"","sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mDAAmD,CAAA;AACjG,OAAO,EAAa,KAAK,EAAE,MAAM,qCAAqC,CAAA;AAiCtE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,SAAU,6BAA6B,KAAG,KAU1E,CAAA"}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.js

@@ -16,23 +16,25 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts
 var scoreTotalAttributes_exports = {};
 __export(scoreTotalAttributes_exports, {
   scoreTotalAttributes: () => scoreTotalAttributes
 });
 module.exports = __toCommonJS(scoreTotalAttributes_exports);
 var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
-const maxScore = 10;
-const defaultMu = 0.15;
-const defaultSigma = 0.1;
-const gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+var maxScore = 10;
+var defaultMu = 0.15;
+var defaultSigma = 0.1;
+var gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
   const sqrtTwoPi = Math.sqrt(2 * Math.PI);
   const denominator = sigma * sqrtTwoPi;
   const power = -0.5 * Math.pow((x - mu) / sigma, 2);
   return 1 / denominator * Math.exp(power);
 };
-const maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
-const scoreTotalAttributes = (info) => {
+var maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
+var scoreTotalAttributes = (info) => {
   const { attributes } = info.metrics.metadata;
   const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {
     return acc * metrics.binomial.p;

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAEjC,MAAM,WAAW;AAKjB,MAAM,YAAY;AAKlB,MAAM,eAAe;AASrB,MAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,MAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,MAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAEjC,IAAM,WAAW;AAKjB,IAAM,YAAY;AAKlB,IAAM,eAAe;AASrB,IAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,IAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,IAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.mjs

@@ -1,15 +1,16 @@
+// src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts
 import { normalize } from "@xyo-network/crypto-nft-score-model";
-const maxScore = 10;
-const defaultMu = 0.15;
-const defaultSigma = 0.1;
-const gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+var maxScore = 10;
+var defaultMu = 0.15;
+var defaultSigma = 0.1;
+var gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
   const sqrtTwoPi = Math.sqrt(2 * Math.PI);
   const denominator = sigma * sqrtTwoPi;
   const power = -0.5 * Math.pow((x - mu) / sigma, 2);
   return 1 / denominator * Math.exp(power);
 };
-const maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
-const scoreTotalAttributes = (info) => {
+var maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
+var scoreTotalAttributes = (info) => {
   const { attributes } = info.metrics.metadata;
   const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {
     return acc * metrics.binomial.p;

package/dist/node/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":"AACA,SAAS,iBAAwB;AAEjC,MAAM,WAAW;AAKjB,MAAM,YAAY;AAKlB,MAAM,eAAe;AASrB,MAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,MAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,MAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts"],"sourcesContent":["import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";AACA,SAAS,iBAAwB;AAEjC,IAAM,WAAW;AAKjB,IAAM,YAAY;AAKlB,IAAM,eAAe;AASrB,IAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,IAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,IAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/criteria/scoring/total.d.cts

@@ -0,0 +1,16 @@
+import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin';
+import { Score } from '@xyo-network/crypto-nft-score-model';
+/**
+ * We're working on some assumptions here:
+ * - If there's < 1000 NFTs in your collection it starts becoming too niche
+ * - If there's > 20,000 NFTs in your collection it starts becoming too broad
+ * So there's a sweet spot somewhere between 2000 and 10,000
+ * where a collection has enough NFTs to be interesting, but
+ * not so many that it's teetering on a diluted money grab.
+ * To model that we're using a log-normal distribution optimized
+ * to maximally reward collections in the aforementioned range
+ * @param nft
+ * @returns
+ */
+export declare const scoreTotal: (nft: NftCollectionCount) => Score;
+//# sourceMappingURL=total.d.ts.map

package/dist/node/lib/rating/criteria/scoring/total.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"total.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/rating/criteria/scoring/total.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAA;AACtF,OAAO,EAAa,KAAK,EAAE,MAAM,qCAAqC,CAAA;AA+BtE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,QAAS,kBAAkB,KAAG,KAIpD,CAAA"}

package/dist/node/lib/rating/criteria/scoring/total.js

@@ -16,25 +16,27 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/rating/criteria/scoring/total.ts
 var total_exports = {};
 __export(total_exports, {
   scoreTotal: () => scoreTotal
 });
 module.exports = __toCommonJS(total_exports);
 var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
-const median = 810308398217352e-7;
-const defaultMu = Math.log(median);
-const defaultSigma = 3;
-const mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2));
-const logNormalProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+var median = 810308398217352e-7;
+var defaultMu = Math.log(median);
+var defaultSigma = 3;
+var mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2));
+var logNormalProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
   if (x <= 0)
     return 0;
   const logX = Math.log(x);
   return 1 / (x * sigma * Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2));
 };
-const maxProbabilityDensity = logNormalProbabilityDensity(mode);
-const maxScore = 10;
-const scoreTotal = (nft) => {
+var maxProbabilityDensity = logNormalProbabilityDensity(mode);
+var maxScore = 10;
+var scoreTotal = (nft) => {
   const density = logNormalProbabilityDensity(nft.total);
   const score = [density, maxProbabilityDensity];
   return (0, import_crypto_nft_score_model.normalize)(score, maxScore);

package/dist/node/lib/rating/criteria/scoring/total.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/lib/rating/criteria/scoring/total.ts"],"sourcesContent":["import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\n/**\n * This \"magic\" value was obtained using Solver in Excel\n * to find the median, with mu/sigma fixed, which maximizes\n * the distribution (the mode for lognormal) at 10,000\n */\nconst median = 81030839.8217352\nconst defaultMu = Math.log(median)\nconst defaultSigma = 3\nconst mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2))\n/**\n * Calculates the log-normal probability density\n * @param x the value at which you want to calculate the probability density\n * @param mu mean of the associated normal distribution\n * @param sigma standard deviation of the associated normal distribution\n * @returns\n */\nconst logNormalProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  if (x <= 0) return 0\n  const logX = Math.log(x)\n  return (1 / (x * sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2))\n}\n\n/**\n * For a lognormal distribution, the peak of the distribution is the mode\n */\nconst maxProbabilityDensity = logNormalProbabilityDensity(mode)\n\nconst maxScore = 10\n\n/**\n * We're working on some assumptions here:\n * - If there's < 1000 NFTs in your collection it starts becoming too niche\n * - If there's > 20,000 NFTs in your collection it starts becoming too broad\n * So there's a sweet spot somewhere between 2000 and 10,000\n * where a collection has enough NFTs to be interesting, but\n * not so many that it's teetering on a diluted money grab.\n * To model that we're using a log-normal distribution optimized\n * to maximally reward collections in the aforementioned range\n * @param nft\n * @returns\n */\nexport const scoreTotal = (nft: NftCollectionCount): Score => {\n  const density = logNormalProbabilityDensity(nft.total)\n  const score: Score = [density, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAOjC,MAAM,SAAS;AACf,MAAM,YAAY,KAAK,IAAI,MAAM;AACjC,MAAM,eAAe;AACrB,MAAM,OAAO,KAAK,IAAI,YAAY,KAAK,IAAI,cAAc,CAAC,CAAC;AAQ3D,MAAM,8BAA8B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC/G,MAAI,KAAK;AAAG,WAAO;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,SAAQ,KAAK,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,KAAM,KAAK,IAAI,OAAO,KAAK,KAAK,OAAO,MAAM,OAAO,CAAC,CAAC;AACtG;AAKA,MAAM,wBAAwB,4BAA4B,IAAI;AAE9D,MAAM,WAAW;AAcV,MAAM,aAAa,CAAC,QAAmC;AAC5D,QAAM,UAAU,4BAA4B,IAAI,KAAK;AACrD,QAAM,QAAe,CAAC,SAAS,qBAAqB;AACpD,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../src/lib/rating/criteria/scoring/total.ts"],"sourcesContent":["import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\n/**\n * This \"magic\" value was obtained using Solver in Excel\n * to find the median, with mu/sigma fixed, which maximizes\n * the distribution (the mode for lognormal) at 10,000\n */\nconst median = 81030839.8217352\nconst defaultMu = Math.log(median)\nconst defaultSigma = 3\nconst mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2))\n/**\n * Calculates the log-normal probability density\n * @param x the value at which you want to calculate the probability density\n * @param mu mean of the associated normal distribution\n * @param sigma standard deviation of the associated normal distribution\n * @returns\n */\nconst logNormalProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  if (x <= 0) return 0\n  const logX = Math.log(x)\n  return (1 / (x * sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2))\n}\n\n/**\n * For a lognormal distribution, the peak of the distribution is the mode\n */\nconst maxProbabilityDensity = logNormalProbabilityDensity(mode)\n\nconst maxScore = 10\n\n/**\n * We're working on some assumptions here:\n * - If there's < 1000 NFTs in your collection it starts becoming too niche\n * - If there's > 20,000 NFTs in your collection it starts becoming too broad\n * So there's a sweet spot somewhere between 2000 and 10,000\n * where a collection has enough NFTs to be interesting, but\n * not so many that it's teetering on a diluted money grab.\n * To model that we're using a log-normal distribution optimized\n * to maximally reward collections in the aforementioned range\n * @param nft\n * @returns\n */\nexport const scoreTotal = (nft: NftCollectionCount): Score => {\n  const density = logNormalProbabilityDensity(nft.total)\n  const score: Score = [density, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,oCAAiC;AAOjC,IAAM,SAAS;AACf,IAAM,YAAY,KAAK,IAAI,MAAM;AACjC,IAAM,eAAe;AACrB,IAAM,OAAO,KAAK,IAAI,YAAY,KAAK,IAAI,cAAc,CAAC,CAAC;AAQ3D,IAAM,8BAA8B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC/G,MAAI,KAAK;AAAG,WAAO;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,SAAQ,KAAK,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,KAAM,KAAK,IAAI,OAAO,KAAK,KAAK,OAAO,MAAM,OAAO,CAAC,CAAC;AACtG;AAKA,IAAM,wBAAwB,4BAA4B,IAAI;AAE9D,IAAM,WAAW;AAcV,IAAM,aAAa,CAAC,QAAmC;AAC5D,QAAM,UAAU,4BAA4B,IAAI,KAAK;AACrD,QAAM,QAAe,CAAC,SAAS,qBAAqB;AACpD,aAAO,yCAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/criteria/scoring/total.mjs

@@ -1,17 +1,18 @@
+// src/lib/rating/criteria/scoring/total.ts
 import { normalize } from "@xyo-network/crypto-nft-score-model";
-const median = 810308398217352e-7;
-const defaultMu = Math.log(median);
-const defaultSigma = 3;
-const mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2));
-const logNormalProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+var median = 810308398217352e-7;
+var defaultMu = Math.log(median);
+var defaultSigma = 3;
+var mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2));
+var logNormalProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
   if (x <= 0)
     return 0;
   const logX = Math.log(x);
   return 1 / (x * sigma * Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2));
 };
-const maxProbabilityDensity = logNormalProbabilityDensity(mode);
-const maxScore = 10;
-const scoreTotal = (nft) => {
+var maxProbabilityDensity = logNormalProbabilityDensity(mode);
+var maxScore = 10;
+var scoreTotal = (nft) => {
   const density = logNormalProbabilityDensity(nft.total);
   const score = [density, maxProbabilityDensity];
   return normalize(score, maxScore);

package/dist/node/lib/rating/criteria/scoring/total.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../src/lib/rating/criteria/scoring/total.ts"],"sourcesContent":["import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\n/**\n * This \"magic\" value was obtained using Solver in Excel\n * to find the median, with mu/sigma fixed, which maximizes\n * the distribution (the mode for lognormal) at 10,000\n */\nconst median = 81030839.8217352\nconst defaultMu = Math.log(median)\nconst defaultSigma = 3\nconst mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2))\n/**\n * Calculates the log-normal probability density\n * @param x the value at which you want to calculate the probability density\n * @param mu mean of the associated normal distribution\n * @param sigma standard deviation of the associated normal distribution\n * @returns\n */\nconst logNormalProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  if (x <= 0) return 0\n  const logX = Math.log(x)\n  return (1 / (x * sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2))\n}\n\n/**\n * For a lognormal distribution, the peak of the distribution is the mode\n */\nconst maxProbabilityDensity = logNormalProbabilityDensity(mode)\n\nconst maxScore = 10\n\n/**\n * We're working on some assumptions here:\n * - If there's < 1000 NFTs in your collection it starts becoming too niche\n * - If there's > 20,000 NFTs in your collection it starts becoming too broad\n * So there's a sweet spot somewhere between 2000 and 10,000\n * where a collection has enough NFTs to be interesting, but\n * not so many that it's teetering on a diluted money grab.\n * To model that we're using a log-normal distribution optimized\n * to maximally reward collections in the aforementioned range\n * @param nft\n * @returns\n */\nexport const scoreTotal = (nft: NftCollectionCount): Score => {\n  const density = logNormalProbabilityDensity(nft.total)\n  const score: Score = [density, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":"AACA,SAAS,iBAAwB;AAOjC,MAAM,SAAS;AACf,MAAM,YAAY,KAAK,IAAI,MAAM;AACjC,MAAM,eAAe;AACrB,MAAM,OAAO,KAAK,IAAI,YAAY,KAAK,IAAI,cAAc,CAAC,CAAC;AAQ3D,MAAM,8BAA8B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC/G,MAAI,KAAK;AAAG,WAAO;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,SAAQ,KAAK,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,KAAM,KAAK,IAAI,OAAO,KAAK,KAAK,OAAO,MAAM,OAAO,CAAC,CAAC;AACtG;AAKA,MAAM,wBAAwB,4BAA4B,IAAI;AAE9D,MAAM,WAAW;AAcV,MAAM,aAAa,CAAC,QAAmC;AAC5D,QAAM,UAAU,4BAA4B,IAAI,KAAK;AACrD,QAAM,QAAe,CAAC,SAAS,qBAAqB;AACpD,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}
+{"version":3,"sources":["../../../../../../src/lib/rating/criteria/scoring/total.ts"],"sourcesContent":["import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\n/**\n * This \"magic\" value was obtained using Solver in Excel\n * to find the median, with mu/sigma fixed, which maximizes\n * the distribution (the mode for lognormal) at 10,000\n */\nconst median = 81030839.8217352\nconst defaultMu = Math.log(median)\nconst defaultSigma = 3\nconst mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2))\n/**\n * Calculates the log-normal probability density\n * @param x the value at which you want to calculate the probability density\n * @param mu mean of the associated normal distribution\n * @param sigma standard deviation of the associated normal distribution\n * @returns\n */\nconst logNormalProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  if (x <= 0) return 0\n  const logX = Math.log(x)\n  return (1 / (x * sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2))\n}\n\n/**\n * For a lognormal distribution, the peak of the distribution is the mode\n */\nconst maxProbabilityDensity = logNormalProbabilityDensity(mode)\n\nconst maxScore = 10\n\n/**\n * We're working on some assumptions here:\n * - If there's < 1000 NFTs in your collection it starts becoming too niche\n * - If there's > 20,000 NFTs in your collection it starts becoming too broad\n * So there's a sweet spot somewhere between 2000 and 10,000\n * where a collection has enough NFTs to be interesting, but\n * not so many that it's teetering on a diluted money grab.\n * To model that we're using a log-normal distribution optimized\n * to maximally reward collections in the aforementioned range\n * @param nft\n * @returns\n */\nexport const scoreTotal = (nft: NftCollectionCount): Score => {\n  const density = logNormalProbabilityDensity(nft.total)\n  const score: Score = [density, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n"],"mappings":";AACA,SAAS,iBAAwB;AAOjC,IAAM,SAAS;AACf,IAAM,YAAY,KAAK,IAAI,MAAM;AACjC,IAAM,eAAe;AACrB,IAAM,OAAO,KAAK,IAAI,YAAY,KAAK,IAAI,cAAc,CAAC,CAAC;AAQ3D,IAAM,8BAA8B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC/G,MAAI,KAAK;AAAG,WAAO;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,SAAQ,KAAK,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,KAAM,KAAK,IAAI,OAAO,KAAK,KAAK,OAAO,MAAM,OAAO,CAAC,CAAC;AACtG;AAKA,IAAM,wBAAwB,4BAA4B,IAAI;AAE9D,IAAM,WAAW;AAcV,IAAM,aAAa,CAAC,QAAmC;AAC5D,QAAM,UAAU,4BAA4B,IAAI,KAAK;AACrD,QAAM,QAAe,CAAC,SAAS,qBAAqB;AACpD,SAAO,UAAU,OAAO,QAAQ;AAClC;","names":[]}

package/dist/node/lib/rating/index.d.cts

@@ -0,0 +1,2 @@
+export * from './analyzeNftCollection';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/lib/rating/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/rating/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}

package/dist/node/lib/rating/index.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,13 +15,105 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/rating/index.ts
 var rating_exports = {};
+__export(rating_exports, {
+  analyzeNftCollection: () => analyzeNftCollection
+});
 module.exports = __toCommonJS(rating_exports);
-__reExport(rating_exports, require("./analyzeNftCollection"), module.exports);
+
+// src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts
+var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
+var maxScore = 10;
+var scoreIndividualAttributes = (info) => {
+  const { attributes } = info.metrics.metadata;
+  const entries = Object.entries(attributes);
+  if (entries.length === 0)
+    return [0, maxScore];
+  const scores = Object.entries(attributes).map(([_trait, { values }]) => {
+    return Object.entries(values).map(([_traitValue, metrics]) => {
+      const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore);
+      return [rarity, maxScore];
+    });
+  }).flat();
+  const total = scores.reduce(([a, b], [c, d]) => [a + c, b + d], [0, 0]);
+  return (0, import_crypto_nft_score_model.normalize)(total, maxScore);
+};
+
+// src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts
+var import_crypto_nft_score_model2 = require("@xyo-network/crypto-nft-score-model");
+var maxScore2 = 10;
+var defaultMu = 0.15;
+var defaultSigma = 0.1;
+var gaussianProbabilityDensity = (x, mu = defaultMu, sigma = defaultSigma) => {
+  const sqrtTwoPi = Math.sqrt(2 * Math.PI);
+  const denominator = sigma * sqrtTwoPi;
+  const power = -0.5 * Math.pow((x - mu) / sigma, 2);
+  return 1 / denominator * Math.exp(power);
+};
+var maxProbabilityDensity = gaussianProbabilityDensity(defaultMu);
+var scoreTotalAttributes = (info) => {
+  const { attributes } = info.metrics.metadata;
+  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {
+    return acc * metrics.binomial.p;
+  }, 1);
+  const probabilityDensity = gaussianProbabilityDensity(jointProbability);
+  const score = [probabilityDensity, maxProbabilityDensity];
+  return (0, import_crypto_nft_score_model2.normalize)(score, maxScore2);
+};
+
+// src/lib/rating/criteria/scoring/metadata/metadata.ts
+var attributeScoringCriteria = {
+  "Metadata Attributes Individual": { score: scoreIndividualAttributes, weight: 2 },
+  "Metadata Attributes Total": { score: scoreTotalAttributes, weight: 2 }
+};
+var scoreMetadata = {
+  ...attributeScoringCriteria
+};
+
+// src/lib/rating/criteria/scoring/total.ts
+var import_crypto_nft_score_model3 = require("@xyo-network/crypto-nft-score-model");
+var median = 810308398217352e-7;
+var defaultMu2 = Math.log(median);
+var defaultSigma2 = 3;
+var mode = Math.exp(defaultMu2 - Math.pow(defaultSigma2, 2));
+var logNormalProbabilityDensity = (x, mu = defaultMu2, sigma = defaultSigma2) => {
+  if (x <= 0)
+    return 0;
+  const logX = Math.log(x);
+  return 1 / (x * sigma * Math.sqrt(2 * Math.PI)) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2));
+};
+var maxProbabilityDensity2 = logNormalProbabilityDensity(mode);
+var maxScore3 = 10;
+var scoreTotal = (nft) => {
+  const density = logNormalProbabilityDensity(nft.total);
+  const score = [density, maxProbabilityDensity2];
+  return (0, import_crypto_nft_score_model3.normalize)(score, maxScore3);
+};
+
+// src/lib/rating/criteria/index.ts
+var scoringCriteria = {
+  ...scoreMetadata,
+  Total: { score: scoreTotal, weight: 2 }
+};
+
+// src/lib/rating/analyzeNftCollection.ts
+var analyzeNftCollection = 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;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./analyzeNftCollection")
+  analyzeNftCollection
 });
 //# sourceMappingURL=index.js.map

package/dist/node/lib/rating/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/rating/index.ts"],"sourcesContent":["export * from './analyzeNftCollection'\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,2BAAc,mCAAd;","names":[]}
+{"version":3,"sources":["../../../../src/lib/rating/index.ts","../../../../src/lib/rating/criteria/scoring/metadata/scoreIndividualAttributes.ts","../../../../src/lib/rating/criteria/scoring/metadata/scoreTotalAttributes.ts","../../../../src/lib/rating/criteria/scoring/metadata/metadata.ts","../../../../src/lib/rating/criteria/scoring/total.ts","../../../../src/lib/rating/criteria/index.ts","../../../../src/lib/rating/analyzeNftCollection.ts"],"sourcesContent":["export * from './analyzeNftCollection'\n","import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\nexport const scoreIndividualAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  const entries = Object.entries(attributes)\n  if (entries.length === 0) return [0, maxScore]\n  const scores = Object.entries(attributes)\n    .map(([_trait, { values }]) => {\n      return Object.entries(values).map<Score>(([_traitValue, metrics]) => {\n        const rarity = Math.min(Math.round((1 - metrics.binomial.p) * maxScore), maxScore)\n        return [rarity, maxScore]\n      })\n    })\n    .flat()\n  const total = scores.reduce<Score>(([a, b], [c, d]) => [a + c, b + d], [0, 0])\n  return normalize(total, maxScore)\n}\n","import { NftCollectionAttributeMetrics } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\nconst maxScore = 10\n\n/**\n * Mean: What value is the distribution centered around\n */\nconst defaultMu = 0.15\n\n/**\n * Standard Deviation: How spread out is the distribution\n */\nconst defaultSigma = 0.1\n\n/**\n * Calculates the Gaussian probability density\n * @param x\n * @param mu Mean\n * @param sigma Standard Deviation\n * @returns\n */\nconst gaussianProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  const sqrtTwoPi = Math.sqrt(2 * Math.PI)\n  const denominator = sigma * sqrtTwoPi\n  const power = -0.5 * Math.pow((x - mu) / sigma, 2)\n  return (1 / denominator) * Math.exp(power)\n}\n\n/**\n * For a Gaussian distribution, the peak of the distribution is the mean\n */\nconst maxProbabilityDensity = gaussianProbabilityDensity(defaultMu)\n\n/**\n * We're working on some assumptions here:\n *\n * - If you have a 100% chance of getting a trait, everyone get's a trophy\n * - If you have a 50% chance of getting a trait, it's not rare\n * - If you have a 0% chance of getting a trait, it's not fun\n *\n * So we're looking for something Pareto-ish (somewhere between\n * 80/20 or 90/10) as that's a good & sustainable model for the\n * distribution of many traits in real life.\n * However, we also don't want to maximally reward collections\n * that have a lot of single attributes distributed uniformly\n * (basically a 0% trait probably) as that's perfectly entropic\n * but not very interesting (some overlap is desirable).\n * So we're using a Gaussian distribution to model the\n * probability density of the joint probability of all traits\n * centered around 15%.\n * @param info\n * @returns\n */\nexport const scoreTotalAttributes = (info: NftCollectionAttributeMetrics): Score => {\n  const { attributes } = info.metrics.metadata\n  // This has somewhat of a filtering function by causing anything with 100% probability to\n  // add no value to the end score\n  const jointProbability = Object.entries(attributes).reduce((acc, [_trait, { metrics }]) => {\n    return acc * metrics.binomial.p\n  }, 1)\n  const probabilityDensity = gaussianProbabilityDensity(jointProbability)\n  const score: Score = [probabilityDensity, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n","import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreIndividualAttributes } from './scoreIndividualAttributes'\nimport { scoreTotalAttributes } from './scoreTotalAttributes'\n\nexport const attributeScoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  'Metadata Attributes Individual': { score: scoreIndividualAttributes, weight: 2 },\n  'Metadata Attributes Total': { score: scoreTotalAttributes, weight: 2 },\n}\n\nexport const scoreMetadata: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...attributeScoringCriteria,\n}\n","import { NftCollectionCount } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { normalize, Score } from '@xyo-network/crypto-nft-score-model'\n\n/**\n * This \"magic\" value was obtained using Solver in Excel\n * to find the median, with mu/sigma fixed, which maximizes\n * the distribution (the mode for lognormal) at 10,000\n */\nconst median = 81030839.8217352\nconst defaultMu = Math.log(median)\nconst defaultSigma = 3\nconst mode = Math.exp(defaultMu - Math.pow(defaultSigma, 2))\n/**\n * Calculates the log-normal probability density\n * @param x the value at which you want to calculate the probability density\n * @param mu mean of the associated normal distribution\n * @param sigma standard deviation of the associated normal distribution\n * @returns\n */\nconst logNormalProbabilityDensity = (x: number, mu: number = defaultMu, sigma: number = defaultSigma): number => {\n  if (x <= 0) return 0\n  const logX = Math.log(x)\n  return (1 / (x * sigma * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * Math.pow((logX - mu) / sigma, 2))\n}\n\n/**\n * For a lognormal distribution, the peak of the distribution is the mode\n */\nconst maxProbabilityDensity = logNormalProbabilityDensity(mode)\n\nconst maxScore = 10\n\n/**\n * We're working on some assumptions here:\n * - If there's < 1000 NFTs in your collection it starts becoming too niche\n * - If there's > 20,000 NFTs in your collection it starts becoming too broad\n * So there's a sweet spot somewhere between 2000 and 10,000\n * where a collection has enough NFTs to be interesting, but\n * not so many that it's teetering on a diluted money grab.\n * To model that we're using a log-normal distribution optimized\n * to maximally reward collections in the aforementioned range\n * @param nft\n * @returns\n */\nexport const scoreTotal = (nft: NftCollectionCount): Score => {\n  const density = logNormalProbabilityDensity(nft.total)\n  const score: Score = [density, maxProbabilityDensity]\n  return normalize(score, maxScore)\n}\n","import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { WeightedScoringCriteria } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoreMetadata, scoreTotal } from './scoring'\n\nexport const scoringCriteria: { [key: string]: WeightedScoringCriteria<NftCollectionInfo> } = {\n  ...scoreMetadata,\n  Total: { score: scoreTotal, weight: 2 },\n}\n","import { NftCollectionInfo } from '@xyo-network/crypto-nft-collection-payload-plugin'\nimport { Score } from '@xyo-network/crypto-nft-score-model'\n\nimport { scoringCriteria } from './criteria'\n\nexport type ScoringCriteriaKey = keyof typeof scoringCriteria & PropertyKey\n\nexport type NftCollectionAnalysis = {\n  [key in ScoringCriteriaKey]: Score\n}\n\nexport const analyzeNftCollection = async (\n  /**\n   * The NFT to evaluate\n   */\n  nft: NftCollectionInfo,\n): Promise<NftCollectionAnalysis> => {\n  const result = Object.fromEntries(\n    await Promise.all(\n      Object.entries(scoringCriteria).map(async ([key, { score, weight }]) => {\n        const rawScore = await score(nft)\n        const weighted = rawScore.map((v) => v * weight) as Score\n        return [key, weighted] as const\n      }),\n    ),\n  ) as NftCollectionAnalysis\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACCA,oCAAiC;AAEjC,IAAM,WAAW;AAEV,IAAM,4BAA4B,CAAC,SAA+C;AACvF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AACpC,QAAM,UAAU,OAAO,QAAQ,UAAU;AACzC,MAAI,QAAQ,WAAW;AAAG,WAAO,CAAC,GAAG,QAAQ;AAC7C,QAAM,SAAS,OAAO,QAAQ,UAAU,EACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM;AAC7B,WAAO,OAAO,QAAQ,MAAM,EAAE,IAAW,CAAC,CAAC,aAAa,OAAO,MAAM;AACnE,YAAM,SAAS,KAAK,IAAI,KAAK,OAAO,IAAI,QAAQ,SAAS,KAAK,QAAQ,GAAG,QAAQ;AACjF,aAAO,CAAC,QAAQ,QAAQ;AAAA,IAC1B,CAAC;AAAA,EACH,CAAC,EACA,KAAK;AACR,QAAM,QAAQ,OAAO,OAAc,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7E,aAAO,yCAAU,OAAO,QAAQ;AAClC;;;AClBA,IAAAA,iCAAiC;AAEjC,IAAMC,YAAW;AAKjB,IAAM,YAAY;AAKlB,IAAM,eAAe;AASrB,IAAM,6BAA6B,CAAC,GAAW,KAAa,WAAW,QAAgB,iBAAyB;AAC9G,QAAM,YAAY,KAAK,KAAK,IAAI,KAAK,EAAE;AACvC,QAAM,cAAc,QAAQ;AAC5B,QAAM,QAAQ,OAAO,KAAK,KAAK,IAAI,MAAM,OAAO,CAAC;AACjD,SAAQ,IAAI,cAAe,KAAK,IAAI,KAAK;AAC3C;AAKA,IAAM,wBAAwB,2BAA2B,SAAS;AAsB3D,IAAM,uBAAuB,CAAC,SAA+C;AAClF,QAAM,EAAE,WAAW,IAAI,KAAK,QAAQ;AAGpC,QAAM,mBAAmB,OAAO,QAAQ,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM;AACzF,WAAO,MAAM,QAAQ,SAAS;AAAA,EAChC,GAAG,CAAC;AACJ,QAAM,qBAAqB,2BAA2B,gBAAgB;AACtE,QAAM,QAAe,CAAC,oBAAoB,qBAAqB;AAC/D,aAAO,0CAAU,OAAOA,SAAQ;AAClC;;;AC1DO,IAAM,2BAA0F;AAAA,EACrG,kCAAkC,EAAE,OAAO,2BAA2B,QAAQ,EAAE;AAAA,EAChF,6BAA6B,EAAE,OAAO,sBAAsB,QAAQ,EAAE;AACxE;AAEO,IAAM,gBAA+E;AAAA,EAC1F,GAAG;AACL;;;ACZA,IAAAC,iCAAiC;AAOjC,IAAM,SAAS;AACf,IAAMC,aAAY,KAAK,IAAI,MAAM;AACjC,IAAMC,gBAAe;AACrB,IAAM,OAAO,KAAK,IAAID,aAAY,KAAK,IAAIC,eAAc,CAAC,CAAC;AAQ3D,IAAM,8BAA8B,CAAC,GAAW,KAAaD,YAAW,QAAgBC,kBAAyB;AAC/G,MAAI,KAAK;AAAG,WAAO;AACnB,QAAM,OAAO,KAAK,IAAI,CAAC;AACvB,SAAQ,KAAK,IAAI,QAAQ,KAAK,KAAK,IAAI,KAAK,EAAE,KAAM,KAAK,IAAI,OAAO,KAAK,KAAK,OAAO,MAAM,OAAO,CAAC,CAAC;AACtG;AAKA,IAAMC,yBAAwB,4BAA4B,IAAI;AAE9D,IAAMC,YAAW;AAcV,IAAM,aAAa,CAAC,QAAmC;AAC5D,QAAM,UAAU,4BAA4B,IAAI,KAAK;AACrD,QAAM,QAAe,CAAC,SAASD,sBAAqB;AACpD,aAAO,0CAAU,OAAOC,SAAQ;AAClC;;;AC3CO,IAAM,kBAAiF;AAAA,EAC5F,GAAG;AAAA,EACH,OAAO,EAAE,OAAO,YAAY,QAAQ,EAAE;AACxC;;;ACGO,IAAM,uBAAuB,OAIlC,QACmC;AACnC,QAAM,SAAS,OAAO;AAAA,IACpB,MAAM,QAAQ;AAAA,MACZ,OAAO,QAAQ,eAAe,EAAE,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,OAAO,CAAC,MAAM;AACtE,cAAM,WAAW,MAAM,MAAM,GAAG;AAChC,cAAM,WAAW,SAAS,IAAI,CAAC,MAAM,IAAI,MAAM;AAC/C,eAAO,CAAC,KAAK,QAAQ;AAAA,MACvB,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO;AACT;","names":["import_crypto_nft_score_model","maxScore","import_crypto_nft_score_model","defaultMu","defaultSigma","maxProbabilityDensity","maxScore"]}