@xyo-network/crypto-asset-plugin 2.83.0 → 2.84.1

package/dist/node/Plugin.d.ts

@@ -1,7 +1,7 @@
 import { CryptoMarketAssetDiviner } from './Diviner';
 export declare const CryptoMarketAssetPlugin: () => import("@xyo-network/payloadset-plugin").PayloadSetDivinerPlugin<CryptoMarketAssetDiviner<import("@xyo-network/object").BaseParamsFields & {
     account?: import("@xyo-network/account-model").AccountInstance | "random" | undefined;
-    config: import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<{
+    config: (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
         accountDerivationPath?: string | undefined;
         readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
         readonly labels?: import("@xyo-network/module-model").Labels | undefined;
@@ -19,7 +19,7 @@ export declare const CryptoMarketAssetPlugin: () => import("@xyo-network/payload
         readonly timestamp?: boolean | undefined;
     } & import("@xyo-network/module-model").ArchivingModuleConfig & {
         schema: string;
-    } & Omit<import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadFields & Omit<{
+    } & Omit<(import("@xyo-network/payload-model").SchemaFields & object & Omit<{
         accountDerivationPath?: string | undefined;
         readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
         readonly labels?: import("@xyo-network/module-model").Labels | undefined;
@@ -41,9 +41,399 @@ export declare const CryptoMarketAssetPlugin: () => import("@xyo-network/payload
         schema: "network.xyo.crypto.asset.diviner.config";
     }, "schema">, "schema"> & {
         schema: "network.xyo.crypto.asset.diviner.config";
+    }) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & object) | (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & import("@xyo-network/payload-model").PayloadMetaFields) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }), "schema">, "schema"> & {
+        schema: string;
+    }) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: string;
+    } & Omit<(import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & object) | (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & import("@xyo-network/payload-model").PayloadMetaFields) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }), "schema">, "schema"> & {
+        schema: string;
+    } & object) | (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: string;
+    } & Omit<(import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & object) | (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & import("@xyo-network/payload-model").PayloadMetaFields) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }), "schema">, "schema"> & {
+        schema: string;
+    } & import("@xyo-network/payload-model").PayloadMetaFields) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: string;
+    } & Omit<(import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & object) | (import("@xyo-network/payload-model").SchemaFields & object & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
     }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & import("@xyo-network/payload-model").PayloadMetaFields) | (import("@xyo-network/payload-model").SchemaFields & import("@xyo-network/payload-model").PayloadMetaFields & Omit<{
+        accountDerivationPath?: string | undefined;
+        readonly archivist?: import("@xyo-network/module-model").ArchivistModuleConfig | undefined;
+        readonly labels?: import("@xyo-network/module-model").Labels | undefined;
+        readonly name?: string | undefined;
+        readonly paging?: Record<string, {
+            size?: number | undefined;
+        }> | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: Record<string, (string | import("@xyo-network/module-model").CosigningAddressSet)[]> | undefined;
+            readonly disallowed?: Record<string, string[]> | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    } & import("@xyo-network/module-model").ArchivingModuleConfig & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    } & Omit<{
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }, "schema">, "schema"> & {
+        schema: "network.xyo.crypto.asset.diviner.config";
+    }), "schema">, "schema"> & {
         schema: string;
-    };
+    });
     ephemeralQueryAccountEnabled?: boolean | undefined;
     wallet?: import("@xyo-network/wallet-model").WalletInstance | undefined;
 }>>;

package/dist/node/Plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/Plugin.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAEpD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQjC,CAAA"}
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/Plugin.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAEpD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQjC,CAAA"}

package/dist/node/{index.mjs → index.cjs}

@@ -1,21 +1,51 @@
+"use strict";
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CryptoMarketAssetDiviner: () => CryptoMarketAssetDiviner,
+  CryptoMarketAssetDivinerConfigSchema: () => CryptoMarketAssetDivinerConfigSchema,
+  CryptoMarketAssetDivinerQuerySchema: () => CryptoMarketAssetDivinerQuerySchema,
+  CryptoMarketAssetPlugin: () => CryptoMarketAssetPlugin,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
 // src/Plugin.ts
-import { CryptoMarketAssetSchema as CryptoMarketAssetSchema5 } from "@xyo-network/crypto-asset-payload-plugin";
-import { PayloadSetSchema } from "@xyo-network/payload-model";
-import { createPayloadSetDivinerPlugin } from "@xyo-network/payloadset-plugin";
+var import_crypto_asset_payload_plugin5 = require("@xyo-network/crypto-asset-payload-plugin");
+var import_payload_model = require("@xyo-network/payload-model");
+var import_payloadset_plugin = require("@xyo-network/payloadset-plugin");
 
 // src/Diviner.ts
-import { AbstractDiviner } from "@xyo-network/abstract-diviner";
-import { CoingeckoCryptoMarketSchema } from "@xyo-network/coingecko-crypto-market-payload-plugin";
-import { CryptoMarketAssetSchema as CryptoMarketAssetSchema4 } from "@xyo-network/crypto-asset-payload-plugin";
-import { UniswapCryptoMarketSchema } from "@xyo-network/uniswap-crypto-market-payload-plugin";
+var import_abstract_diviner = require("@xyo-network/abstract-diviner");
+var import_coingecko_crypto_market_payload_plugin = require("@xyo-network/coingecko-crypto-market-payload-plugin");
+var import_crypto_asset_payload_plugin4 = require("@xyo-network/crypto-asset-payload-plugin");
+var import_uniswap_crypto_market_payload_plugin = require("@xyo-network/uniswap-crypto-market-payload-plugin");
 
 // src/lib/divinePrices.ts
-import { exists as exists3 } from "@xylabs/exists";
-import { CryptoMarketAssetSchema as CryptoMarketAssetSchema3 } from "@xyo-network/crypto-asset-payload-plugin";
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/payload-builder";
+var import_exists3 = require("@xylabs/exists");
+var import_crypto_asset_payload_plugin3 = require("@xyo-network/crypto-asset-payload-plugin");
+var import_payload_builder3 = require("@xyo-network/payload-builder");
 
 // src/lib/average.ts
-import { exists } from "@xylabs/exists";
+var import_exists = require("@xylabs/exists");
 var isNumber = (val) => {
   return val !== void 0;
 };
@@ -30,16 +60,16 @@ var averageStringifiedNumbers = (...prices) => {
   return numbers.length ? numbers.reduce((sum, n) => sum + n, 0) / numbers.length : void 0;
 };
 var average = (...input) => {
-  const payloads = input.filter(exists);
+  const payloads = input.filter(import_exists.exists);
   const tokens = new Set(payloads.map((payload) => Object.keys(payload.assets).map((t) => t)).flatMap((t) => t));
   const valuations = new Set(
     [...tokens].map((asset) => {
       const assetInfo = payloads.map((p) => {
         var _a;
         return (_a = p.assets) == null ? void 0 : _a[asset];
-      }).filter(exists);
+      }).filter(import_exists.exists);
       const valueBasis = new Set(
-        assetInfo.map((v) => Object.keys(v.value)).flatMap((v) => v).filter(exists)
+        assetInfo.map((v) => Object.keys(v.value)).flatMap((v) => v).filter(import_exists.exists)
       );
       return [...valueBasis];
     }).flatMap((v) => v)
@@ -49,7 +79,7 @@ var average = (...input) => {
       const assetInfo = payloads.map((p) => {
         var _a;
         return (_a = p.assets) == null ? void 0 : _a[token];
-      }).filter(exists);
+      }).filter(import_exists.exists);
       const value = Object.fromEntries(
         [...valuations].map((valuation) => {
           const assetValuations = assetInfo.map((info) => {
@@ -67,9 +97,9 @@ var average = (...input) => {
 };
 
 // src/lib/divineCoinGeckoPrices.ts
-import { CryptoMarketAssetSchema } from "@xyo-network/crypto-asset-payload-plugin";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-var schema = CryptoMarketAssetSchema;
+var import_crypto_asset_payload_plugin = require("@xyo-network/crypto-asset-payload-plugin");
+var import_payload_builder = require("@xyo-network/payload-builder");
+var schema = import_crypto_asset_payload_plugin.CryptoMarketAssetSchema;
 var valuationExists = (value) => {
   return !!value[1];
 };
@@ -77,7 +107,7 @@ var otherValueExists = (value) => {
   const possiblyNumber = value[1];
   return typeof possiblyNumber === "number" && !isNaN(possiblyNumber);
 };
-var divineCoinGeckoPrices = (payload) => {
+var divineCoinGeckoPrices = async (payload) => {
   const assets = payload && (payload == null ? void 0 : payload.assets) ? Object.fromEntries(
     Object.entries(payload.assets).filter(valuationExists).map(([asset, valuation]) => {
       const value = Object.fromEntries(
@@ -87,14 +117,14 @@ var divineCoinGeckoPrices = (payload) => {
     })
   ) : {};
   const timestamp = Date.now();
-  return new PayloadBuilder({ schema }).fields({ assets, timestamp }).build();
+  return await new import_payload_builder.PayloadBuilder({ schema }).fields({ assets, timestamp }).build();
 };
 
 // src/lib/divineUniswapPrices.ts
-import { exists as exists2 } from "@xylabs/exists";
-import { CryptoMarketAssetSchema as CryptoMarketAssetSchema2 } from "@xyo-network/crypto-asset-payload-plugin";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-var schema2 = CryptoMarketAssetSchema2;
+var import_exists2 = require("@xylabs/exists");
+var import_crypto_asset_payload_plugin2 = require("@xyo-network/crypto-asset-payload-plugin");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var schema2 = import_crypto_asset_payload_plugin2.CryptoMarketAssetSchema;
 var mapUniswapToken = (symbol) => {
   if (symbol.toLowerCase() === "wbtc")
     return "btc";
@@ -105,7 +135,7 @@ var mapUniswapToken = (symbol) => {
   return symbol.toLowerCase();
 };
 var pairsContainingToken = (uniswapPayload, token) => {
-  return uniswapPayload == null ? void 0 : uniswapPayload.pairs.map((p) => p.tokens).filter((p) => p.some((x) => x.symbol.toLowerCase() === token)).filter(exists2);
+  return uniswapPayload == null ? void 0 : uniswapPayload.pairs.map((p) => p.tokens).filter((p) => p.some((x) => x.symbol.toLowerCase() === token)).filter(import_exists2.exists);
 };
 var tokensFromPairs = (pairs) => {
   return pairs.map((p) => p.tokens).flat().map((t) => t.symbol.toLowerCase());
@@ -120,7 +150,7 @@ var valuesFromTokenPairs = (tokensPairs, token) => {
     }).map((x) => [mapUniswapToken(x[0]), x[1]])
   );
 };
-var divineUniswapPrices = (uniswapPayload) => {
+var divineUniswapPrices = async (uniswapPayload) => {
   let assets = {};
   if (uniswapPayload) {
     const tokens = new Set(tokensFromPairs(uniswapPayload.pairs));
@@ -134,18 +164,18 @@ var divineUniswapPrices = (uniswapPayload) => {
     );
   }
   const timestamp = Date.now();
-  return new PayloadBuilder2({ schema: schema2 }).fields({ assets, timestamp }).build();
+  return await new import_payload_builder2.PayloadBuilder({ schema: schema2 }).fields({ assets, timestamp }).build();
 };
 
 // src/lib/divinePrices.ts
-var schema3 = CryptoMarketAssetSchema3;
-var divinePrices = (coinGeckoPayload, uniswapPayload) => {
-  const coinGeckoPrices = divineCoinGeckoPrices(coinGeckoPayload);
-  const uniswapPrices = divineUniswapPrices(uniswapPayload);
-  const prices = [uniswapPayload, coinGeckoPayload].some(exists3);
+var schema3 = import_crypto_asset_payload_plugin3.CryptoMarketAssetSchema;
+var divinePrices = async (coinGeckoPayload, uniswapPayload) => {
+  const coinGeckoPrices = await divineCoinGeckoPrices(coinGeckoPayload);
+  const uniswapPrices = await divineUniswapPrices(uniswapPayload);
+  const prices = [uniswapPayload, coinGeckoPayload].some(import_exists3.exists);
   const assets = prices ? average(coinGeckoPrices, uniswapPrices) : {};
   const timestamp = Date.now();
-  return new PayloadBuilder3({ schema: schema3 }).fields({ assets, timestamp }).build();
+  return await new import_payload_builder3.PayloadBuilder({ schema: schema3 }).fields({ assets, timestamp }).build();
 };
 
 // src/Schema.ts
@@ -153,20 +183,20 @@ var CryptoMarketAssetDivinerQuerySchema = "network.xyo.crypto.asset.diviner.quer
 var CryptoMarketAssetDivinerConfigSchema = "network.xyo.crypto.asset.diviner.config";
 
 // src/Diviner.ts
-var CryptoMarketAssetDiviner = class extends AbstractDiviner {
+var CryptoMarketAssetDiviner = class extends import_abstract_diviner.AbstractDiviner {
   static configSchemas = [CryptoMarketAssetDivinerConfigSchema];
-  static targetSchema = CryptoMarketAssetSchema4;
-  divineHandler(payloads) {
-    const coinGeckoPayload = payloads == null ? void 0 : payloads.find((payload) => (payload == null ? void 0 : payload.schema) === CoingeckoCryptoMarketSchema);
-    const uniswapPayload = payloads == null ? void 0 : payloads.find((payload) => (payload == null ? void 0 : payload.schema) === UniswapCryptoMarketSchema);
-    const result = divinePrices(coinGeckoPayload, uniswapPayload);
+  static targetSchema = import_crypto_asset_payload_plugin4.CryptoMarketAssetSchema;
+  async divineHandler(payloads) {
+    const coinGeckoPayload = payloads == null ? void 0 : payloads.find((payload) => (payload == null ? void 0 : payload.schema) === import_coingecko_crypto_market_payload_plugin.CoingeckoCryptoMarketSchema);
+    const uniswapPayload = payloads == null ? void 0 : payloads.find((payload) => (payload == null ? void 0 : payload.schema) === import_uniswap_crypto_market_payload_plugin.UniswapCryptoMarketSchema);
+    const result = await divinePrices(coinGeckoPayload, uniswapPayload);
     return [result];
   }
 };
 
 // src/Plugin.ts
-var CryptoMarketAssetPlugin = () => createPayloadSetDivinerPlugin(
-  { required: { [CryptoMarketAssetSchema5]: 1 }, schema: PayloadSetSchema },
+var CryptoMarketAssetPlugin = () => (0, import_payloadset_plugin.createPayloadSetDivinerPlugin)(
+  { required: { [import_crypto_asset_payload_plugin5.CryptoMarketAssetSchema]: 1 }, schema: import_payload_model.PayloadSetSchema },
   {
     diviner: async (params) => {
       return await CryptoMarketAssetDiviner.create(params);
@@ -176,11 +206,11 @@ var CryptoMarketAssetPlugin = () => createPayloadSetDivinerPlugin(
 
 // src/index.ts
 var src_default = CryptoMarketAssetPlugin;
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   CryptoMarketAssetDiviner,
   CryptoMarketAssetDivinerConfigSchema,
   CryptoMarketAssetDivinerQuerySchema,
-  CryptoMarketAssetPlugin,
-  src_default as default
-};
-//# sourceMappingURL=index.mjs.map
+  CryptoMarketAssetPlugin
+});
+//# sourceMappingURL=index.cjs.map