@xyo-network/service-kit-xl1 0.2.1 → 0.2.2

package/dist/browser/index.mjs

@@ -1,3 +1,510 @@
+// src/createFleetAuthority.ts
+import {
+  foldFleetControls,
+  resolveFleetPayload,
+  verifyFleetPayload
+} from "@xyo-network/service-kit-protocol";
+import {
+  AddressZod,
+  FleetControlSchema,
+  FleetMemberSchema,
+  FleetPublicationScopeSchema,
+  FleetPublicationScopeZod,
+  FleetSchema,
+  FleetZod,
+  HashZod
+} from "@xyo-network/service-kit-schemas";
+import {
+  createXl1FinalizedPublicationEvidence
+} from "@xyo-network/xl1-sdk/protocol-sdk/finalized-publication";
+
+// src/fleetControl.ts
+var abortedDescriptor = Object.getOwnPropertyDescriptor(AbortSignal.prototype, "aborted");
+var abortedGetter = Reflect.get(abortedDescriptor ?? {}, "get");
+var nativeEvents = EventTarget.prototype;
+var addListener = nativeEvents.addEventListener;
+var removeListener = nativeEvents.removeEventListener;
+var apply = Reflect.apply;
+var now = performance.now.bind(performance);
+function captureSignal(value) {
+  if (value === void 0) return;
+  if (typeof abortedGetter !== "function") throw new TypeError("Native AbortSignal is required");
+  apply(abortedGetter, value, []);
+  return value;
+}
+function aborted(signal) {
+  if (typeof abortedGetter !== "function") throw new TypeError("Native AbortSignal is required");
+  return apply(abortedGetter, signal, []);
+}
+function listenAbort(signal, listener) {
+  if (signal === void 0) return () => {
+  };
+  apply(addListener, signal, ["abort", listener, { once: true }]);
+  return () => {
+    apply(removeListener, signal, ["abort", listener]);
+  };
+}
+var FleetAuthorityError = class extends Error {
+  code;
+  status;
+  constructor(status, code) {
+    super(code);
+    this.name = "FleetAuthorityError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function operationControl(signal, timeoutMs, startedAt) {
+  const controller = new AbortController();
+  const deadline = startedAt + timeoutMs;
+  let terminal;
+  const stop = (status) => {
+    terminal ??= new FleetAuthorityError(status, status);
+    controller.abort();
+  };
+  const unlisten = listenAbort(signal, () => stop("cancelled"));
+  if (signal !== void 0 && aborted(signal)) stop("cancelled");
+  const timer = setTimeout(() => stop("deadline"), Math.max(1, Math.ceil(deadline - now())));
+  return {
+    signal: controller.signal,
+    assertActive() {
+      if (now() >= deadline) stop("deadline");
+      if (terminal !== void 0) throw terminal;
+    },
+    remainingMs: () => Math.max(1, Math.ceil(deadline - now())),
+    dispose() {
+      clearTimeout(timer);
+      unlisten();
+      controller.abort();
+    }
+  };
+}
+var fleetNow = now;
+
+// src/fleetProjection.ts
+function nextPublisherProjection(result) {
+  const { publicationBlock: projectionBlock, ...original } = result;
+  const context2 = {
+    ...original,
+    projection: "pending-N+1",
+    projectionBlock
+  };
+  if (result.status === "authorized" || result.status === "absent") {
+    return Object.freeze({
+      ...context2,
+      status: result.status === "authorized" ? "projected-granted" : "projected-absent",
+      coveredRange: Object.freeze({ fromBlockNumber: 0, toBlockNumber: result.anchor.blockNumber })
+    });
+  }
+  return Object.freeze(context2);
+}
+
+// src/createFleetAuthority.ts
+var b4Families = Object.freeze([FleetSchema, FleetMemberSchema, FleetPublicationScopeSchema, FleetControlSchema]);
+function ownRecord(input, required, optional = []) {
+  if (input === null || typeof input !== "object" || Object.getPrototypeOf(input) !== Object.prototype) throw new TypeError("Use a strict own-data profile/request");
+  const keys = Reflect.ownKeys(input);
+  if (keys.some((key) => typeof key !== "string" || ![...required, ...optional].includes(key)) || required.some((key) => !keys.includes(key))) throw new TypeError("Unexpected or missing profile/request fields");
+  return Object.fromEntries(keys.map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor?.enumerable !== true || !("value" in descriptor)) throw new TypeError("Profile/request accessors are unsupported");
+    return [key, descriptor.value];
+  }));
+}
+function finiteProfile(input, keys) {
+  const values = ownRecord(input, keys);
+  if (Object.values(values).some((value) => typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > 2147483647)) throw new RangeError("Every finite positive bound is required");
+  return Object.freeze(values);
+}
+function pinProfile(input) {
+  const profile = ownRecord(input, ["evidence", "foldLimits", "limits", "resolutionLimits", "seeds"]);
+  const evidence = ownRecord(profile.evidence, ["assurance", "chainId", "genesisRoot", "limits", "network", "source"]);
+  const source = ownRecord(evidence.source, ["bodyBaseUrl", "finalizedBaseUrl", "headUrl"], ["fetch"]);
+  const evidenceLimits = finiteProfile(evidence.limits, [
+    "maxAggregateBytes",
+    "maxBlocks",
+    "maxBodies",
+    "maxConcurrentReads",
+    "maxDecodedDepth",
+    "maxDecodedNodes",
+    "maxLineageBlocks",
+    "maxResponseBytes",
+    "maxRoots",
+    "maxSourceUrlBytes",
+    "perCallTimeoutMs",
+    "totalTimeoutMs"
+  ]);
+  const fixedEvidence = Object.freeze({
+    ...evidence,
+    limits: evidenceLimits,
+    source: Object.freeze(source)
+  });
+  const limits = finiteProfile(profile.limits, [
+    "maxBlocks",
+    "maxConcurrentCalls",
+    "maxConcurrentReads",
+    "maxFleets",
+    "maxOccurrences",
+    "maxPages",
+    "maxRootReads",
+    "totalTimeoutMs"
+  ]);
+  const foldLimits = finiteProfile(profile.foldLimits, ["maxBodyBytes", "maxControls", "maxDeclarations", "maxDepth", "maxGrants", "maxMembers", "maxNodes"]);
+  const resolutionLimits = finiteProfile(profile.resolutionLimits, [
+    "attemptTimeoutMs",
+    "maxBodyBytes",
+    "maxCandidatesPerSeed",
+    "maxDepth",
+    "maxNodes",
+    "maxSeeds",
+    "totalTimeoutMs"
+  ]);
+  return {
+    evidence: fixedEvidence,
+    limits,
+    foldLimits,
+    resolutionLimits,
+    seeds: profile.seeds
+  };
+}
+function pinRequest(input, next = false) {
+  const values = ownRecord(input, ["anchor", "owner", "publicationBlock"], ["fleetRoot", "signal"]);
+  const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
+  HashZod.parse(anchor.blockRoot);
+  AddressZod.parse(values.owner);
+  if (values.fleetRoot !== void 0) HashZod.parse(values.fleetRoot);
+  if (!Number.isSafeInteger(anchor.blockNumber) || anchor.blockNumber < 0 || anchor.blockNumber >= Number.MAX_SAFE_INTEGER || typeof values.publicationBlock !== "number" || !Number.isSafeInteger(values.publicationBlock) || values.publicationBlock < 0 || (next ? values.publicationBlock !== anchor.blockNumber + 1 : values.publicationBlock > anchor.blockNumber)) throw new RangeError("Select an exact publication height within the anchor");
+  return Object.freeze({
+    ...values,
+    anchor: Object.freeze(anchor),
+    signal: captureSignal(values.signal)
+  });
+}
+function pinReaders(seeds, profile) {
+  if (!Array.isArray(seeds) || seeds.length === 0 || seeds.length > profile.resolutionLimits.maxSeeds) throw new RangeError("Explicit bounded root readers required");
+  const ids = /* @__PURE__ */ new Set();
+  return Object.freeze(Array.from({ length: seeds.length }, (_, index) => {
+    const slot = Object.getOwnPropertyDescriptor(seeds, String(index));
+    if (slot?.enumerable !== true || !("value" in slot)) throw new TypeError("Readers require dense own data slots");
+    const seed = ownRecord(slot.value, ["id", "reader"]);
+    if (typeof seed.id !== "string" || seed.id.length === 0 || seed.id.length > 128 || seed.id.trim() !== seed.id || ids.has(seed.id)) throw new TypeError("Readers require unique bounded IDs");
+    ids.add(seed.id);
+    const reader = ownRecord(seed.reader, ["get"]);
+    if (typeof reader.get !== "function") throw new TypeError("Readers require an own get method");
+    const get = reader.get.bind(seed.reader);
+    return Object.freeze({ id: seed.id, reader: Object.freeze({ get }) });
+  }));
+}
+function capacityReaders(seeds, state, maximum, capacity) {
+  return Object.freeze(seeds.map((seed) => Object.freeze({
+    id: seed.id,
+    reader: Object.freeze({
+      get: async (...args) => {
+        if (state.active >= maximum) {
+          capacity.limited = true;
+          throw new FleetAuthorityError("resource-limit", "reader-capacity");
+        }
+        state.active++;
+        try {
+          return await seed.reader.get(...args);
+        } finally {
+          state.active--;
+        }
+      }
+    })
+  })));
+}
+function context(profile, request) {
+  return Object.freeze({
+    assurance: "source-trusted-finalized-replay",
+    historyScope: "verified-native-owner-and-B4-families",
+    network: profile.evidence.network,
+    chainId: profile.evidence.chainId,
+    genesisRoot: profile.evidence.genesisRoot,
+    anchor: request.anchor,
+    owner: request.owner,
+    publicationBlock: request.publicationBlock
+  });
+}
+function positionAfter(left, right) {
+  return left.blockNumber > right.blockNumber || left.blockNumber === right.blockNumber && (left.transactionIndex > right.transactionIndex || left.transactionIndex === right.transactionIndex && left.payloadOrdinal > right.payloadOrdinal);
+}
+function nativeFailure(page) {
+  const statuses = ["cancelled", "deadline", "conflict", "unsupported", "resource-limit"];
+  const status = statuses.includes(page.status) ? page.status : "incomplete";
+  return new FleetAuthorityError(status, `native-${page.issues[0]?.code ?? page.status}`);
+}
+function validatePage(page, profile, request, from, to) {
+  const actual = [
+    page.network,
+    page.chainId,
+    page.genesisRoot,
+    page.anchor.blockNumber,
+    page.anchor.blockRoot,
+    page.assurance,
+    page.requestedRange.fromBlockNumber,
+    page.requestedRange.toBlockNumber
+  ];
+  const expected = [
+    profile.evidence.network,
+    profile.evidence.chainId,
+    profile.evidence.genesisRoot,
+    request.anchor.blockNumber,
+    request.anchor.blockRoot,
+    "source-trusted-finalized-replay",
+    from,
+    to
+  ];
+  if (actual.some((value, index) => value !== expected[index])) throw new FleetAuthorityError("conflict", "scan-binding");
+  if (page.scopeCompleteness !== "verified-native-header-selection" || page.scope.authorizers?.length !== 1 || page.scope.authorizers[0] !== request.owner || page.scope.schemas?.length !== b4Families.length || page.scope.schemas.some((family, index) => family !== b4Families[index])) throw new FleetAuthorityError("conflict", "scan-scope");
+  if (page.status !== "complete") throw nativeFailure(page);
+  if (page.coveredRange?.fromBlockNumber !== from || page.coveredRange.toBlockNumber !== to || page.continuation !== void 0 || page.issues.length > 0) {
+    throw new FleetAuthorityError("incomplete", "scan-coverage");
+  }
+}
+function createFleetAuthority(input) {
+  const profile = pinProfile(input);
+  const evidence = createXl1FinalizedPublicationEvidence(profile.evidence);
+  const readState = { active: 0 };
+  const seeds = pinReaders(profile.seeds, profile);
+  let activeCalls = 0;
+  async function resolved(root, family, work) {
+    work.control.assertActive();
+    const cached = work.roots.get(root);
+    if (cached !== void 0) {
+      if (cached.schema !== family) throw new FleetAuthorityError("unsupported", "declaration-family");
+      return cached;
+    }
+    if (work.roots.size >= profile.limits.maxRootReads) throw new FleetAuthorityError("resource-limit", "root-reads");
+    const result = await resolveFleetPayload(root, family, {
+      seeds: work.seeds,
+      signal: work.control.signal,
+      limits: { ...profile.resolutionLimits, totalTimeoutMs: Math.min(profile.resolutionLimits.totalTimeoutMs, work.control.remainingMs()) }
+    });
+    work.control.assertActive();
+    if (work.capacity.limited) throw new FleetAuthorityError("resource-limit", "reader-capacity");
+    if (result.status !== "verified") {
+      if (result.status === "aborted") throw new FleetAuthorityError("cancelled", "root-cancelled");
+      if (result.reason === "resource-limit") throw new FleetAuthorityError("resource-limit", "root-resource-limit");
+      if (result.reason === "deadline") throw new FleetAuthorityError("deadline", "root-deadline");
+      if (result.attempts.some((attempt) => attempt.status === "unsupported")) throw new FleetAuthorityError("unsupported", "root-definition");
+      throw new FleetAuthorityError("incomplete", "root-unavailable");
+    }
+    work.roots.set(root, result.payload);
+    if (family !== FleetControlSchema) work.declarations.set(root, Object.freeze({ root, payload: result.payload }));
+    return result.payload;
+  }
+  async function scan(request, control) {
+    if (request.anchor.blockNumber + 1 > profile.limits.maxBlocks) throw new FleetAuthorityError("resource-limit", "history-blocks");
+    const occurrences = [];
+    let pages = 0;
+    for (let from = 0; from <= request.anchor.blockNumber; ) {
+      control.assertActive();
+      if (++pages > profile.limits.maxPages) throw new FleetAuthorityError("resource-limit", "scan-pages");
+      const to = Math.min(request.anchor.blockNumber, from + profile.evidence.limits.maxBlocks - 1);
+      const page = await evidence.scanScoped({
+        anchor: request.anchor,
+        fromBlockNumber: from,
+        toBlockNumber: to,
+        signal: control.signal,
+        scope: { authorizers: [request.owner], schemas: b4Families }
+      });
+      control.assertActive();
+      validatePage(page, profile, request, from, to);
+      for (const fact of page.occurrences) {
+        const previous = occurrences.at(-1);
+        if (fact.network !== profile.evidence.network || fact.chainId !== profile.evidence.chainId || fact.genesisRoot !== profile.evidence.genesisRoot || fact.signer !== request.owner || !b4Families.includes(fact.schema) || fact.blockNumber < from || fact.blockNumber > to || previous !== void 0 && !positionAfter(fact, previous)) throw new FleetAuthorityError("conflict", "occurrence-binding-order");
+        if (occurrences.length >= profile.limits.maxOccurrences) throw new FleetAuthorityError("resource-limit", "occurrences");
+        occurrences.push(fact);
+      }
+      from = to + 1;
+    }
+    return occurrences;
+  }
+  async function original(fact, family, control) {
+    const checked = await verifyFleetPayload(fact.payloadRoot, family, fact.body, profile.foldLimits);
+    control.assertActive();
+    if (checked.status !== "verified") throw new FleetAuthorityError(checked.status === "unsupported" ? "unsupported" : "incomplete", "owner-definition");
+    return checked.payload;
+  }
+  async function discoverFleet(fact, request, work, roots) {
+    if (fact.schema !== FleetSchema || request.fleetRoot !== void 0) return;
+    const checked = await verifyFleetPayload(fact.payloadRoot, FleetSchema, fact.body, profile.foldLimits);
+    work.control.assertActive();
+    if (checked.status !== "verified") {
+      if (fact.signer === request.owner) throw new FleetAuthorityError(checked.status === "unsupported" ? "unsupported" : "incomplete", "owner-declaration");
+      return;
+    }
+    if (FleetZod.parse(checked.payload).owner === request.owner) roots.add(fact.payloadRoot);
+  }
+  async function collect(request, work, occurrences) {
+    const roots = new Set(request.fleetRoot === void 0 ? [] : [request.fleetRoot]);
+    const controls = [];
+    for (const fact of occurrences) {
+      work.control.assertActive();
+      if (fact.blockNumber > request.publicationBlock) continue;
+      await discoverFleet(fact, request, work, roots);
+      if (fact.schema !== FleetControlSchema || fact.signer !== request.owner || fact.blockNumber === request.publicationBlock) continue;
+      const payload = await original(fact, FleetControlSchema, work.control);
+      if (request.fleetRoot !== void 0 && payload.fleetRoot !== request.fleetRoot) continue;
+      const fleet = FleetZod.parse(await resolved(payload.fleetRoot, FleetSchema, work));
+      if (fleet.owner !== request.owner) continue;
+      roots.add(payload.fleetRoot);
+      await resolved(fact.payloadRoot, FleetControlSchema, work);
+      controls.push(Object.freeze({
+        root: fact.payloadRoot,
+        payload,
+        authorizer: fact.signer,
+        block: fact.blockNumber,
+        chainId: fact.chainId,
+        transactionIndex: fact.transactionIndex,
+        payloadIndex: fact.payloadOrdinal
+      }));
+      if ("memberRoot" in payload) await resolved(payload.memberRoot, FleetMemberSchema, work);
+      if ("scopeRoot" in payload) await resolved(payload.scopeRoot, FleetPublicationScopeSchema, work);
+      if (roots.size > profile.limits.maxFleets) throw new FleetAuthorityError("resource-limit", "fleets");
+    }
+    if (roots.size > profile.limits.maxFleets) throw new FleetAuthorityError("resource-limit", "fleets");
+    return { roots, controls };
+  }
+  async function enumerateWork(request, work) {
+    const occurrences = await scan(request, work.control);
+    const { roots, controls } = await collect(request, work, occurrences);
+    const views = [];
+    for (const root of roots) {
+      await resolved(root, FleetSchema, work);
+      const selected = controls.filter((fact) => fact.payload.fleetRoot === root);
+      const needed = /* @__PURE__ */ new Set([root]);
+      for (const fact of selected) {
+        if ("memberRoot" in fact.payload) needed.add(fact.payload.memberRoot);
+        if ("scopeRoot" in fact.payload) needed.add(fact.payload.scopeRoot);
+      }
+      const folded = foldFleetControls({
+        owner: request.owner,
+        fleetRoot: root,
+        chainId: profile.evidence.chainId,
+        genesisRoot: profile.evidence.genesisRoot,
+        publicationBlock: request.publicationBlock,
+        controls: selected,
+        declarations: [...needed].map((key) => {
+          const declaration = work.declarations.get(key);
+          if (declaration === void 0) throw new FleetAuthorityError("incomplete", "missing-declaration");
+          return declaration;
+        }),
+        limits: profile.foldLimits,
+        signal: work.control.signal
+      });
+      work.control.assertActive();
+      if (folded.status !== "folded") {
+        const status = folded.status === "aborted" ? "cancelled" : folded.reason === "resource-limit" ? "resource-limit" : folded.status;
+        throw new FleetAuthorityError(status, `fold-${folded.reason}`);
+      }
+      views.push(Object.freeze({
+        ...folded,
+        status: "complete",
+        assurance: "source-trusted-finalized-replay"
+      }));
+    }
+    return Object.freeze({
+      ...context(profile, request),
+      status: "complete",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      coveredRange: Object.freeze({ fromBlockNumber: 0, toBlockNumber: request.anchor.blockNumber }),
+      views: Object.freeze(views)
+    });
+  }
+  async function execute(request, startedAt, operation) {
+    const control = operationControl(request.signal, profile.limits.totalTimeoutMs, startedAt);
+    let admitted = false;
+    try {
+      control.assertActive();
+      if (activeCalls >= profile.limits.maxConcurrentCalls) throw new FleetAuthorityError("resource-limit", "composition-capacity");
+      activeCalls++;
+      admitted = true;
+      const capacity = { limited: false };
+      return await operation({
+        control,
+        roots: /* @__PURE__ */ new Map(),
+        declarations: /* @__PURE__ */ new Map(),
+        capacity,
+        seeds: capacityReaders(seeds, readState, profile.limits.maxConcurrentReads, capacity)
+      });
+    } catch (error) {
+      const failure = error instanceof FleetAuthorityError ? error : new FleetAuthorityError("incomplete", "composition-source");
+      return Object.freeze({
+        ...context(profile, request),
+        status: failure.status,
+        code: failure.code
+      });
+    } finally {
+      if (admitted) activeCalls--;
+      control.dispose();
+    }
+  }
+  async function publisherWork(request, scopeRoot, publisherAddress, work) {
+    const scope = FleetPublicationScopeZod.parse(await resolved(scopeRoot, FleetPublicationScopeSchema, work));
+    const result = await enumerateWork({ ...request, fleetRoot: scope.fleetRoot }, work);
+    const view = result.views[0];
+    const matches = view?.fleetActive ? view.grants.filter((grant2) => grant2.scopeRoot === scopeRoot && grant2.publisherAddress === publisherAddress) : [];
+    if (matches.length > 1) throw new FleetAuthorityError("conflict", "publisher-ambiguity");
+    const grant = matches[0];
+    return grant === void 0 ? Object.freeze({
+      ...context(profile, request),
+      status: "absent",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      scopeRoot,
+      publisherAddress
+    }) : Object.freeze({
+      ...context(profile, request),
+      status: "authorized",
+      correspondence: "native-sdk-verified",
+      history: "complete-genesis-to-anchor",
+      fleetRoot: scope.fleetRoot,
+      memberRoot: grant.memberRoot,
+      controlRoot: grant.controlRoot,
+      scopeRoot,
+      publisherAddress
+    });
+  }
+  return Object.freeze({
+    async enumerate(inputRequest) {
+      const startedAt = fleetNow();
+      const request = pinRequest(inputRequest);
+      return await execute(request, startedAt, (work) => enumerateWork(request, work));
+    },
+    async resolvePublisher(inputRequest) {
+      const startedAt = fleetNow();
+      const values = ownRecord(inputRequest, ["anchor", "owner", "publicationBlock", "publisherAddress", "scopeRoot"], ["signal"]);
+      const publisherAddress = AddressZod.parse(values.publisherAddress);
+      const scopeRoot = HashZod.parse(values.scopeRoot);
+      const request = pinRequest({
+        anchor: values.anchor,
+        owner: values.owner,
+        publicationBlock: values.publicationBlock,
+        ...values.signal !== void 0 && { signal: values.signal }
+      });
+      return await execute(request, startedAt, (work) => publisherWork(request, scopeRoot, publisherAddress, work));
+    },
+    async projectNextPublisher(inputRequest) {
+      const startedAt = fleetNow();
+      const values = ownRecord(inputRequest, ["anchor", "owner", "publisherAddress", "scopeRoot"], ["signal"]);
+      const anchor = ownRecord(values.anchor, ["blockNumber", "blockRoot"]);
+      const publisherAddress = AddressZod.parse(values.publisherAddress);
+      const scopeRoot = HashZod.parse(values.scopeRoot);
+      const request = pinRequest({
+        anchor,
+        owner: values.owner,
+        publicationBlock: anchor.blockNumber + 1,
+        ...values.signal !== void 0 && { signal: values.signal }
+      }, true);
+      const result = await execute(request, startedAt, (work) => publisherWork(request, scopeRoot, publisherAddress, work));
+      return nextPublisherProjection(result);
+    }
+  });
+}
+
 // src/createXl1DataLakeSeed.ts
 import { createRestDataLakeViewer } from "@xyo-network/xl1-sdk/providers";
 
@@ -134,6 +641,7 @@ async function createXl1DataLakeSeed(options) {
   });
 }
 export {
+  createFleetAuthority,
   createXl1DataLakeSeed
 };
 //# sourceMappingURL=index.mjs.map