@xyo-network/payload-plugins 7.0.3 → 7.1.0

package/dist/neutral/crypto-nft-collection.mjs

@@ -0,0 +1,202 @@
+// src/modules/crypto-nft-collection/Diviner/Config.ts
+import { asSchema as asSchema3 } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft-collection/Diviner/Schema.ts
+import { asSchema as asSchema2 } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft-collection/Schema.ts
+import { asSchema } from "@xyo-network/sdk";
+var NftCollectionSchema = asSchema("network.xyo.crypto.nft.collection", true);
+
+// src/modules/crypto-nft-collection/Diviner/Schema.ts
+var NftCollectionScoreSchema = asSchema2(`${NftCollectionSchema}.score`, true);
+
+// src/modules/crypto-nft-collection/Diviner/Config.ts
+var NftCollectionScoreDivinerConfigSchema = asSchema3(`${NftCollectionScoreSchema}.diviner.config`, true);
+
+// src/modules/crypto-nft-collection/Diviner/Payload.ts
+import {
+  HashZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema } from "@xyo-network/sdk";
+import * as z2 from "zod/mini";
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetadata.ts
+import * as z from "zod/mini";
+var TokenTypeZod = z.nullable(z.enum(["ERC721", "ERC1155"]));
+var NftCollectionMetadataZod = z.object({
+  address: z.string(),
+  chainId: z.number(),
+  implementation: z.optional(z.string()),
+  name: z.string(),
+  symbol: z.string(),
+  /** @deprecated use types instead */
+  type: z.optional(TokenTypeZod),
+  types: z.optional(z.array(TokenTypeZod))
+});
+
+// src/modules/crypto-nft-collection/Diviner/Payload.ts
+var NftCollectionAnalysisZod = z2.record(z2.string(), z2.tuple([z2.number(), z2.number()]));
+var NftCollectionScoresZod = z2.object({ scores: NftCollectionAnalysisZod });
+var NftCollectionScoreFieldsZod = z2.object({
+  ...NftCollectionMetadataZod.shape,
+  ...NftCollectionScoresZod.shape,
+  sources: z2.optional(z2.array(HashZod))
+});
+var NftCollectionScoreZod = z2.extend(PayloadZodOfSchema(NftCollectionScoreSchema), { ...NftCollectionScoreFieldsZod.shape });
+var isNftCollectionScore = zodIsFactory(NftCollectionScoreZod);
+var asNftCollectionScore = zodAsFactory(NftCollectionScoreZod, "asNftCollectionScore");
+var toNftCollectionScore = zodToFactory(NftCollectionScoreZod, "toNftCollectionScore");
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionAttributeMetrics.ts
+import * as z6 from "zod/mini";
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftCollectionMetrics.ts
+import * as z5 from "zod/mini";
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftTraitMetrics.ts
+import * as z4 from "zod/mini";
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/BinomialDistributionParameters.ts
+import * as z3 from "zod/mini";
+var BinomialDistributionParametersZod = z3.object({
+  /**
+   * Mean
+   */
+  mean: z3.number(),
+  /**
+   * Success probability
+   */
+  p: z3.number(),
+  /**
+   * Standard deviation
+   */
+  stdDev: z3.number(),
+  /**
+   * Variance
+   */
+  variance: z3.number()
+});
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftTraitMetrics.ts
+var NftTraitMetricsZod = z4.object({
+  binomial: z4.object({ p: BinomialDistributionParametersZod.shape.p }),
+  count: z4.number()
+});
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftCollectionMetrics.ts
+var NftCollectionMetricsZod = z5.object({
+  metadata: z5.object({
+    attributes: z5.record(z5.string(), z5.object({
+      metrics: NftTraitMetricsZod,
+      values: z5.record(z5.string(), NftTraitMetricsZod)
+    }))
+  })
+});
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionAttributeMetrics.ts
+var NftCollectionAttributeMetricsZod = z6.object({ metrics: NftCollectionMetricsZod });
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionCount.ts
+import * as z7 from "zod/mini";
+var NftCollectionCountZod = z7.object({
+  // TODO: Change to count
+  total: z7.number()
+});
+
+// src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionInfoFields.ts
+import * as z8 from "zod/mini";
+var NftCollectionInfoFieldsZod = z8.object({
+  ...NftCollectionCountZod.shape,
+  ...NftCollectionMetadataZod.shape,
+  ...NftCollectionAttributeMetricsZod.shape
+});
+
+// src/modules/crypto-nft-collection/Payload/Payload.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk";
+import * as z9 from "zod/mini";
+var NftCollectionInfoZod = z9.extend(PayloadZodOfSchema2(NftCollectionSchema), { ...NftCollectionInfoFieldsZod.shape });
+var isNftCollectionInfo = zodIsFactory2(NftCollectionInfoZod);
+var asNftCollectionInfo = zodAsFactory2(NftCollectionInfoZod, "asNftCollectionInfo");
+var toNftCollectionInfo = zodToFactory2(NftCollectionInfoZod, "toNftCollectionInfo");
+
+// src/modules/crypto-nft-collection/Plugin.ts
+import { createPayloadPlugin } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft-collection/Template.ts
+var cryptoNftCollectionPayloadTemplate = () => ({ schema: NftCollectionSchema });
+
+// src/modules/crypto-nft-collection/Plugin.ts
+var NftCollectionInfoPayloadPlugin = () => createPayloadPlugin({
+  schema: NftCollectionSchema,
+  template: cryptoNftCollectionPayloadTemplate
+});
+
+// src/modules/crypto-nft-collection/Witness/Query.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema3 } from "@xyo-network/sdk";
+import * as z10 from "zod/mini";
+
+// src/modules/crypto-nft-collection/Witness/Schema.ts
+import { asSchema as asSchema4 } from "@xyo-network/sdk";
+var NftCollectionWitnessConfigSchema = asSchema4(`${NftCollectionSchema}.witness.config`, true);
+var NftCollectionWitnessQuerySchema = asSchema4(`${NftCollectionSchema}.witness.query`, true);
+
+// src/modules/crypto-nft-collection/Witness/Query.ts
+var NftCollectionWitnessQueryZod = z10.extend(PayloadZodOfSchema3(NftCollectionWitnessQuerySchema), {
+  address: z10.optional(z10.string()),
+  chainId: z10.optional(z10.number()),
+  /**
+   * The maximum number of NFTs to sample from the collection
+   * for determining the collection's schema & distribution
+   */
+  maxNfts: z10.optional(z10.number())
+});
+var isNftCollectionWitnessQuery = zodIsFactory3(NftCollectionWitnessQueryZod);
+var asNftCollectionWitnessQuery = zodAsFactory3(NftCollectionWitnessQueryZod, "asNftCollectionWitnessQuery");
+var toNftCollectionWitnessQuery = zodToFactory3(NftCollectionWitnessQueryZod, "toNftCollectionWitnessQuery");
+export {
+  BinomialDistributionParametersZod,
+  NftCollectionAnalysisZod,
+  NftCollectionAttributeMetricsZod,
+  NftCollectionCountZod,
+  NftCollectionInfoFieldsZod,
+  NftCollectionInfoPayloadPlugin,
+  NftCollectionInfoZod,
+  NftCollectionMetadataZod,
+  NftCollectionMetricsZod,
+  NftCollectionSchema,
+  NftCollectionScoreDivinerConfigSchema,
+  NftCollectionScoreFieldsZod,
+  NftCollectionScoreSchema,
+  NftCollectionScoreZod,
+  NftCollectionScoresZod,
+  NftCollectionWitnessConfigSchema,
+  NftCollectionWitnessQuerySchema,
+  NftCollectionWitnessQueryZod,
+  NftTraitMetricsZod,
+  asNftCollectionInfo,
+  asNftCollectionScore,
+  asNftCollectionWitnessQuery,
+  cryptoNftCollectionPayloadTemplate,
+  NftCollectionInfoPayloadPlugin as default,
+  isNftCollectionInfo,
+  isNftCollectionScore,
+  isNftCollectionWitnessQuery,
+  toNftCollectionInfo,
+  toNftCollectionScore,
+  toNftCollectionWitnessQuery
+};
+//# sourceMappingURL=crypto-nft-collection.mjs.map

package/dist/neutral/crypto-nft-collection.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/crypto-nft-collection/Diviner/Config.ts", "../../src/modules/crypto-nft-collection/Diviner/Schema.ts", "../../src/modules/crypto-nft-collection/Schema.ts", "../../src/modules/crypto-nft-collection/Diviner/Payload.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetadata.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionAttributeMetrics.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftCollectionMetrics.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/NftTraitMetrics.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionMetrics/BinomialDistributionParameters.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionCount.ts", "../../src/modules/crypto-nft-collection/Payload/NftCollectionInfo/NftCollectionInfoFields.ts", "../../src/modules/crypto-nft-collection/Payload/Payload.ts", "../../src/modules/crypto-nft-collection/Plugin.ts", "../../src/modules/crypto-nft-collection/Template.ts", "../../src/modules/crypto-nft-collection/Witness/Query.ts", "../../src/modules/crypto-nft-collection/Witness/Schema.ts"],
+  "sourcesContent": ["import type { DivinerConfig } from '@xyo-network/sdk'\nimport { asSchema } from '@xyo-network/sdk'\n\nimport { NftCollectionScoreSchema } from './Schema.ts'\n\nexport type NftCollectionScoreDivinerConfigSchema = typeof NftCollectionScoreDivinerConfigSchema\nexport const NftCollectionScoreDivinerConfigSchema = asSchema(`${NftCollectionScoreSchema}.diviner.config`, true)\n\nexport type NftCollectionScoreDivinerConfig = DivinerConfig<{ schema: NftCollectionScoreDivinerConfigSchema }>\n", "import { asSchema } from '@xyo-network/sdk'\n\nimport { NftCollectionSchema } from '../Schema.ts'\n\nexport type NftCollectionScoreSchema = typeof NftCollectionScoreSchema\nexport const NftCollectionScoreSchema = asSchema(`${NftCollectionSchema}.score`, true)\n", "import { asSchema } from '@xyo-network/sdk'\n\nexport type NftCollectionSchema = typeof NftCollectionSchema\nexport const NftCollectionSchema = asSchema('network.xyo.crypto.nft.collection', true)\n", "import {\n  HashZod, zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport { PayloadZodOfSchema } from '@xyo-network/sdk'\nimport * as z from 'zod/mini'\n\nimport { NftCollectionMetadataZod } from '../Payload/NftCollectionInfo/NftCollectionMetadata.ts'\nimport { NftCollectionScoreSchema } from './Schema.ts'\n\nexport const NftCollectionAnalysisZod = z.record(z.string(), z.tuple([z.number(), z.number()]))\n\nexport type NftCollectionAnalysis = z.infer<typeof NftCollectionAnalysisZod>\n\nexport const NftCollectionScoresZod = z.object({ scores: NftCollectionAnalysisZod })\n\nexport type NftCollectionScores = z.infer<typeof NftCollectionScoresZod>\n\nexport const NftCollectionScoreFieldsZod = z.object({\n  ...NftCollectionMetadataZod.shape,\n  ...NftCollectionScoresZod.shape,\n  sources: z.optional(z.array(HashZod)),\n})\n\nexport type NftCollectionScoreFields = z.infer<typeof NftCollectionScoreFieldsZod>\n\nexport const NftCollectionScoreZod = z.extend(PayloadZodOfSchema(NftCollectionScoreSchema), { ...NftCollectionScoreFieldsZod.shape })\n\nexport type NftCollectionScore = z.infer<typeof NftCollectionScoreZod>\n\nexport const isNftCollectionScore = zodIsFactory(NftCollectionScoreZod)\nexport const asNftCollectionScore = zodAsFactory(NftCollectionScoreZod, 'asNftCollectionScore')\nexport const toNftCollectionScore = zodToFactory(NftCollectionScoreZod, 'toNftCollectionScore')\n", "import * as z from 'zod/mini'\n\n/**\n * TokenType as modeled by `@xyo-network/crypto-nft-payload-plugin`\n */\nconst TokenTypeZod = z.nullable(z.enum(['ERC721', 'ERC1155']))\n\nexport const NftCollectionMetadataZod = z.object({\n  address: z.string(),\n  chainId: z.number(),\n  implementation: z.optional(z.string()),\n  name: z.string(),\n  symbol: z.string(),\n  /** @deprecated use types instead */\n  type: z.optional(TokenTypeZod),\n  types: z.optional(z.array(TokenTypeZod)),\n})\n\nexport type NftCollectionMetadata = z.infer<typeof NftCollectionMetadataZod>\n", "import * as z from 'zod/mini'\n\nimport { NftCollectionMetricsZod } from './NftCollectionMetrics/NftCollectionMetrics.ts'\n\nexport const NftCollectionAttributeMetricsZod = z.object({ metrics: NftCollectionMetricsZod })\n\nexport type NftCollectionAttributeMetrics = z.infer<typeof NftCollectionAttributeMetricsZod>\n", "import * as z from 'zod/mini'\n\nimport { NftTraitMetricsZod } from './NftTraitMetrics.ts'\n\nexport const NftCollectionMetricsZod = z.object({\n  metadata: z.object({\n    attributes: z.record(z.string(), z.object({\n      metrics: NftTraitMetricsZod,\n      values: z.record(z.string(), NftTraitMetricsZod),\n    })),\n  }),\n})\n\nexport type NftCollectionMetrics = z.infer<typeof NftCollectionMetricsZod>\n", "import * as z from 'zod/mini'\n\nimport { BinomialDistributionParametersZod } from './BinomialDistributionParameters.ts'\n\nexport const NftTraitMetricsZod = z.object({\n  binomial: z.object({ p: BinomialDistributionParametersZod.shape.p }),\n  count: z.number(),\n})\n\nexport type NftTraitMetrics = z.infer<typeof NftTraitMetricsZod>\n", "import * as z from 'zod/mini'\n\n/**\n * Parameters of a binomial distribution\n */\nexport const BinomialDistributionParametersZod = z.object({\n  /**\n   * Mean\n   */\n  mean: z.number(),\n  /**\n   * Success probability\n   */\n  p: z.number(),\n  /**\n   * Standard deviation\n   */\n  stdDev: z.number(),\n  /**\n   * Variance\n   */\n  variance: z.number(),\n})\n\n/**\n * Parameters of a binomial distribution\n */\nexport type BinomialDistributionParameters = z.infer<typeof BinomialDistributionParametersZod>\n", "import * as z from 'zod/mini'\n\nexport const NftCollectionCountZod = z.object({\n  // TODO: Change to count\n  total: z.number(),\n})\n\nexport type NftCollectionCount = z.infer<typeof NftCollectionCountZod>\n", "import * as z from 'zod/mini'\n\nimport { NftCollectionAttributeMetricsZod } from './NftCollectionAttributeMetrics.ts'\nimport { NftCollectionCountZod } from './NftCollectionCount.ts'\nimport { NftCollectionMetadataZod } from './NftCollectionMetadata.ts'\n\nexport const NftCollectionInfoFieldsZod = z.object({\n  ...NftCollectionCountZod.shape,\n  ...NftCollectionMetadataZod.shape,\n  ...NftCollectionAttributeMetricsZod.shape,\n})\n\nexport type NftCollectionInfoFields = z.infer<typeof NftCollectionInfoFieldsZod>\n", "import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport { PayloadZodOfSchema } from '@xyo-network/sdk'\nimport * as z from 'zod/mini'\n\nimport { NftCollectionSchema } from '../Schema.ts'\nimport { NftCollectionInfoFieldsZod } from './NftCollectionInfo/NftCollectionInfoFields.ts'\n\nexport const NftCollectionInfoZod = z.extend(PayloadZodOfSchema(NftCollectionSchema), { ...NftCollectionInfoFieldsZod.shape })\n\nexport type NftCollectionInfo = z.infer<typeof NftCollectionInfoZod>\n\nexport const isNftCollectionInfo = zodIsFactory(NftCollectionInfoZod)\nexport const asNftCollectionInfo = zodAsFactory(NftCollectionInfoZod, 'asNftCollectionInfo')\nexport const toNftCollectionInfo = zodToFactory(NftCollectionInfoZod, 'toNftCollectionInfo')\n", "import { createPayloadPlugin } from '@xyo-network/sdk'\n\nimport type { NftCollectionInfo } from './Payload/index.ts'\nimport { NftCollectionSchema } from './Schema.ts'\nimport { cryptoNftCollectionPayloadTemplate } from './Template.ts'\n\nexport const NftCollectionInfoPayloadPlugin = () =>\n  createPayloadPlugin<NftCollectionInfo>({\n    schema: NftCollectionSchema,\n    template: cryptoNftCollectionPayloadTemplate,\n  })\n", "import type { NftCollectionInfo } from './Payload/index.ts'\nimport { NftCollectionSchema } from './Schema.ts'\n\nexport const cryptoNftCollectionPayloadTemplate = (): Partial<NftCollectionInfo> => ({ schema: NftCollectionSchema })\n", "import {\n  zodAsFactory, zodIsFactory, zodToFactory,\n} from '@ariestools/sdk'\nimport { PayloadZodOfSchema } from '@xyo-network/sdk'\nimport * as z from 'zod/mini'\n\nimport { NftCollectionWitnessQuerySchema } from './Schema.ts'\n\nexport const NftCollectionWitnessQueryZod = z.extend(PayloadZodOfSchema(NftCollectionWitnessQuerySchema), {\n  address: z.optional(z.string()),\n  chainId: z.optional(z.number()),\n  /**\n   * The maximum number of NFTs to sample from the collection\n   * for determining the collection's schema & distribution\n   */\n  maxNfts: z.optional(z.number()),\n})\n\nexport type NftCollectionWitnessQuery = z.infer<typeof NftCollectionWitnessQueryZod>\n\nexport const isNftCollectionWitnessQuery = zodIsFactory(NftCollectionWitnessQueryZod)\nexport const asNftCollectionWitnessQuery = zodAsFactory(NftCollectionWitnessQueryZod, 'asNftCollectionWitnessQuery')\nexport const toNftCollectionWitnessQuery = zodToFactory(NftCollectionWitnessQueryZod, 'toNftCollectionWitnessQuery')\n", "import { asSchema } from '@xyo-network/sdk'\n\nimport { NftCollectionSchema } from '../Schema.ts'\n\nexport type NftCollectionWitnessConfigSchema = typeof NftCollectionWitnessConfigSchema\nexport const NftCollectionWitnessConfigSchema = asSchema(`${NftCollectionSchema}.witness.config`, true)\n\nexport type NftCollectionWitnessQuerySchema = typeof NftCollectionWitnessQuerySchema\nexport const NftCollectionWitnessQuerySchema = asSchema(`${NftCollectionSchema}.witness.query`, true)\n"],
+  "mappings": "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",
+  "names": ["asSchema", "asSchema", "asSchema", "asSchema", "z", "z", "z", "z", "z", "z", "z", "zodAsFactory", "zodIsFactory", "zodToFactory", "PayloadZodOfSchema", "z", "PayloadZodOfSchema", "zodIsFactory", "zodAsFactory", "zodToFactory", "zodAsFactory", "zodIsFactory", "zodToFactory", "PayloadZodOfSchema", "z", "asSchema", "asSchema", "PayloadZodOfSchema", "zodIsFactory", "zodAsFactory", "zodToFactory"]
+}

package/dist/neutral/crypto-nft-plugins.d.ts

@@ -0,0 +1,2 @@
+export * from './modules/crypto-nft-plugins/index.js';
+//# sourceMappingURL=crypto-nft-plugins.d.ts.map

package/dist/neutral/crypto-nft-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-nft-plugins.d.ts","sourceRoot":"","sources":["../../src/crypto-nft-plugins.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAA"}

package/dist/neutral/crypto-nft-plugins.mjs

@@ -0,0 +1,4 @@
+// src/modules/crypto-nft-plugins/index.ts
+export * from "#crypto-nft";
+export * from "#crypto-nft-collection";
+//# sourceMappingURL=crypto-nft-plugins.mjs.map

package/dist/neutral/crypto-nft-plugins.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/crypto-nft-plugins/index.ts"],
+  "sourcesContent": ["export * from '#crypto-nft'\nexport * from '#crypto-nft-collection'\n"],
+  "mappings": ";AAAA,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/neutral/crypto-nft-score.d.ts

@@ -0,0 +1,2 @@
+export * from './modules/crypto-nft-score/index.js';
+//# sourceMappingURL=crypto-nft-score.d.ts.map

package/dist/neutral/crypto-nft-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-nft-score.d.ts","sourceRoot":"","sources":["../../src/crypto-nft-score.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA"}

package/dist/neutral/crypto-nft-score.mjs

@@ -0,0 +1,61 @@
+// src/modules/crypto-nft-score/increment.ts
+var incrementTotal = (score, by = 1) => {
+  score[0] += by;
+  return score;
+};
+var incrementPossible = (score, by = 1) => {
+  score[1] += by;
+  return score;
+};
+var incrementTotalAndPossible = (score, totalBy = 1, possibleBy = 1) => {
+  score[0] += totalBy;
+  score[1] += possibleBy;
+  return score;
+};
+
+// src/modules/crypto-nft-score/score.ts
+import * as z from "zod/mini";
+var PassFailScoreZod = z.tuple([z.number(), z.literal(1)]);
+var PASS = [1, 1];
+var FAIL = [0, 1];
+var ScaledScoreZod = z.tuple([z.number(), z.number()]);
+var SKIP = [0, 0];
+var ScoreZod = z.union([ScaledScoreZod, PassFailScoreZod]);
+
+// src/modules/crypto-nft-score/normalize.ts
+var normalize = (score, maxScore) => {
+  const [total, possible] = score;
+  if (possible === 0) return SKIP;
+  const normalizedScore = Math.min(Math.round(total / possible * maxScore), maxScore);
+  return [normalizedScore, maxScore];
+};
+
+// src/modules/crypto-nft-score/scoringFunction.ts
+import * as z2 from "zod/mini";
+var PassFailScoringFunctionZod = z2.custom();
+var ScaledScoringFunctionZod = z2.custom();
+var ScoringFunctionZod = z2.union([PassFailScoringFunctionZod, ScaledScoringFunctionZod]);
+
+// src/modules/crypto-nft-score/weighted.ts
+import * as z3 from "zod/mini";
+var WeightedScoringCriteriaZod = z3.object({
+  score: ScoringFunctionZod,
+  weight: z3.number()
+});
+export {
+  FAIL,
+  PASS,
+  PassFailScoreZod,
+  PassFailScoringFunctionZod,
+  SKIP,
+  ScaledScoreZod,
+  ScaledScoringFunctionZod,
+  ScoreZod,
+  ScoringFunctionZod,
+  WeightedScoringCriteriaZod,
+  incrementPossible,
+  incrementTotal,
+  incrementTotalAndPossible,
+  normalize
+};
+//# sourceMappingURL=crypto-nft-score.mjs.map

package/dist/neutral/crypto-nft-score.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/modules/crypto-nft-score/increment.ts", "../../src/modules/crypto-nft-score/score.ts", "../../src/modules/crypto-nft-score/normalize.ts", "../../src/modules/crypto-nft-score/scoringFunction.ts", "../../src/modules/crypto-nft-score/weighted.ts"],
+  "sourcesContent": ["import type { ScaledScore } from './score.ts'\n\nexport const incrementTotal = (score: ScaledScore, by = 1): ScaledScore => {\n  score[0] += by\n  return score\n}\n\nexport const incrementPossible = (score: ScaledScore, by = 1): ScaledScore => {\n  score[1] += by\n  return score\n}\n\nexport const incrementTotalAndPossible = (score: ScaledScore, totalBy = 1, possibleBy = 1): ScaledScore => {\n  score[0] += totalBy\n  score[1] += possibleBy\n  return score\n}\n", "import * as z from 'zod/mini'\n\nexport const PassFailScoreZod = z.tuple([z.number(), z.literal(1)])\nexport type PassFailScore = z.infer<typeof PassFailScoreZod>\nexport const PASS: PassFailScore = [1, 1]\nexport const FAIL: PassFailScore = [0, 1]\n\nexport const ScaledScoreZod = z.tuple([z.number(), z.number()])\nexport type ScaledScore = z.infer<typeof ScaledScoreZod>\nexport const SKIP: ScaledScore = [0, 0]\n\nexport const ScoreZod = z.union([ScaledScoreZod, PassFailScoreZod])\nexport type Score = z.infer<typeof ScoreZod>\n", "import type { Score } from './score.ts'\nimport { SKIP } from './score.ts'\n\nexport const normalize = (score: Score, maxScore: number): Score => {\n  const [total, possible] = score\n  if (possible === 0) return SKIP\n  const normalizedScore = Math.min(Math.round((total / possible) * maxScore), maxScore)\n  return [normalizedScore, maxScore]\n}\n", "import type { AnyObject, EmptyObject } from '@ariestools/sdk'\nimport * as z from 'zod/mini'\n\nimport type { PassFailScore, Score } from './score.ts'\n\nexport const PassFailScoringFunctionZod = z.custom<(payload: AnyObject) => PassFailScore | Promise<PassFailScore>>()\nexport type PassFailScoringFunction<T extends EmptyObject = AnyObject> = (payload: T) => PassFailScore | Promise<PassFailScore>\n\nexport const ScaledScoringFunctionZod = z.custom<(payload: AnyObject) => Score | Promise<Score>>()\nexport type ScaledScoringFunction<T extends EmptyObject = AnyObject> = (payload: T) => Score | Promise<Score>\n\nexport const ScoringFunctionZod = z.union([PassFailScoringFunctionZod, ScaledScoringFunctionZod])\nexport type ScoringFunction<T extends EmptyObject = AnyObject> = PassFailScoringFunction<T> | ScaledScoringFunction<T>\n", "import type { AnyObject } from '@ariestools/sdk'\nimport type { Payload } from '@xyo-network/sdk'\nimport * as z from 'zod/mini'\n\nimport type { ScoringFunction } from './scoringFunction.ts'\nimport { ScoringFunctionZod } from './scoringFunction.ts'\n\nexport const WeightedScoringCriteriaZod = z.object({\n  score: ScoringFunctionZod,\n  weight: z.number(),\n})\n\nexport type WeightedScoringCriteria<T extends Payload = Payload<AnyObject>> = Omit<z.infer<typeof WeightedScoringCriteriaZod>, 'score'> & {\n  score: ScoringFunction<T>\n}\n"],
+  "mappings": ";AAEO,IAAM,iBAAiB,CAAC,OAAoB,KAAK,MAAmB;AACzE,QAAM,CAAC,KAAK;AACZ,SAAO;AACT;AAEO,IAAM,oBAAoB,CAAC,OAAoB,KAAK,MAAmB;AAC5E,QAAM,CAAC,KAAK;AACZ,SAAO;AACT;AAEO,IAAM,4BAA4B,CAAC,OAAoB,UAAU,GAAG,aAAa,MAAmB;AACzG,QAAM,CAAC,KAAK;AACZ,QAAM,CAAC,KAAK;AACZ,SAAO;AACT;;;AChBA,YAAY,OAAO;AAEZ,IAAM,mBAAqB,QAAM,CAAG,SAAO,GAAK,UAAQ,CAAC,CAAC,CAAC;AAE3D,IAAM,OAAsB,CAAC,GAAG,CAAC;AACjC,IAAM,OAAsB,CAAC,GAAG,CAAC;AAEjC,IAAM,iBAAmB,QAAM,CAAG,SAAO,GAAK,SAAO,CAAC,CAAC;AAEvD,IAAM,OAAoB,CAAC,GAAG,CAAC;AAE/B,IAAM,WAAa,QAAM,CAAC,gBAAgB,gBAAgB,CAAC;;;ACR3D,IAAM,YAAY,CAAC,OAAc,aAA4B;AAClE,QAAM,CAAC,OAAO,QAAQ,IAAI;AAC1B,MAAI,aAAa,EAAG,QAAO;AAC3B,QAAM,kBAAkB,KAAK,IAAI,KAAK,MAAO,QAAQ,WAAY,QAAQ,GAAG,QAAQ;AACpF,SAAO,CAAC,iBAAiB,QAAQ;AACnC;;;ACPA,YAAYA,QAAO;AAIZ,IAAM,6BAA+B,UAAuE;AAG5G,IAAM,2BAA6B,UAAuD;AAG1F,IAAM,qBAAuB,SAAM,CAAC,4BAA4B,wBAAwB,CAAC;;;ACThG,YAAYC,QAAO;AAKZ,IAAM,6BAA+B,UAAO;AAAA,EACjD,OAAO;AAAA,EACP,QAAU,UAAO;AACnB,CAAC;",
+  "names": ["z", "z"]
+}

package/dist/neutral/crypto-nft.d.ts

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

package/dist/neutral/crypto-nft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-nft.d.ts","sourceRoot":"","sources":["../../src/crypto-nft.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAA"}

package/dist/neutral/crypto-nft.mjs

@@ -0,0 +1,288 @@
+// src/modules/crypto-nft/Diviner/Config.ts
+import { asSchema as asSchema3 } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft/Diviner/Schema.ts
+import { asSchema as asSchema2 } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft/Schema.ts
+import { asSchema } from "@xyo-network/sdk";
+var NftSchema = asSchema("network.xyo.crypto.nft", true);
+
+// src/modules/crypto-nft/Diviner/Schema.ts
+var NftScoreSchema = asSchema2(`${NftSchema}.score`, true);
+
+// src/modules/crypto-nft/Diviner/Config.ts
+var NftScoreDivinerConfigSchema = asSchema3(`${NftScoreSchema}.diviner.config`, true);
+
+// src/modules/crypto-nft/Diviner/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema } from "@xyo-network/sdk";
+import * as z3 from "zod/mini";
+
+// src/modules/crypto-nft/Payload/NftInfo/NftContractInformation.ts
+import * as z2 from "zod/mini";
+
+// src/modules/crypto-nft/Payload/NftInfo/TokenType.ts
+import * as z from "zod/mini";
+var TokenTypeZod = z.nullable(z.enum(["ERC721", "ERC1155"]));
+var nonNullTokenTypes = /* @__PURE__ */ new Set(["ERC721", "ERC1155"]);
+var isNonNullTokenType = (value) => nonNullTokenTypes.has(value);
+var toTokenType = (value) => {
+  if (value == null) {
+    return null;
+  }
+  if (isNonNullTokenType(value)) {
+    return value;
+  }
+  throw new Error(`${value} is not a valid TokenType`);
+};
+
+// src/modules/crypto-nft/Payload/NftInfo/NftContractInformation.ts
+var NftContractInformationZod = z2.object({
+  address: z2.string(),
+  chainId: z2.number(),
+  implementation: z2.optional(z2.string()),
+  /** @deprecated use types instead */
+  type: z2.optional(TokenTypeZod),
+  types: z2.optional(z2.array(TokenTypeZod))
+});
+
+// src/modules/crypto-nft/Diviner/Payload.ts
+var AttributesScoringCriteriaZod = z3.literal("Attributes");
+var MetadataScoringCriteriaZod = z3.union([
+  z3.literal("Animation URL"),
+  z3.literal("Background Color"),
+  z3.literal("Description"),
+  z3.literal("External Url"),
+  z3.literal("Image"),
+  z3.literal("Image Data"),
+  z3.literal("Name"),
+  z3.literal("YouTube URL"),
+  AttributesScoringCriteriaZod
+]);
+var ScoringCriteriaZod = z3.union([
+  z3.literal("Contract Address"),
+  z3.literal("Supply"),
+  z3.literal("Token Id"),
+  z3.literal("Type"),
+  MetadataScoringCriteriaZod
+]);
+var ScoringCriteriaKeyZod = ScoringCriteriaZod;
+var NftAnalysisZod = z3.record(ScoringCriteriaKeyZod, z3.custom());
+var NftScoresZod = z3.object({ scores: NftAnalysisZod });
+var NftScoreFieldsZod = z3.object({
+  ...NftContractInformationZod.shape,
+  ...NftScoresZod.shape,
+  sources: z3.optional(z3.array(z3.string()))
+});
+var NftScoreZod = z3.extend(PayloadZodOfSchema(NftScoreSchema), { ...NftScoreFieldsZod.shape });
+var isNftScore = zodIsFactory(NftScoreZod);
+var asNftScore = zodAsFactory(NftScoreZod, "asNftScore");
+var toNftScore = zodToFactory(NftScoreZod, "toNftScore");
+
+// src/modules/crypto-nft/Payload/NftInfo/NftAttribute.ts
+import * as z4 from "zod/mini";
+var NftAttributeZod = z4.object({
+  display_type: z4.optional(z4.custom()),
+  trait_type: z4.optional(z4.custom()),
+  value: z4.optional(z4.custom())
+});
+
+// src/modules/crypto-nft/Payload/NftInfo/NftInfoFields.ts
+import * as z6 from "zod/mini";
+
+// src/modules/crypto-nft/Payload/NftInfo/NftMetadata.ts
+import * as z5 from "zod/mini";
+var NftMetadataZod = z5.object({
+  attributes: z5.optional(z5.custom()),
+  description: z5.optional(z5.custom()),
+  image: z5.optional(z5.custom()),
+  name: z5.optional(z5.custom())
+});
+
+// src/modules/crypto-nft/Payload/NftInfo/NftInfoFields.ts
+var NftInfoFieldsZod = z6.object({
+  ...NftContractInformationZod.shape,
+  metadata: z6.optional(NftMetadataZod),
+  metadataUri: z6.optional(z6.string()),
+  supply: z6.string(),
+  tokenId: z6.string()
+});
+
+// src/modules/crypto-nft/Payload/OpenSeaNftInfo/DisplayType.ts
+import * as z7 from "zod/mini";
+var DisplayTypeZod = z7.enum([
+  "date",
+  "boost_number",
+  "boost_percentage",
+  "number",
+  "string"
+]);
+
+// src/modules/crypto-nft/Payload/OpenSeaNftInfo/OpenSeaNftAttribute.ts
+import * as z8 from "zod/mini";
+var OpenSeaNftAttributeZod = z8.object({
+  /**
+   * A field indicating how you would like it to be displayed. For string traits, you don't have to worry about display_type.
+   */
+  display_type: z8.optional(DisplayTypeZod),
+  max_value: z8.optional(z8.number()),
+  /**
+   * The name of the trait
+   */
+  trait_type: z8.string(),
+  /**
+   * The value of the trait
+   */
+  value: z8.union([z8.string(), z8.number()])
+});
+
+// src/modules/crypto-nft/Payload/OpenSeaNftInfo/OpenSeaNftInfoFields.ts
+import * as z10 from "zod/mini";
+
+// src/modules/crypto-nft/Payload/OpenSeaNftInfo/OpenSeaNftMetadata.ts
+import * as z9 from "zod/mini";
+var OpenSeaNftMetadataZod = z9.object({
+  /**
+   * A URL to a multi-media attachment for the item. The file extensions GLTF, GLB, WEBM, MP4, M4V, OGV, and OGG are supported,
+   * along with the audio-only extensions MP3, WAV, and OGA. Animation_url also supports HTML pages, allowing you to build rich
+   * experiences and interactive NFTs using JavaScript canvas, WebGL, and more. Scripts and relative paths within the HTML page
+   * are now supported. However, access to browser extensions is not supported.
+   */
+  animation_url: z9.string(),
+  /**
+   * These are the attributes for the item, which will show up on the OpenSea page for the item.
+   */
+  attributes: z9.optional(z9.array(OpenSeaNftAttributeZod)),
+  /**
+   * Background color of the item on OpenSea. Must be a six-character hexadecimal without a pre-pended #.
+   */
+  background_color: z9.optional(z9.string()),
+  /**
+   * A human readable description of the item. Markdown is supported.
+   */
+  description: z9.string(),
+  /**
+   * This is the URL that will appear below the asset's image on OpenSea and will allow users to leave OpenSea and view the item
+   * on your site.
+   */
+  external_url: z9.optional(z9.string()),
+  // TODO: this property is conditional based on the presence of the image_data property
+  /**
+   * This is the URL to the image of the item. Can be just about any type of image (including SVGs, which will be cached into PNGs
+   * by OpenSea), and can be IPFS URLs or paths. We recommend using a 350 x 350 image.
+   */
+  image: z9.string(),
+  /**
+   * Raw SVG image data, if you want to generate images on the fly (not recommended). Only use this if you're not including the
+   * image parameter.
+   */
+  image_data: z9.optional(z9.string()),
+  /**
+   * Name of the item.
+   */
+  name: z9.string(),
+  /**
+   * A URL to a YouTube video.
+   */
+  youtube_url: z9.optional(z9.string())
+});
+
+// src/modules/crypto-nft/Payload/OpenSeaNftInfo/OpenSeaNftInfoFields.ts
+var OpenSeaNftInfoFieldsZod = z10.extend(NftInfoFieldsZod, { metadata: OpenSeaNftMetadataZod });
+
+// src/modules/crypto-nft/Payload/Payload.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "@xyo-network/sdk";
+import * as z11 from "zod/mini";
+var NftInfoZod = z11.extend(PayloadZodOfSchema2(NftSchema), { ...NftInfoFieldsZod.shape });
+var isNftInfo = zodIsFactory2(NftInfoZod);
+var asNftInfo = zodAsFactory2(NftInfoZod, "asNftInfo");
+var toNftInfo = zodToFactory2(NftInfoZod, "toNftInfo");
+
+// src/modules/crypto-nft/Plugin.ts
+import { createPayloadPlugin } from "@xyo-network/sdk";
+
+// src/modules/crypto-nft/Template.ts
+var cryptoWalletNftPayloadTemplate = () => ({ schema: NftSchema });
+
+// src/modules/crypto-nft/Plugin.ts
+var NftInfoPayloadPlugin = () => createPayloadPlugin({
+  schema: NftSchema,
+  template: cryptoWalletNftPayloadTemplate
+});
+
+// src/modules/crypto-nft/Witness/Query.ts
+import {
+  zodAsFactory as zodAsFactory3,
+  zodIsFactory as zodIsFactory3,
+  zodToFactory as zodToFactory3
+} from "@ariestools/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema3 } from "@xyo-network/sdk";
+import * as z12 from "zod/mini";
+
+// src/modules/crypto-nft/Witness/Schema.ts
+import { asSchema as asSchema4 } from "@xyo-network/sdk";
+var NftWitnessConfigSchema = asSchema4(`${NftSchema}.witness.config`, true);
+var NftWitnessQuerySchema = asSchema4(`${NftSchema}.witness.query`, true);
+
+// src/modules/crypto-nft/Witness/Query.ts
+var NftWitnessQueryZod = z12.extend(PayloadZodOfSchema3(NftWitnessQuerySchema), {
+  address: z12.optional(z12.string()),
+  /**
+   * The maximum number of NFTs to return. Configurable to prevent
+   * large wallets from exhausting Infura API credits.
+   */
+  maxNfts: z12.optional(z12.number())
+});
+var isNftWitnessQuery = zodIsFactory3(NftWitnessQueryZod);
+var asNftWitnessQuery = zodAsFactory3(NftWitnessQueryZod, "asNftWitnessQuery");
+var toNftWitnessQuery = zodToFactory3(NftWitnessQueryZod, "toNftWitnessQuery");
+export {
+  AttributesScoringCriteriaZod,
+  DisplayTypeZod,
+  MetadataScoringCriteriaZod,
+  NftAnalysisZod,
+  NftAttributeZod,
+  NftContractInformationZod,
+  NftInfoFieldsZod,
+  NftInfoPayloadPlugin,
+  NftInfoZod,
+  NftMetadataZod,
+  NftSchema,
+  NftScoreDivinerConfigSchema,
+  NftScoreFieldsZod,
+  NftScoreSchema,
+  NftScoreZod,
+  NftScoresZod,
+  NftWitnessConfigSchema,
+  NftWitnessQuerySchema,
+  NftWitnessQueryZod,
+  OpenSeaNftAttributeZod,
+  OpenSeaNftInfoFieldsZod,
+  OpenSeaNftMetadataZod,
+  ScoringCriteriaKeyZod,
+  ScoringCriteriaZod,
+  TokenTypeZod,
+  asNftInfo,
+  asNftScore,
+  asNftWitnessQuery,
+  cryptoWalletNftPayloadTemplate,
+  NftInfoPayloadPlugin as default,
+  isNftInfo,
+  isNftScore,
+  isNftWitnessQuery,
+  toNftInfo,
+  toNftScore,
+  toNftWitnessQuery,
+  toTokenType
+};
+//# sourceMappingURL=crypto-nft.mjs.map