@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/domain-payload-plugin/neutral/index.mjs

@@ -0,0 +1,485 @@
+// src/DomainConfigPayload.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema as PayloadZodOfSchema2 } from "../../payload-model/neutral/index.mjs";
+import * as z2 from "zod/mini";
+
+// src/DomainConfigSchema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var DomainConfigSchema = asSchema("network.xyo.domain.config", true);
+
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema as asSchema2 } from "../../payload-model/neutral/index.mjs";
+var DomainSchema = asSchema2("network.xyo.domain", true);
+
+// src/Payload.ts
+var AliasZod = z.object({
+  /** huri to the aliased payload */
+  huri: z.string(),
+  /** canonical name (ex. network.xyo.example) */
+  name: z.optional(z.string())
+});
+var SchemaDefinitionZod = z.looseObject({ $id: z.optional(z.string()) });
+var SchemaMapEntryZod = z.union([z.string(), SchemaDefinitionZod]);
+var stringZod = z.string();
+var optionalStringArrayZod = z.optional(z.array(stringZod));
+var optionalAliasRecordZod = z.optional(z.record(stringZod, AliasZod));
+var networkPayloadZod = z.custom();
+var optionalNetworkPayloadArrayZod = z.optional(z.array(networkPayloadZod));
+var optionalSchemaMapEntryRecordZod = z.optional(z.record(stringZod, SchemaMapEntryZod));
+var DomainConfigFieldsZod = z.object({
+  /** Additional config files [huri] [out] */
+  additional: optionalStringArrayZod,
+  /** Values associated with this domain [out] */
+  aliases: optionalAliasRecordZod,
+  /** Known networks [out] */
+  networks: optionalNetworkPayloadArrayZod,
+  /** Official schemas published by this domain, keyed by schema name [out] */
+  schemas: optionalSchemaMapEntryRecordZod
+});
+var DomainPayloadZod = z.extend(PayloadZodOfSchema(DomainSchema), DomainConfigFieldsZod.shape);
+var isDomainPayload = zodIsFactory(DomainPayloadZod);
+var asDomainPayload = zodAsFactory(DomainPayloadZod, "asDomainPayload");
+var toDomainPayload = zodToFactory(DomainPayloadZod, "toDomainPayload");
+
+// src/DomainConfigPayload.ts
+var DomainConfigPayloadZod = z2.extend(PayloadZodOfSchema2(DomainConfigSchema), DomainConfigFieldsZod.shape);
+var isDomainConfigPayload = zodIsFactory2(DomainConfigPayloadZod);
+var asDomainConfigPayload = zodAsFactory2(DomainConfigPayloadZod, "asDomainConfigPayload");
+var toDomainConfigPayload = zodToFactory2(DomainConfigPayloadZod, "toDomainConfigPayload");
+
+// src/DomainConfigPlugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/DomainConfigTemplate.ts
+var domainConfigPayloadTemplate = () => ({
+  schema: DomainConfigSchema,
+  schemas: {
+    "com.example.inline": {
+      properties: { value: { type: "string" } },
+      type: "object"
+    },
+    "com.example.referenced": ""
+  }
+});
+
+// src/DomainConfigPlugin.ts
+var DomainConfigPayloadPlugin = () => createPayloadPlugin({
+  schema: DomainConfigSchema,
+  template: domainConfigPayloadTemplate,
+  zod: DomainConfigPayloadZod
+});
+
+// src/Plugin.ts
+import { createPayloadPlugin as createPayloadPlugin2 } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+import { asSchema as asSchema3 } from "../../payload-model/neutral/index.mjs";
+var domainConfigTemplate = () => ({
+  aliases: { "com.example.id": { huri: "" } },
+  networks: [
+    {
+      name: "",
+      nodes: [
+        {
+          name: "",
+          schema: asSchema3("network.xyo.network.node", true),
+          slug: "",
+          type: "archivist",
+          uri: ""
+        }
+      ],
+      schema: asSchema3("network.xyo.network", true),
+      slug: ""
+    }
+  ],
+  schema: DomainSchema
+});
+
+// src/Wrapper.ts
+import {
+  Base,
+  FetchClientError,
+  fetchJson,
+  isBrowser,
+  isString
+} from "@xylabs/sdk";
+import { isHash as isHash2 } from "@xylabs/sdk";
+import { DnsRecordType, domainResolve } from "../../dns/neutral/index.mjs";
+import { Huri } from "../../huri/neutral/index.mjs";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { PayloadWrapper } from "../../payload-wrapper/neutral/index.mjs";
+
+// src/Resolution/XyoDnsRecords.ts
+import { isHash } from "@xylabs/sdk";
+var SCHEMA_KEY_PREFIX = "schema.";
+function normalizeTxtData(data) {
+  const trimmed = data.trim();
+  if (trimmed.includes('"')) {
+    const quotedParts = Array.from(trimmed.matchAll(/"([^"]*)"/g), (match) => match[1]);
+    return quotedParts.join("") || trimmed;
+  }
+  return trimmed;
+}
+function parseXyoTxtRecords(answers) {
+  const entries = (answers ?? []).map((answer) => answer.data).filter((data) => typeof data === "string").map(normalizeTxtData).toSorted((left, right) => left.localeCompare(right));
+  const records = { legacyHashes: [], schemas: {} };
+  for (const entry of entries) {
+    if (isHash(entry)) {
+      records.legacyHashes.push(entry);
+    } else if (entry.startsWith(SCHEMA_KEY_PREFIX)) {
+      const separatorIndex = entry.indexOf("=");
+      if (separatorIndex > SCHEMA_KEY_PREFIX.length) {
+        const name = entry.slice(SCHEMA_KEY_PREFIX.length, separatorIndex);
+        const value = entry.slice(separatorIndex + 1);
+        if (name.length > 0 && value.length > 0) {
+          records.schemas[name] ??= value;
+        }
+      }
+    } else if (entry.startsWith("domain=")) {
+      const value = entry.slice("domain=".length);
+      if (value.length > 0) {
+        records.domain ??= value;
+      }
+    } else if (entry.startsWith("config=")) {
+      const value = entry.slice("config=".length);
+      if (value.length > 0) {
+        records.config ??= value;
+      }
+    }
+  }
+  return records;
+}
+
+// src/Wrapper.ts
+var DomainPayloadWrapper = class _DomainPayloadWrapper extends PayloadWrapper {
+  aliases;
+  static async discover(reverseDomainName, proxy) {
+    const parts = reverseDomainName.split(".");
+    for (let i = 2; i <= parts.length; i++) {
+      const domainToCheck = parts.filter((_, index) => index < i).toReversed().join(".");
+      const result = await this.discoverDNSEntry(domainToCheck) ?? await this.discoverRootFile(domainToCheck, proxy);
+      if (result) {
+        return result;
+      }
+    }
+  }
+  static async discoverDNSEntry(domain) {
+    try {
+      const { Answer } = await domainResolve(`_xyo.${domain}`, DnsRecordType.TXT) ?? {};
+      const records = parseXyoTxtRecords(Answer);
+      const candidates = [records.config, ...records.legacyHashes].filter((element) => isString(element));
+      for (const candidate of candidates) {
+        const huri = new Huri(candidate);
+        const payload = await huri.fetch();
+        if (isDomainPayload(payload) || isDomainConfigPayload(payload)) {
+          return new _DomainPayloadWrapper(payload);
+        }
+      }
+    } catch {
+      Base.defaultLogger?.log(`DomainConfig dns reading error entry not found [${domain}]`);
+    }
+  }
+  static async discoverRootFile(domain, proxy) {
+    return await this.discoverRootFileDirect(domain) ?? (isBrowser() || isString(proxy) ? await this.discoverRootFileWithProxy(domain, proxy) : void 0);
+  }
+  static async discoverRootFileDirect(domain) {
+    const urls = [`https://${domain}/xyo.json`, `https://xyo.${domain}/`, `https://${domain}/xyo-config.json`];
+    for (const url of urls) {
+      try {
+        const response = await fetchJson(url);
+        if (response.data) {
+          return new _DomainPayloadWrapper(response.data);
+        }
+      } catch {
+        console.log(`DomainConfig root file not found [${url}]`);
+      }
+    }
+  }
+  static async discoverRootFileWithProxy(domain, proxy = "https://api.archivist.xyo.network/domain") {
+    try {
+      const requestUrl = `${proxy}/${domain.split(".").toReversed().join(".")}`;
+      const response = await fetchJson(requestUrl);
+      if (response.data?.data) {
+        return new _DomainPayloadWrapper(response.data.data);
+      }
+    } catch (ex) {
+      const status = ex instanceof FetchClientError ? ex.response.status : "unknown";
+      console.log(`DomainConfig root file not found using proxy [${domain}] [${status}]`);
+    }
+  }
+  async fetchAlias(alias, huriOptions) {
+    const huri = new Huri(alias.huri, huriOptions);
+    const payload = await huri.fetch();
+    return payload ? {
+      alias,
+      huri,
+      payload
+    } : null;
+  }
+  async findArchivistUri(hash) {
+    const network = await this.getNetwork(hash);
+    return network?.nodes?.find((payload) => payload.type === "archivist" ? payload : void 0)?.uri;
+  }
+  async getNetwork(hash) {
+    return isHash2(hash) ? await PayloadBuilder.findByDataHash(this.payload.networks, hash) : this.payload.networks?.[0];
+  }
+  async fetch(networkSlug) {
+    await this.fetchAliases(networkSlug);
+  }
+  async fetchAliases(networkSlug) {
+    this.aliases = null;
+    const archivistUri = await this.findArchivistUri(networkSlug);
+    if (this.payload.aliases) {
+      const fetchedAliases = await Promise.all(
+        Object.values(this.payload.aliases ?? {}).map((alias) => {
+          return this.fetchAlias(alias, { archivistUri });
+        })
+      );
+      this.aliases = fetchedAliases.filter(Boolean);
+    }
+  }
+};
+
+// src/Plugin.ts
+var DomainPayloadPlugin = () => createPayloadPlugin2({
+  schema: DomainSchema,
+  template: domainConfigTemplate,
+  wrap: (payload) => DomainPayloadWrapper.wrap(payload)
+});
+
+// src/Resolution/DomainSchemaResolver.ts
+import {
+  fetchJson as fetchJson2,
+  isBrowser as isBrowser2,
+  isString as isString2
+} from "@xylabs/sdk";
+import { DnsRecordType as DnsRecordType2, domainResolve as domainResolve2 } from "../../dns/neutral/index.mjs";
+import { Huri as Huri2 } from "../../huri/neutral/index.mjs";
+import { PayloadBuilder as PayloadBuilder2 } from "../../payload-builder/neutral/index.mjs";
+import { isSchemaPayload, SchemaSchema } from "../../schema-payload-plugin/neutral/index.mjs";
+var DEFAULT_MAX_INDIRECTION_DEPTH = 3;
+var DEFAULT_PROXY = "https://api.archivist.xyo.network/domain";
+function candidateDomains(schemaName) {
+  const parts = schemaName.split(".");
+  const domains = [];
+  for (let i = 2; i <= parts.length; i++) {
+    domains.push(parts.slice(0, i).toReversed().join("."));
+  }
+  return domains;
+}
+function isSchemaInDomainNamespace(schemaName, domain) {
+  return candidateDomains(schemaName).some((candidate) => candidate === domain || domain.endsWith(`.${candidate}`));
+}
+function isValidSchemaName(schemaName) {
+  return schemaName.length > 0 && schemaName === schemaName.toLowerCase() && schemaName.split(".").length >= 3;
+}
+var DomainSchemaResolver = class {
+  async resolve(schemaName, options = {}) {
+    if (!isValidSchemaName(schemaName)) {
+      return { status: "not-published" };
+    }
+    const context = {
+      anyCleanAnswer: false,
+      archivistUri: options.archivistUri,
+      proxy: options.proxy,
+      visited: /* @__PURE__ */ new Set()
+    };
+    const depth = options.maxIndirectionDepth ?? DEFAULT_MAX_INDIRECTION_DEPTH;
+    for (const domain of candidateDomains(schemaName)) {
+      const resolved = await this.resolveAtDomain(domain, schemaName, depth, context);
+      if (resolved) {
+        return {
+          payload: resolved.payload,
+          source: resolved.source,
+          status: "resolved"
+        };
+      }
+    }
+    return { status: context.anyCleanAnswer ? "not-published" : "unreachable" };
+  }
+  /** Fetch a payload by hash (or HURI href) and verify it against the referenced hash */
+  async fetchPayload(hashOrHref, context, configFields) {
+    try {
+      const archivistUri = context.archivistUri ?? findArchivistUri(configFields);
+      const huri = new Huri2(hashOrHref, { archivistUri });
+      const payload = await huri.fetch();
+      if (!payload) {
+        context.anyCleanAnswer = true;
+        return void 0;
+      }
+      if (await PayloadBuilder2.dataHash(payload) !== huri.hash && await PayloadBuilder2.hash(payload) !== huri.hash) {
+        console.warn(`DomainSchemaResolver: hash mismatch for [${huri.hash}]`);
+        context.anyCleanAnswer = true;
+        return void 0;
+      }
+      return payload;
+    } catch {
+      return void 0;
+    }
+  }
+  async fetchSchemaPayloadByHash(hashOrHref, schemaName, context, configFields) {
+    const payload = await this.fetchPayload(hashOrHref, context, configFields);
+    if (isSchemaPayload(payload) && payload.definition.$id === schemaName) {
+      return payload;
+    }
+  }
+  lookupHash(fields, schemaName) {
+    const entry = fields.schemas?.[schemaName];
+    if (isString2(entry)) return entry;
+    const alias = fields.aliases?.[schemaName];
+    if (isString2(alias?.huri) && alias.huri.length > 0) return alias.huri;
+  }
+  /** Find the schema in a domain config document (schemas map first, then legacy aliases) */
+  async lookupInConfig(fields, schemaName, domain, mechanism, context, url) {
+    if (!fields) return void 0;
+    context.anyCleanAnswer = true;
+    const entry = fields.schemas?.[schemaName];
+    if (entry !== void 0 && !isString2(entry)) {
+      const payload = { definition: { ...entry, $id: schemaName }, schema: SchemaSchema };
+      return {
+        payload,
+        source: {
+          domain,
+          mechanism,
+          url
+        }
+      };
+    }
+    const hash = this.lookupHash(fields, schemaName);
+    if (isString2(hash)) {
+      const payload = await this.fetchSchemaPayloadByHash(hash, schemaName, context, fields);
+      if (payload) {
+        const huri = new Huri2(hash);
+        return {
+          payload,
+          source: {
+            domain,
+            hash: huri.hash,
+            mechanism,
+            url
+          }
+        };
+      }
+    }
+  }
+  async resolveAtDomain(domain, schemaName, depth, context) {
+    if (context.visited.has(domain)) return void 0;
+    context.visited.add(domain);
+    const dnsResolved = await this.resolveViaDns(domain, schemaName, depth, context);
+    if (dnsResolved) return dnsResolved;
+    const fileCandidates = [
+      [`https://${domain}/xyo.json`, "file-root"],
+      [`https://xyo.${domain}/`, "file-subdomain"],
+      [`https://${domain}/xyo-config.json`, "file-legacy"]
+    ];
+    let anyDirectTransportFailure = false;
+    for (const [url, mechanism] of fileCandidates) {
+      try {
+        const response = await fetchJson2(url);
+        context.anyCleanAnswer = true;
+        const resolved = await this.lookupInConfig(response.data ?? void 0, schemaName, domain, mechanism, context, url);
+        if (resolved) return resolved;
+      } catch {
+        anyDirectTransportFailure = true;
+      }
+    }
+    if (isString2(context.proxy) || isBrowser2() && anyDirectTransportFailure) {
+      const url = `${context.proxy ?? DEFAULT_PROXY}/${domain.split(".").toReversed().join(".")}`;
+      try {
+        const response = await fetchJson2(url);
+        context.anyCleanAnswer = true;
+        const resolved = await this.lookupInConfig(response.data?.data, schemaName, domain, "file-proxy", context, url);
+        if (resolved) return resolved;
+      } catch {
+      }
+    }
+  }
+  async resolveViaDns(domain, schemaName, depth, context) {
+    try {
+      const result = await domainResolve2(`_xyo.${domain}`, DnsRecordType2.TXT);
+      if (!result) return void 0;
+      context.anyCleanAnswer = true;
+      const records = parseXyoTxtRecords(result.Answer);
+      const schemaHash = records.schemas[schemaName];
+      if (isString2(schemaHash)) {
+        const payload = await this.fetchSchemaPayloadByHash(schemaHash, schemaName, context);
+        if (payload) {
+          const huri = new Huri2(schemaHash);
+          return {
+            payload,
+            source: {
+              domain,
+              hash: huri.hash,
+              mechanism: "dns-schema"
+            }
+          };
+        }
+      }
+      if (isString2(records.config)) {
+        const configPayload = await this.fetchPayload(records.config, context);
+        if (isDomainConfigPayload(configPayload) || isDomainPayload(configPayload)) {
+          const resolved = await this.lookupInConfig(configPayload, schemaName, domain, "dns-config", context);
+          if (resolved) return resolved;
+        }
+      }
+      if (isString2(records.domain) && depth > 0 && !context.visited.has(records.domain)) {
+        const resolved = await this.resolveAtDomain(records.domain, schemaName, depth - 1, context);
+        if (resolved) {
+          return { payload: resolved.payload, source: { ...resolved.source, mechanism: "dns-domain" } };
+        }
+      }
+      for (const legacyHash of records.legacyHashes) {
+        const legacyPayload = await this.fetchPayload(legacyHash, context);
+        if (isDomainPayload(legacyPayload) || isDomainConfigPayload(legacyPayload)) {
+          const resolved = await this.lookupInConfig(legacyPayload, schemaName, domain, "dns-legacy", context);
+          if (resolved) return resolved;
+        }
+      }
+    } catch {
+    }
+  }
+};
+function findArchivistUri(fields) {
+  return fields?.networks?.[0]?.nodes?.find((node) => node.type === "archivist")?.uri;
+}
+export {
+  AliasZod,
+  DomainConfigFieldsZod,
+  DomainConfigPayloadPlugin,
+  DomainConfigPayloadZod,
+  DomainConfigSchema,
+  DomainPayloadPlugin,
+  DomainPayloadWrapper,
+  DomainPayloadZod,
+  DomainSchema,
+  DomainSchemaResolver,
+  SchemaDefinitionZod,
+  SchemaMapEntryZod,
+  asDomainConfigPayload,
+  asDomainPayload,
+  candidateDomains,
+  DomainPayloadPlugin as default,
+  domainConfigPayloadTemplate,
+  domainConfigTemplate,
+  isDomainConfigPayload,
+  isDomainPayload,
+  isSchemaInDomainNamespace,
+  normalizeTxtData,
+  parseXyoTxtRecords,
+  toDomainConfigPayload,
+  toDomainPayload
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/elliptic/neutral/Elliptic.d.ts

@@ -0,0 +1,15 @@
+import type { Secp256k1 } from '@bitauth/libauth';
+import { WasmSupport } from '../../wasm/neutral/index.ts';
+export declare class Elliptic {
+    static readonly wasmSupport: WasmSupport;
+    protected static _secp256k1: Secp256k1 | undefined;
+    private static _secp256k1Mutex;
+    static addressFromPublicKey(key: ArrayBufferLike): ArrayBufferLike;
+    static initialize(): Promise<Secp256k1>;
+    static publicKeyFromPrivateKey(privateKey: ArrayBufferLike, prefix?: boolean): Promise<ArrayBufferLike>;
+    static ready(): boolean;
+    static secp256k1(): Promise<Secp256k1>;
+    static sign(hash: ArrayBufferLike, key: ArrayBufferLike): Promise<ArrayBufferLike>;
+    static verify(msg: ArrayBufferLike, signature: ArrayBufferLike, address: ArrayBufferLike): Promise<boolean>;
+}
+//# sourceMappingURL=Elliptic.d.ts.map

package/dist/_pkg/elliptic/neutral/index.d.ts

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

package/dist/_pkg/elliptic/neutral/index.mjs

@@ -0,0 +1,89 @@
+// src/Elliptic.ts
+import { instantiateSecp256k1 } from "@bitauth/libauth";
+import {
+  assertEx,
+  toHex,
+  toUint8Array
+} from "@xylabs/sdk";
+import { Data } from "../../data/neutral/index.mjs";
+import { WasmSupport } from "../../wasm/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+var wasmSupportStatic = new WasmSupport(["bigInt", "mutableGlobals", "referenceTypes", "saturatedFloatToInt", "signExtensions", "simd"]);
+var recoveryIds = [0, 1, 2, 3];
+function compareArrayBuffers(b1, b2) {
+  if (b1.byteLength !== b2.byteLength) {
+    return false;
+  }
+  const a1 = new Uint8Array(b1);
+  const a2 = new Uint8Array(b2);
+  for (let i = 0; i < b1.byteLength; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var Elliptic = class {
+  static wasmSupport = wasmSupportStatic;
+  static _secp256k1;
+  static _secp256k1Mutex = new Mutex();
+  static addressFromPublicKey(key) {
+    const data = new Data(64, key);
+    return data.keccak256.slice(12);
+  }
+  static initialize() {
+    return this.secp256k1();
+  }
+  static async publicKeyFromPrivateKey(privateKey, prefix = false) {
+    const { derivePublicKeyUncompressed } = await this.secp256k1();
+    if (BigInt(toHex(privateKey, { prefix: true })) === 0n) {
+      throw new Error(`Invalid private key [${toHex(privateKey)}]`);
+    }
+    const derivedPublicKey = derivePublicKeyUncompressed(new Uint8Array(privateKey));
+    const fullPublicKey = typeof derivedPublicKey === "string" ? toUint8Array(derivedPublicKey) : derivedPublicKey;
+    return (prefix ? fullPublicKey : fullPublicKey.slice(1)).buffer;
+  }
+  static ready() {
+    return !!this._secp256k1;
+  }
+  static async secp256k1() {
+    return await this._secp256k1Mutex.runExclusive(async () => {
+      if (this._secp256k1) return this._secp256k1;
+      await wasmSupportStatic.initialize();
+      const secp256k1 = assertEx(await instantiateSecp256k1(), () => "No Wasm Support");
+      this._secp256k1 = secp256k1;
+      return secp256k1;
+    });
+  }
+  static async sign(hash, key) {
+    const { signMessageHashCompact } = await this.secp256k1();
+    const signature = signMessageHashCompact(new Uint8Array(key), toUint8Array(hash));
+    return (typeof signature === "string" ? toUint8Array(signature) : signature).buffer;
+  }
+  static async verify(msg, signature, address) {
+    const verifier = await this.secp256k1();
+    if (this.wasmSupport.canUseWasm) {
+      for (const recoveryId of recoveryIds) {
+        try {
+          const rawRecoveredPublicKey = verifier.recoverPublicKeyUncompressed(toUint8Array(signature), recoveryId, toUint8Array(msg));
+          const recoveredPublicKey = (typeof rawRecoveredPublicKey === "string" ? toUint8Array(rawRecoveredPublicKey) : rawRecoveredPublicKey).slice(1).buffer;
+          const recoveredAddress = this.addressFromPublicKey(recoveredPublicKey);
+          if (compareArrayBuffers(address, recoveredAddress)) {
+            return true;
+          }
+        } catch (ex) {
+          const error = ex;
+          console.log(error.message);
+          console.log(error.stack);
+          continue;
+        }
+      }
+      return false;
+    }
+    throw new Error("No wasm support");
+  }
+};
+export {
+  Elliptic
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/hash/browser/BrowserObjectHasher.d.ts

@@ -0,0 +1,9 @@
+import type { EmptyObject } from '@xylabs/sdk';
+import { ObjectHasher } from './ObjectHasher.ts';
+export declare class BrowserObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
+    static readonly createBrowserWorker: (url?: URL) => import("@xylabs/threads/master").Worker;
+    static readonly createNodeWorker: (func?: () => unknown) => import("@xylabs/threads/master").Worker;
+    static readonly subtleHashWorkerUrl: URL | undefined;
+    static readonly wasmHashWorkerUrl: URL | undefined;
+}
+//# sourceMappingURL=BrowserObjectHasher.d.ts.map

package/dist/_pkg/hash/browser/NodeObjectHasher.d.ts

@@ -0,0 +1,6 @@
+import type { EmptyObject } from '@xylabs/sdk';
+import { ObjectHasher } from './ObjectHasher.ts';
+export declare class NodeObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectHasher<T> {
+    static readonly createNodeWorker: (func?: () => unknown) => import("@xylabs/threads/master").Worker;
+}
+//# sourceMappingURL=NodeObjectHasher.d.ts.map

package/dist/_pkg/hash/browser/ObjectHasher.d.ts

@@ -0,0 +1,69 @@
+import type { EmptyObject, Hash } from '@xylabs/sdk';
+import { ObjectWrapper } from '@xylabs/sdk';
+import type { Worker } from '@xylabs/threads/master';
+import { WasmSupport } from '../../wasm/neutral/index.ts';
+export type WorkerFunction = ((...args: unknown[]) => unknown) | (() => unknown);
+export type WorkerModule<Keys extends string> = Record<Keys, WorkerFunction>;
+export declare class ObjectHasher<T extends EmptyObject = EmptyObject> extends ObjectWrapper<T> {
+    static allowHashPooling: boolean;
+    static allowSubtle: boolean;
+    static createBrowserWorker?: (url?: URL) => Worker | undefined;
+    static createNodeWorker?: (func?: () => unknown) => Worker | undefined;
+    static readonly subtleHashWorkerUrl?: URL;
+    static warnIfUsingJsHash: boolean;
+    static readonly wasmHashWorkerUrl?: URL;
+    static readonly wasmInitialized: Promise<void>;
+    static readonly wasmSupport: WasmSupport;
+    private static _subtleHashPool?;
+    private static _wasmHashPool?;
+    private static get subtleHashPool();
+    private static get wasmHashPool();
+    static createWorker(url?: URL, func?: () => unknown): Worker;
+    static filterExcludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static findByHash<T extends EmptyObject>(objs: T[] | undefined, hash: Hash): Promise<T | undefined>;
+    /**
+     * Asynchronously hashes a payload
+     * @param obj A payload
+     * @returns The payload hash
+     */
+    static hash<T extends EmptyObject>(obj: T): Promise<Hash>;
+    static hashBytes(bytes: ArrayBuffer | Uint8Array): Promise<Hash>;
+    static hashFields<T extends EmptyObject>(obj: T): T;
+    /**
+     * Creates an array of payload/hash tuples based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload/hash tuples
+     */
+    static hashPairs<T extends EmptyObject>(objs: T[]): Promise<[T, Hash][]>;
+    /**
+     * Creates an array of payload hashes based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload hashes
+     */
+    static hashes<T extends EmptyObject>(objs?: T[]): Promise<Hash[] | undefined>;
+    /**
+     * Returns a clone of the payload that is JSON safe
+     * @param obj A payload
+     * @param meta Keeps underscore (meta) fields if set to true
+     * @returns Returns a clone of the payload that is JSON safe
+     */
+    static json<T extends EmptyObject>(payload: T, meta?: boolean): T;
+    /** @deprecated us JSON instead */
+    static jsonPayload<T extends EmptyObject>(payload: T, meta?: boolean): T;
+    static stringifyHashFields<T extends EmptyObject>(obj: T): string;
+    static subtleHash(data: Uint8Array<ArrayBuffer>): Promise<ArrayBuffer>;
+    static wasmHash(data: Uint8Array): Promise<Hash>;
+    private static createWorkerPool;
+    hash(): Promise<Hash>;
+    /**
+     * Returns a clone of the payload that is JSON safe
+     * @param meta Keeps underscore (meta) fields if set to true
+     * @returns Returns a clone of the payload that is JSON safe
+     */
+    json(meta?: boolean): T;
+}
+/** @deprecated use PayloadBuilder or ObjectHasher instead */
+export declare class PayloadHasher<T extends object> extends ObjectHasher<T> {
+}
+//# sourceMappingURL=ObjectHasher.d.ts.map

package/dist/_pkg/hash/browser/createBrowserWorker.d.ts

@@ -0,0 +1,3 @@
+import { Worker } from '@xylabs/threads/master';
+export declare const createBrowserWorker: (url?: URL) => Worker;
+//# sourceMappingURL=createBrowserWorker.d.ts.map

package/dist/_pkg/hash/browser/createNodeWorker.d.ts

@@ -0,0 +1,3 @@
+import { Worker } from '@xylabs/threads/master';
+export declare const createNodeWorker: (func?: () => unknown) => Worker;
+//# sourceMappingURL=createNodeWorker.d.ts.map