@xyo-network/crypto-nft-diviner-score-plugin 2.70.0

package/src/lib/rating/criteria/scoring/metadata/name.ts

@@ -0,0 +1,12 @@
+import { NftInfo, OpenSeaNftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+import { incrementTotal, ScaledScore } from '../../../score'
+
+export const scoreNftName = (nft: NftInfo | OpenSeaNftInfo): ScaledScore => {
+  return scoreName(nft.metadata?.name)
+}
+export const scoreName = (name: unknown): ScaledScore => {
+  const score: ScaledScore = [0, 1]
+  if (!name || typeof name !== 'string') return score
+  return incrementTotal(score)
+}

package/src/lib/rating/criteria/scoring/metadata/spec/testHelpers.ts

@@ -0,0 +1,29 @@
+import { PASS, ScaledScore } from '../../../../score'
+
+export const expectMaxPossibleScore = (score: ScaledScore) => {
+  const [total, possible] = score
+  expect(total).toBeNumber()
+  expect(total).toBePositive()
+  expect(possible).toBeNumber()
+  expect(possible).toBePositive()
+  expect(total).toEqual(possible)
+}
+
+export const expectLoweredScore = (score: ScaledScore) => {
+  const [total, possible] = score
+  expect(total).toBeNumber()
+  expect(total).not.toBeNegative()
+  expect(possible).toBeNumber()
+  expect(possible).toBePositive()
+  expect(total).toBeLessThan(possible)
+}
+
+export const expectMiniumScore = (score: ScaledScore) => {
+  const [total] = score
+  expectLoweredScore(score)
+  expect(total).toBe(0)
+}
+
+export const expectNoScore = (score: ScaledScore) => {
+  expect(score).toEqual(PASS)
+}

package/src/lib/rating/criteria/scoring/metadata/youtubeUrl.ts

@@ -0,0 +1,16 @@
+import { NftInfo, OpenSeaNftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+import { incrementTotal, PASS, ScaledScore } from '../../../score'
+import { isSecure, isValidUrl } from './lib'
+
+export const scoreNftYoutubeUrl = (nft: NftInfo | OpenSeaNftInfo): ScaledScore => {
+  return scoreYoutubeUrl(nft?.metadata?.youtube_url)
+}
+export const scoreYoutubeUrl = (youtube_url: unknown): ScaledScore => {
+  if (youtube_url === undefined || youtube_url === null) return PASS
+  const score: ScaledScore = [0, 2]
+  if (typeof youtube_url !== 'string' || !isValidUrl(youtube_url)) return score
+  incrementTotal(score)
+  if (!isSecure(youtube_url)) return score
+  return incrementTotal(score)
+}

package/src/lib/rating/criteria/scoring/supply.ts

@@ -0,0 +1,15 @@
+import { NftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+import { FAIL, PASS, PassFailScoringFunction } from '../../score'
+import { isValidPositiveBigNumber } from './lib'
+
+export const scoreSupply: PassFailScoringFunction = (nft: NftInfo) => {
+  if (!nft.supply) return FAIL
+  if (typeof nft.supply !== 'string') return FAIL
+  try {
+    // Check for positive BigNumber since data type is uint256
+    return isValidPositiveBigNumber(nft.supply) ? PASS : FAIL
+  } catch (_error) {
+    return FAIL
+  }
+}

package/src/lib/rating/criteria/scoring/tokenId.ts

@@ -0,0 +1,21 @@
+import { NftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+import { FAIL, PASS, PassFailScoringFunction } from '../../score'
+import { isValidPositiveBigNumber } from './lib'
+
+/**
+ * Callers SHALL NOT assume that ID numbers have any specific pattern to them, and
+ * MUST treat the ID as a "black box"
+ * @param nft
+ * @returns
+ */
+export const scoreTokenId: PassFailScoringFunction = (nft: NftInfo) => {
+  if (!nft.tokenId) return FAIL
+  if (typeof nft.tokenId !== 'string') return FAIL
+  try {
+    // Check for positive BigNumber since data type is uint256
+    return isValidPositiveBigNumber(nft.tokenId) ? PASS : FAIL
+  } catch (_error) {
+    return FAIL
+  }
+}

package/src/lib/rating/criteria/scoring/type.ts

@@ -0,0 +1,11 @@
+import { NftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+import { FAIL, PASS, PassFailScoringFunction } from '../../score'
+
+export const scoreType: PassFailScoringFunction = (nft: NftInfo) => {
+  if (!nft.type) return FAIL
+  if (typeof nft.type !== 'string') return FAIL
+  const type = nft.type.toUpperCase()
+  if (type !== 'ERC721' && type !== 'ERC1155') return FAIL
+  return PASS
+}

package/src/lib/rating/criteria/scoringCriteria.ts

@@ -0,0 +1,39 @@
+import {
+  evaluateNftAttributes,
+  scoreContractAddress,
+  scoreNftAnimationUrl,
+  scoreNftBackgroundColor,
+  scoreNftDescription,
+  scoreNftExternalUrl,
+  scoreNftImage,
+  scoreNftImageData,
+  scoreNftName,
+  scoreNftYoutubeUrl,
+  scoreSupply,
+  scoreTokenId,
+  scoreType,
+} from './scoring'
+
+const attributesScoringCriteria = {
+  Attributes: { score: evaluateNftAttributes, weight: 1 },
+}
+
+const 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 },
+  ...attributesScoringCriteria,
+}
+
+export const scoringCriteria = {
+  'Contract Address': { score: scoreContractAddress, weight: 1 },
+  Supply: { score: scoreSupply, weight: 1 },
+  'Token Id': { score: scoreTokenId, weight: 1 },
+  Type: { score: scoreType, weight: 1 },
+  ...metadataScoringCriteria,
+}

package/src/lib/rating/index.ts

@@ -0,0 +1,2 @@
+export * from './analyzeNft'
+export * from './score'

package/src/lib/rating/score.ts

@@ -0,0 +1,33 @@
+import { NftInfo } from '@xyo-network/crypto-nft-payload-plugin'
+
+export type PassFailScore = [total: number, possible: 1]
+export const PASS: PassFailScore = [1, 1]
+export const FAIL: PassFailScore = [0, 1]
+export type ScaledScore = [total: number, possible: number]
+export const SKIP: ScaledScore = [0, 0]
+export type Score = ScaledScore | PassFailScore
+
+export type PassFailScoringFunction = (nft: NftInfo) => PassFailScore | Promise<PassFailScore>
+export type ScaledScoringFunction = (nft: NftInfo) => Score | Promise<Score>
+export type ScoringFunction = PassFailScoringFunction | ScaledScoringFunction
+
+export interface WeightedScoringCriteria {
+  score: ScoringFunction
+  weight: number
+}
+
+export const incrementTotal = (score: ScaledScore, by = 1): ScaledScore => {
+  score[0] += by
+  return score
+}
+
+export const incrementPossible = (score: ScaledScore, by = 1): ScaledScore => {
+  score[1] += by
+  return score
+}
+
+export const incrementTotalAndPossible = (score: ScaledScore, totalBy = 1, possibleBy = 1): ScaledScore => {
+  score[0] += totalBy
+  score[1] += possibleBy
+  return score
+}

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["./src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}