@xyo-network/xl1-protocol-sdk 1.26.43 → 1.26.46

package/dist/neutral/index.mjs

@@ -11,137 +11,6 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/actor/ActorV3.ts
-import {
-  AbstractCreatable,
-  assertEx,
-  delay,
-  IdLogger
-} from "@xylabs/sdk-js";
-import { Semaphore } from "async-mutex";
-import z from "zod";
-var CreatableNameZod = z.custom((val) => typeof val === "string" && val.length > 0);
-var StatusReporterInstanceZod = z.custom((val) => val && typeof val === "object" && "report" in val);
-var AccountInstanceZod = z.custom((val) => val && typeof val === "object" && "address" in val);
-var ActorParamsV3Zod = z.object({
-  account: AccountInstanceZod,
-  locator: z.unknown(),
-  name: CreatableNameZod,
-  statusReporter: StatusReporterInstanceZod.optional()
-});
-var ActorV3 = class extends AbstractCreatable {
-  _intervals = /* @__PURE__ */ new Map();
-  _semaphores = /* @__PURE__ */ new Map();
-  _timeouts = /* @__PURE__ */ new Map();
-  _logger;
-  get logger() {
-    this._logger = new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name);
-    return this._logger;
-  }
-  get account() {
-    return this.params.account;
-  }
-  get context() {
-    return this.locator.context;
-  }
-  get locator() {
-    return this.params.locator;
-  }
-  static async paramsHandler(params) {
-    const baseParams = await super.paramsHandler({ ...params, name: params.name ?? "UnknownActor" });
-    const account = assertEx(params.account, () => `params.account is required for actor ${baseParams.name}.`);
-    const locator = assertEx(params.locator, () => `params.locator is required for actor ${baseParams.name}.`);
-    return {
-      ...baseParams,
-      account,
-      locator
-    };
-  }
-  /**
-   * The timer runs until the actor is deactivated (or you manually stop it).
-   */
-  registerTimer(timerName, callback, dueTimeMs, periodMs) {
-    if (this.status !== "starting") {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not starting.`
-      );
-      return;
-    }
-    let running = false;
-    this._semaphores.set(timerName, new Semaphore(1));
-    const timeoutId = setTimeout(() => {
-      const intervalId = setInterval(() => {
-        const semaphore = this._semaphores.get(timerName);
-        if (this.status !== "started" || !this._intervals.has(timerName) || !semaphore || running) return;
-        if (semaphore.isLocked()) {
-          this.logger?.warn(
-            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`
-          );
-          return;
-        }
-        semaphore.acquire().then(([, release]) => {
-          const startTime = Date.now();
-          running = true;
-          callback().then(() => {
-            const duration = Date.now() - startTime;
-            if (duration > periodMs) {
-              this.logger?.warn(
-                `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`
-              );
-            } else if (duration > 5e3) {
-              this.logger?.warn(
-                `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`
-              );
-            }
-          }).catch((error) => {
-            this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`);
-            this.logger?.error(error.stack);
-          }).finally(() => {
-            release();
-            running = false;
-          });
-        }).catch((error) => {
-          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`);
-        });
-      }, periodMs);
-      this._intervals.set(timerName, intervalId);
-    }, dueTimeMs);
-    this._timeouts.set(timerName, timeoutId);
-    this.logger?.debug(
-      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`
-    );
-  }
-  /**
-   * Called by the Orchestrator when the actor is deactivated.
-   * Stop all running timers.
-   */
-  async stopHandler() {
-    await super.stopHandler();
-    this.logger?.debug("Stopping all timers...");
-    await Promise.all(
-      [...this._semaphores.values()].map(async (semaphore) => {
-        while (semaphore.isLocked()) {
-          this.logger?.debug("Waiting for running timer task to complete...");
-          await delay(500);
-        }
-        await semaphore.acquire();
-      })
-    );
-    this._semaphores.clear();
-    for (const [, timeoutRef] of this._timeouts.entries()) {
-      clearTimeout(timeoutRef);
-    }
-    this._timeouts.clear();
-    for (const [, intervalRef] of this._intervals.entries()) {
-      clearInterval(intervalRef);
-    }
-    this._intervals.clear();
-    this.logger?.debug("Stopped.");
-  }
-};
-var Actor = class extends ActorV3 {
-};
-
 // src/amount/splitOnDecimal.ts
 var splitOnDecimal = (value, places = 18) => {
   const whole = value / BigInt(10 ** places);
@@ -230,7 +99,7 @@ var ShiftedBigInt = class _ShiftedBigInt {
 };
 
 // src/amount/XL1Amount.ts
-import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { assertEx } from "@xylabs/sdk-js";
 import {
   AttoXL1,
   FemtoXL1,
@@ -251,7 +120,7 @@ var XL1Amount = class _XL1Amount {
     this.value = AttoXL1(value > MAX_XL1_AMOUNT ? MAX_XL1_AMOUNT : value < 0n ? 0n : value);
   }
   static from(value, places = XL1Places.atto) {
-    assertEx2(allowedPlaces.includes(places), () => `Invalid conversion places (${places} not in ${allowedPlaces.join(", ")})`);
+    assertEx(allowedPlaces.includes(places), () => `Invalid conversion places (${places} not in ${allowedPlaces.join(", ")})`);
     return new _XL1Amount(value * 10n ** BigInt(places));
   }
   static fromMilli(value) {
@@ -300,7 +169,7 @@ var XL1Amount = class _XL1Amount {
     return XL1(this.to(XL1Places.xl1));
   }
   toString(places = Number(XL1Places.atto), config = {}) {
-    assertEx2(allowedPlaces.includes(BigInt(places)), () => `Invalid conversion places (${places} not in ${allowedPlaces.join(", ")})`);
+    assertEx(allowedPlaces.includes(BigInt(places)), () => `Invalid conversion places (${places} not in ${allowedPlaces.join(", ")})`);
     return new ShiftedBigInt(
       this.value,
       {
@@ -322,15 +191,243 @@ function allHashesPresent(hashes, payloads) {
 }
 
 // src/block/hydrate/blockPayloadsFromHydratedBlock.ts
-import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
 import { isTransactionBoundWitness } from "@xyo-network/xl1-protocol-lib";
 var blockPayloadsFromHydratedBlock = (block) => {
-  return block[0].payload_hashes.map((hash) => assertEx3(
+  return block[0].payload_hashes.map((hash) => assertEx2(
     block[1].find((p) => p._hash === hash),
     () => `missing payload ${hash}`
   )).filter((x) => !isTransactionBoundWitness(x));
 };
 
+// src/block/hydrate/BoundWitnessHydrator.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import {
+  isAnyPayload,
+  isBoundWitness,
+  PayloadBuilder
+} from "@xyo-network/sdk-js";
+import { LRUCache } from "lru-cache";
+var DEFAULT_CACHE_MAX = 5e3;
+var DEFAULT_CACHE_TTL = Number.MAX_SAFE_INTEGER;
+var BoundWitnessHydrator = class {
+  asBoundWitness;
+  asHydrated;
+  datalakes;
+  isNestedBoundWitness;
+  payloadCache;
+  sourceCache;
+  /**
+   * @throws if `params.datalakes` is empty. Required at construction to fail fast on misconfig.
+   *   The only zero-datalake hydrate calls that would succeed anyway are degenerate (maxDepth=0
+   *   or a BW with empty payload_hashes) — not load-bearing enough to justify loosening the guard.
+   *   If lifecycle ordering ever requires construction before sources are wired, prefer adding
+   *   an `addDatalake()` mutator over removing this assertion.
+   */
+  constructor(params) {
+    assertEx3(params.datalakes.length > 0, () => "BoundWitnessHydrator requires at least one datalake");
+    const seen = /* @__PURE__ */ new Set();
+    for (const dl of params.datalakes) {
+      assertEx3(!seen.has(dl.name), () => `Duplicate datalake name: ${dl.name}`);
+      seen.add(dl.name);
+    }
+    this.datalakes = params.datalakes;
+    this.asBoundWitness = params.asBoundWitness;
+    this.asHydrated = params.asHydrated;
+    this.isNestedBoundWitness = params.isNestedBoundWitness ?? isBoundWitness;
+    const max = params.cacheMax ?? DEFAULT_CACHE_MAX;
+    const ttl = params.cacheTtl ?? DEFAULT_CACHE_TTL;
+    this.payloadCache = new LRUCache({ max, ttl });
+    this.sourceCache = new LRUCache({ max, ttl });
+  }
+  async hydrate(input, maxDepth = 1, minDepth = maxDepth) {
+    const [hydrated] = await this.hydrateInternal(input, maxDepth, minDepth);
+    return hydrated;
+  }
+  async hydrateWithProvenance(input, maxDepth = 1, minDepth = maxDepth) {
+    return await this.hydrateInternal(input, maxDepth, minDepth);
+  }
+  /** Returns an adapter compatible with HydratedCache. The context arg is ignored. */
+  toHydrateFunction() {
+    return async (_context, hash) => await this.tryHydrate(hash);
+  }
+  async tryHydrate(input, maxDepth = 1) {
+    try {
+      return await this.hydrate(input, maxDepth);
+    } catch {
+      return void 0;
+    }
+  }
+  async tryHydrateWithProvenance(input, maxDepth = 1) {
+    try {
+      return await this.hydrateWithProvenance(input, maxDepth);
+    } catch {
+      return void 0;
+    }
+  }
+  async appendDirectPayloads(bw, sources, minDepth, orderedHashes, orderedPayloads) {
+    const fetched = await this.fetchByHashes(bw.payload_hashes, sources);
+    if (minDepth >= 1) {
+      const missing = bw.payload_hashes.filter((h) => !fetched.has(h));
+      assertEx3(missing.length === 0, () => `Unable to find all payloads for BoundWitness: missing ${missing.join(", ")}`);
+    }
+    for (const h of bw.payload_hashes) {
+      const p = fetched.get(h);
+      if (p === void 0 || orderedHashes.has(h)) continue;
+      orderedHashes.add(h);
+      orderedPayloads.push(p);
+    }
+  }
+  async appendNestedPayloads(sources, minDepth, orderedHashes, orderedPayloads) {
+    const nestedHashes = [];
+    for (const p of orderedPayloads) {
+      if (!this.isNestedBoundWitness(p)) continue;
+      for (const h of p.payload_hashes) {
+        if (!orderedHashes.has(h)) nestedHashes.push(h);
+      }
+    }
+    const fetched = await this.fetchByHashes(nestedHashes, sources);
+    if (minDepth >= 2) {
+      const missing = nestedHashes.filter((h) => !fetched.has(h));
+      assertEx3(missing.length === 0, () => `Unable to find all nested payloads for BoundWitness: missing ${missing.join(", ")}`);
+    }
+    for (const h of nestedHashes) {
+      const p = fetched.get(h);
+      if (p === void 0 || orderedHashes.has(h)) continue;
+      orderedHashes.add(h);
+      orderedPayloads.push(p);
+    }
+  }
+  async fetchByHash(hash, sources) {
+    const cached = this.payloadCache.get(hash);
+    if (cached !== void 0) {
+      const cachedSource = this.sourceCache.get(hash);
+      if (cachedSource !== void 0) sources.set(hash, cachedSource);
+      return cached;
+    }
+    for (const dl of this.datalakes) {
+      const results = await dl.viewer.get([hash]);
+      for (const data of results) {
+        if (!isAnyPayload(data)) continue;
+        this.payloadCache.set(hash, data);
+        this.sourceCache.set(hash, dl.name);
+        sources.set(hash, dl.name);
+        return data;
+      }
+    }
+    return void 0;
+  }
+  async fetchByHashes(hashes, sources) {
+    const result = /* @__PURE__ */ new Map();
+    const remaining = /* @__PURE__ */ new Set();
+    for (const h of hashes) {
+      const cached = this.payloadCache.get(h);
+      if (cached === void 0) {
+        remaining.add(h);
+        continue;
+      }
+      result.set(h, cached);
+      const cachedSource = this.sourceCache.get(h);
+      if (cachedSource !== void 0) sources.set(h, cachedSource);
+    }
+    for (const dl of this.datalakes) {
+      if (remaining.size === 0) break;
+      const needHashes = [...remaining];
+      const fetched = await Promise.all(needHashes.map(async (h) => {
+        const arr = await dl.viewer.get([h]);
+        for (const item of arr) {
+          if (isAnyPayload(item)) return item;
+        }
+        return void 0;
+      }));
+      for (const [i, h] of needHashes.entries()) {
+        const p = fetched[i];
+        if (p === void 0) continue;
+        result.set(h, p);
+        this.payloadCache.set(h, p);
+        this.sourceCache.set(h, dl.name);
+        sources.set(h, dl.name);
+        remaining.delete(h);
+      }
+    }
+    return result;
+  }
+  async hydrateInternal(input, maxDepth, minDepth) {
+    assertEx3(maxDepth >= 0 && maxDepth <= 2, () => `maxDepth must be 0, 1, or 2 (got ${maxDepth})`);
+    assertEx3(minDepth >= 0 && minDepth <= 2, () => `minDepth must be 0, 1, or 2 (got ${minDepth})`);
+    assertEx3(maxDepth >= minDepth, () => `maxDepth (${maxDepth}) must be >= minDepth (${minDepth})`);
+    const sources = /* @__PURE__ */ new Map();
+    const bw = await this.resolveBoundWitness(input, sources);
+    if (maxDepth === 0) {
+      return [this.asHydrated([bw, []], true), sources];
+    }
+    const orderedHashes = /* @__PURE__ */ new Set();
+    const orderedPayloads = [];
+    await this.appendDirectPayloads(bw, sources, minDepth, orderedHashes, orderedPayloads);
+    if (maxDepth === 2) {
+      await this.appendNestedPayloads(sources, minDepth, orderedHashes, orderedPayloads);
+    }
+    return [this.asHydrated([bw, orderedPayloads], true), sources];
+  }
+  async resolveBoundWitness(input, sources) {
+    if (typeof input === "string") {
+      const fetched = assertEx3(
+        await this.fetchByHash(input, sources),
+        () => `BoundWitness ${input} not found in any datalake`
+      );
+      return this.asBoundWitness(fetched, true);
+    }
+    const withMeta = "_hash" in input ? input : await PayloadBuilder.addStorageMeta(input);
+    return this.asBoundWitness(withMeta, true);
+  }
+};
+
+// src/block/hydrate/createBlockHydrator.ts
+import { asBlockBoundWitnessWithStorageMeta, asHydratedBlockWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+function createBlockHydrator(params) {
+  return new BoundWitnessHydrator({
+    ...params,
+    asBoundWitness: asBlockBoundWitnessWithStorageMeta,
+    asHydrated: asHydratedBlockWithStorageMeta
+  });
+}
+
+// src/block/hydrate/createBoundWitnessHydrator.ts
+import { zodAsFactory } from "@xylabs/sdk-js";
+import {
+  BoundWitnessZod,
+  PayloadZod,
+  WithStorageMetaZod
+} from "@xyo-network/sdk-js";
+import { z } from "zod";
+var BoundWitnessWithStorageMetaZod = WithStorageMetaZod(BoundWitnessZod);
+var asBoundWitnessWithStorageMeta = zodAsFactory(BoundWitnessWithStorageMetaZod, "asBoundWitnessWithStorageMeta");
+var HydratedBoundWitnessWithStorageMetaZod = z.tuple([
+  BoundWitnessWithStorageMetaZod,
+  z.array(WithStorageMetaZod(PayloadZod).loose())
+]);
+var asHydratedBoundWitnessWithStorageMeta = zodAsFactory(
+  HydratedBoundWitnessWithStorageMetaZod,
+  "asHydratedBoundWitnessWithStorageMeta"
+);
+function createBoundWitnessHydrator(params) {
+  return new BoundWitnessHydrator({
+    ...params,
+    asBoundWitness: asBoundWitnessWithStorageMeta,
+    asHydrated: asHydratedBoundWitnessWithStorageMeta
+  });
+}
+
+// src/block/hydrate/createTransactionHydrator.ts
+import { asHydratedTransactionWithStorageMeta, asTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+function createTransactionHydrator(params) {
+  return new BoundWitnessHydrator({
+    ...params,
+    asBoundWitness: asTransactionBoundWitnessWithStorageMeta,
+    asHydrated: asHydratedTransactionWithStorageMeta
+  });
+}
+
 // src/block/hydrate/flattenHydratedBlock.ts
 import { toHydratedBlock } from "@xyo-network/xl1-protocol-lib";
 var flattenHydratedBlock = (hydratedBlock) => {
@@ -350,14 +447,14 @@ var flattenHydratedBlocks = (hydratedBlocks) => hydratedBlocks.flatMap((blk) =>
 // src/block/hydrate/hydrateBlock.ts
 import { assertEx as assertEx4 } from "@xylabs/sdk-js";
 import { asAnyPayload } from "@xyo-network/sdk-js";
-import { asBlockBoundWitnessWithStorageMeta, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
+import { asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2, isTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-protocol-lib";
 var hydrateBlock = async (context, hash, maxDepth = 1, minDepth = maxDepth) => {
   assertEx4(maxDepth >= 0, () => "maxDepth must be greater than or equal to 0");
   assertEx4(minDepth >= 0, () => "minDepth must be greater than or equal to 0");
   assertEx4(maxDepth >= minDepth, () => "maxDepth must be greater than or equal to minDepth");
   const { chainMap } = context;
   const [block] = await chainMap.get([hash]);
-  const bw = assertEx4(asBlockBoundWitnessWithStorageMeta(
+  const bw = assertEx4(asBlockBoundWitnessWithStorageMeta2(
     assertEx4(block, () => `block ${hash} not found`)
   ), () => `hash ${hash} is not a BlockBoundWitness`);
   if (maxDepth === 0) return [bw, []];
@@ -425,11 +522,11 @@ import {
 } from "@xylabs/sdk-js";
 
 // src/driver/cache/LruCacheMap.ts
-import { LRUCache } from "lru-cache";
+import { LRUCache as LRUCache2 } from "lru-cache";
 var LruCacheMap = class {
   lruCache;
   constructor(options) {
-    this.lruCache = new LRUCache(options ?? { max: 5e3 });
+    this.lruCache = new LRUCache2(options ?? { max: 5e3 });
   }
   clear() {
     this.lruCache.clear();
@@ -654,7 +751,7 @@ import {
   toSafeJsonString as toSafeJsonString2
 } from "@xylabs/sdk-js";
 import {
-  PayloadBuilder
+  PayloadBuilder as PayloadBuilder2
 } from "@xyo-network/sdk-js";
 import { isExecutable } from "@xyo-network/xl1-protocol-lib";
 async function validateTransactionsOpcodes(txs) {
@@ -666,7 +763,7 @@ async function validateTransactionsOpcodes(txs) {
         switch (opCode) {
           case "elevate": {
             const [hash, ...rest] = args;
-            const txPayloadsWithStorageMeta = await PayloadBuilder.addStorageMeta(txPayloads);
+            const txPayloadsWithStorageMeta = await PayloadBuilder2.addStorageMeta(txPayloads);
             assertEx6(rest.length === 0, () => `Invalid elevate operation ${opCode} ${args.join(", ")} - Too many Arguments`);
             if (isHash(hash)) {
               assertEx6(
@@ -695,7 +792,7 @@ async function validateTransactionsOpcodes(txs) {
 
 // src/config/Actor.ts
 import {
-  zodAsFactory as zodAsFactory2,
+  zodAsFactory as zodAsFactory3,
   zodIsFactory as zodIsFactory2,
   zodToFactory as zodToFactory2
 } from "@xylabs/sdk-js";
@@ -819,7 +916,7 @@ import z10 from "zod";
 
 // src/config/Provider.ts
 import {
-  zodAsFactory,
+  zodAsFactory as zodAsFactory2,
   zodIsFactory,
   zodToFactory
 } from "@xylabs/sdk-js";
@@ -829,7 +926,7 @@ var ProviderConfigZod = z9.object({
   labels: z9.array(z9.string()).optional()
 }).describe("Configuration for a Provider");
 var isProviderConfig = zodIsFactory(ProviderConfigZod);
-var asProviderConfig = zodAsFactory(ProviderConfigZod, "asProviderConfig");
+var asProviderConfig = zodAsFactory2(ProviderConfigZod, "asProviderConfig");
 var toProviderConfig = zodToFactory(ProviderConfigZod, "toProviderConfig");
 
 // src/config/Providers.ts
@@ -1463,12 +1560,12 @@ async function externalBlockRangeFromStep(context, blockViewer, stepIdentity) {
 
 // src/primitives/datalake/addDataLakePayloadsToPayloads.ts
 import { isUndefined as isUndefined3 } from "@xylabs/sdk-js";
-import { isAnyPayload, PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload2, PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
 async function addDataLakePayloadsToPayloads(hashes, payloads, dataLakeViewer) {
   if (isUndefined3(dataLakeViewer)) return [payloads, []];
   const missingPayloadHashes = hashes.filter((hash) => !payloads.some((p) => p._hash === hash));
-  const payloadsFromDataLake = await PayloadBuilder2.addHashMeta(
-    await PayloadBuilder2.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload))
+  const payloadsFromDataLake = await PayloadBuilder3.addHashMeta(
+    await PayloadBuilder3.addHashMeta((await dataLakeViewer.get(missingPayloadHashes)).filter(isAnyPayload2))
   );
   return [[...payloads, ...payloadsFromDataLake], payloadsFromDataLake.map((p) => p._hash)];
 }
@@ -1940,14 +2037,19 @@ var ActorConfigZod = BaseConfigZod.extend({
     title: "accountPath",
     type: "string"
   }),
+  /**
+   * @deprecated Use the top-level `healthCheckPort` on `ConfigZod` instead.
+   * The system-wide health server covers all actors in a single process; per-actor
+   * health ports will be removed in a future major release.
+   */
   healthCheckPort: z17.coerce.number().optional().register(globalRegistry12, {
-    description: "Port for the Producer health checks",
-    title: "producer.healthCheckPort",
+    description: "[DEPRECATED \u2014 use top-level healthCheckPort] Per-actor health server port.",
+    title: "actor.healthCheckPort",
     type: "number"
   })
 });
 var isActorConfig = zodIsFactory2(ActorConfigZod);
-var asActorConfig = zodAsFactory2(ActorConfigZod, "asActorConfig");
+var asActorConfig = zodAsFactory3(ActorConfigZod, "asActorConfig");
 var toActorConfig = zodToFactory2(ActorConfigZod, "toActorConfig");
 
 // src/config/Actors.ts
@@ -1955,7 +2057,15 @@ import z18 from "zod";
 var ActorsConfigZod = z18.array(ActorConfigZod.loose()).describe("Actor-specific configurations that override the base configuration when the actor is running").default([]);
 
 // src/config/Config.ts
-var ConfigZod = BaseConfigZod.extend({ actors: ActorsConfigZod }).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
+import { globalRegistry as globalRegistry13, z as z19 } from "zod";
+var ConfigZod = BaseConfigZod.extend({
+  actors: ActorsConfigZod,
+  healthCheckPort: z19.coerce.number().optional().register(globalRegistry13, {
+    description: "Port for the system-wide health, readiness, and liveness endpoints (/healthz, /livez, /readyz). Set to 0 to disable.",
+    title: "healthCheckPort",
+    type: "number"
+  })
+}).describe("The complete configuration for the protocol, including global settings and actor-specific overrides");
 function resolveConfig(config) {
   const parsedConfig = ConfigZod.parse(config);
   const { actors, ...rootConfig } = parsedConfig;
@@ -1967,19 +2077,19 @@ function resolveConfig(config) {
 
 // src/config/HostActor.ts
 import {
-  zodAsFactory as zodAsFactory3,
+  zodAsFactory as zodAsFactory4,
   zodIsFactory as zodIsFactory3,
   zodToFactory as zodToFactory3
 } from "@xylabs/sdk-js";
-import { globalRegistry as globalRegistry13, z as z19 } from "zod";
+import { globalRegistry as globalRegistry14, z as z20 } from "zod";
 var HostActorConfigZod = ActorConfigZod.extend({
-  host: z19.string().default("localhost").register(globalRegistry13, {
+  host: z20.string().default("localhost").register(globalRegistry14, {
     default: "localhost",
     description: "Host for the Actor",
     title: "host",
     type: "string"
   }),
-  port: z19.coerce.number().default(8080).register(globalRegistry13, {
+  port: z20.coerce.number().default(8080).register(globalRegistry14, {
     default: 8080,
     description: "Port for the Actor",
     title: "port",
@@ -1987,34 +2097,34 @@ var HostActorConfigZod = ActorConfigZod.extend({
   })
 });
 var isHostActorConfig = zodIsFactory3(HostActorConfigZod);
-var asHostActorConfig = zodAsFactory3(HostActorConfigZod, "asHostActorConfig");
+var asHostActorConfig = zodAsFactory4(HostActorConfigZod, "asHostActorConfig");
 var toHostActorConfig = zodToFactory3(HostActorConfigZod, "toHostActorConfig");
 
 // src/config/UsageMeta.ts
-import { z as z20 } from "zod";
-var DescriptionSchema = z20.string();
-var TitleSchema = z20.string();
-var JSONSchemaMetaSchema = z20.object({
-  id: z20.string().optional(),
+import { z as z21 } from "zod";
+var DescriptionSchema = z21.string();
+var TitleSchema = z21.string();
+var JSONSchemaMetaSchema = z21.object({
+  id: z21.string().optional(),
   title: TitleSchema.optional(),
   description: DescriptionSchema.optional(),
-  deprecated: z20.boolean().optional()
-}).catchall(z20.unknown());
+  deprecated: z21.boolean().optional()
+}).catchall(z21.unknown());
 var GlobalMetaSchema = JSONSchemaMetaSchema.extend({});
-var ChoicesSchema = z20.array(z20.union([z20.string(), z20.number(), z20.literal(true), z20.undefined()])).readonly();
+var ChoicesSchema = z21.array(z21.union([z21.string(), z21.number(), z21.literal(true), z21.undefined()])).readonly();
 var UsageMetaSchema = GlobalMetaSchema.extend({
   choices: ChoicesSchema.optional(),
-  default: z20.unknown().optional(),
+  default: z21.unknown().optional(),
   description: DescriptionSchema,
-  group: z20.string().optional(),
-  hidden: z20.boolean().optional(),
+  group: z21.string().optional(),
+  hidden: z21.boolean().optional(),
   title: TitleSchema,
-  type: z20.union([
-    z20.literal("array"),
-    z20.literal("count"),
-    z20.literal("boolean"),
-    z20.literal("number"),
-    z20.literal("string")
+  type: z21.union([
+    z21.literal("array"),
+    z21.literal("count"),
+    z21.literal("boolean"),
+    z21.literal("number"),
+    z21.literal("string")
   ])
 });
 function isUsageMeta(v) {
@@ -2023,42 +2133,42 @@ function isUsageMeta(v) {
 
 // src/context/Actor.ts
 import {
-  zodAsFactory as zodAsFactory5,
+  zodAsFactory as zodAsFactory6,
   zodIsFactory as zodIsFactory5,
   zodToFactory as zodToFactory5
 } from "@xylabs/sdk-js";
 
 // src/model/CreatableProviderContext.zod.ts
 import {
-  zodAsFactory as zodAsFactory4,
+  zodAsFactory as zodAsFactory5,
   zodIsFactory as zodIsFactory4,
   zodToFactory as zodToFactory4
 } from "@xylabs/sdk-js";
 import { CachingContextZod } from "@xyo-network/xl1-protocol-lib";
-import { z as z21 } from "zod";
-var RuntimeStatusMonitorZod = z21.custom((val) => val && typeof val === "object");
-var ProviderFactoryLocatorZod = z21.lazy(() => z21.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
+import { z as z22 } from "zod";
+var RuntimeStatusMonitorZod = z22.custom((val) => val && typeof val === "object");
+var ProviderFactoryLocatorZod = z22.lazy(() => z22.custom((val) => val && typeof val === "object" && "context" in val && "registry" in val));
 var BaseConfigContextZod = CachingContextZod.extend({
   config: BaseConfigZod.loose(),
   locator: ProviderFactoryLocatorZod.optional()
 });
-var CreatableProviderContextZod = z21.lazy(() => BaseConfigContextZod.extend({
-  _id: z21.string().optional(),
+var CreatableProviderContextZod = z22.lazy(() => BaseConfigContextZod.extend({
+  _id: z22.string().optional(),
   locator: ProviderFactoryLocatorZod,
   statusReporter: RuntimeStatusMonitorZod.optional()
 }));
 var isBaseConfigContext = zodIsFactory4(BaseConfigContextZod);
-var asBaseConfigContext = zodAsFactory4(BaseConfigContextZod, "asBaseConfigContext");
+var asBaseConfigContext = zodAsFactory5(BaseConfigContextZod, "asBaseConfigContext");
 var toBaseConfigContext = zodToFactory4(BaseConfigContextZod, "toBaseConfigContext");
 var isCreatableProviderContext = zodIsFactory4(CreatableProviderContextZod);
-var asCreatableProviderContext = zodAsFactory4(CreatableProviderContextZod, "asCreatableProviderContext");
+var asCreatableProviderContext = zodAsFactory5(CreatableProviderContextZod, "asCreatableProviderContext");
 var toCreatableProviderContext = zodToFactory4(CreatableProviderContextZod, "toCreatableProviderContext");
 
 // src/model/PayloadBundle/bundledPayloadToHydratedBlock.ts
-import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
 import { asSignedBlockBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol-lib";
 var bundledPayloadToHydratedBlock = async (payload) => {
-  const withHashMeta = await PayloadBuilder3.addHashMeta(payload.payloads);
+  const withHashMeta = await PayloadBuilder4.addHashMeta(payload.payloads);
   const tx = asSignedBlockBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [tx, withHashMeta.filter((p) => p._hash !== payload.root)];
@@ -2066,10 +2176,10 @@ var bundledPayloadToHydratedBlock = async (payload) => {
 };
 
 // src/model/PayloadBundle/bundledPayloadToHydratedTransaction.ts
-import { PayloadBuilder as PayloadBuilder4 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
 import { asSignedTransactionBoundWitnessWithHashMeta } from "@xyo-network/xl1-protocol-lib";
 var bundledPayloadToHydratedTransaction = async (payload) => {
-  const withHashMeta = await PayloadBuilder4.addHashMeta(payload.payloads);
+  const withHashMeta = await PayloadBuilder5.addHashMeta(payload.payloads);
   const tx = asSignedTransactionBoundWitnessWithHashMeta(withHashMeta.find((p) => p._hash === payload.root));
   if (tx) {
     return [tx, withHashMeta.filter((p) => p._hash !== payload.root)];
@@ -2078,26 +2188,26 @@ var bundledPayloadToHydratedTransaction = async (payload) => {
 
 // src/model/PayloadBundle/hydratedBlockToPayloadBundle.ts
 import { PayloadBundleSchema } from "@xyo-network/sdk-js";
-import { PayloadBuilder as PayloadBuilder5 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder6 } from "@xyo-network/sdk-js";
 var hydratedBlockToPayloadBundle = (transaction) => {
   const root = transaction[0]._hash;
   return bundle(root, transaction);
 };
 var bundle = (root, transaction) => {
-  const payloads = flattenHydratedBlock(transaction).flatMap((p) => PayloadBuilder5.omitStorageMeta(p));
-  return new PayloadBuilder5({ schema: PayloadBundleSchema }).fields({ payloads, root }).build();
+  const payloads = flattenHydratedBlock(transaction).flatMap((p) => PayloadBuilder6.omitStorageMeta(p));
+  return new PayloadBuilder6({ schema: PayloadBundleSchema }).fields({ payloads, root }).build();
 };
 
 // src/model/PayloadBundle/hydratedTransactionToPayloadBundle.ts
 import { PayloadBundleSchema as PayloadBundleSchema2 } from "@xyo-network/sdk-js";
-import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
 
 // src/transaction/buildTransaction.ts
 import { assertEx as assertEx18, toHex } from "@xylabs/sdk-js";
 import {
   asAnyPayload as asAnyPayload2,
   BoundWitnessBuilder,
-  PayloadBuilder as PayloadBuilder6
+  PayloadBuilder as PayloadBuilder7
 } from "@xyo-network/sdk-js";
 import { defaultTransactionFees } from "@xyo-network/xl1-protocol-lib";
 async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer, nbf, exp, from, fees = defaultTransactionFees) {
@@ -2115,7 +2225,7 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder6.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder7.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
@@ -2128,12 +2238,12 @@ async function buildTransaction(chain, onChainPayloads, offChainPayloads, signer
     fields.script = script;
   }
   const [tx, txPayloads] = await new BoundWitnessBuilder().fields(fields).meta({ $signatures: [] }).payloads([...onChainPayloads, ...offChainPayloads]).signers(Array.isArray(signer) ? signer : [signer]).build();
-  return [await PayloadBuilder6.addHashMeta(tx), await PayloadBuilder6.addHashMeta(txPayloads.map((p) => asAnyPayload2(p, true)))];
+  return [await PayloadBuilder7.addHashMeta(tx), await PayloadBuilder7.addHashMeta(txPayloads.map((p) => asAnyPayload2(p, true)))];
 }
 
 // src/transaction/buildUnsignedTransaction.ts
 import { toHex as toHex2 } from "@xylabs/sdk-js";
-import { BoundWitnessBuilder as BoundWitnessBuilder2, PayloadBuilder as PayloadBuilder7 } from "@xyo-network/sdk-js";
+import { BoundWitnessBuilder as BoundWitnessBuilder2, PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
 import { defaultTransactionFees as defaultTransactionFees2 } from "@xyo-network/xl1-protocol-lib";
 async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads, nbf, exp, from, fees = defaultTransactionFees2) {
   const txBoundWitnessFields = {
@@ -2147,7 +2257,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
     nbf,
     exp
   };
-  const elevatedHashes = await PayloadBuilder7.hashes(onChainPayloads);
+  const elevatedHashes = await PayloadBuilder8.hashes(onChainPayloads);
   const script = [];
   for (const elevatedHash of elevatedHashes) {
     script.push(`elevate|${elevatedHash}`);
@@ -2164,7 +2274,7 @@ async function buildUnsignedTransaction(chain, onChainPayloads, offChainPayloads
 }
 
 // src/transaction/confirmSubmittedTransaction.ts
-import { delay as delay2, isDefined as isDefined14 } from "@xylabs/sdk-js";
+import { delay, isDefined as isDefined14 } from "@xylabs/sdk-js";
 var DEFAULT_CONFIRMATION_ATTEMPTS = 20;
 var DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1e3;
 var confirmSubmittedTransaction = async (viewer, txHash, options) => {
@@ -2183,7 +2293,7 @@ var confirmSubmittedTransaction = async (viewer, txHash, options) => {
         throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`);
       } else {
         options?.logger?.debug(`Transaction not confirmed yet, attempt ${attempts}. Retrying...`, txHash);
-        await delay2(attemptDelay);
+        await delay(attemptDelay);
       }
     }
   }
@@ -2269,11 +2379,11 @@ var hydrateElevatedTransaction = async (context, hash) => {
 };
 
 // src/transaction/primitives/transactionBlockByteCount.ts
-import { PayloadBuilder as PayloadBuilder8 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
 function transactionBlockByteCount([transaction, payloads]) {
-  const cleanTransaction = PayloadBuilder8.omitStorageMeta(transaction);
+  const cleanTransaction = PayloadBuilder9.omitStorageMeta(transaction);
   const transactionBytes = JSON.stringify(cleanTransaction).length;
-  const cleanPayloads = PayloadBuilder8.omitStorageMeta(payloads);
+  const cleanPayloads = PayloadBuilder9.omitStorageMeta(payloads);
   return cleanPayloads.reduce((acc, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes;
 }
 
@@ -2322,13 +2432,13 @@ import {
   hexFromArrayBuffer,
   toArrayBuffer
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder9 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
 async function signTransaction(tx, account) {
   assertEx20(tx.from === account.address, () => "Signer address does not match transaction from address");
   const unsignedTx = structuredClone(tx);
   unsignedTx.addresses = [account.address];
   unsignedTx.previous_hashes = [account.previousHash ?? null];
-  const hash = await PayloadBuilder9.dataHash(unsignedTx);
+  const hash = await PayloadBuilder10.dataHash(unsignedTx);
   const hashBytes = toArrayBuffer(hash);
   const [signature] = await account.sign(hashBytes);
   const result = {
@@ -2340,7 +2450,7 @@ async function signTransaction(tx, account) {
 
 // src/transaction/TransactionBuilder.ts
 import { assertEx as assertEx21, Base } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder10 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder11 } from "@xyo-network/sdk-js";
 import {
   asXL1BlockNumber as asXL1BlockNumber4,
   defaultTransactionFees as defaultTransactionFees3,
@@ -2438,8 +2548,8 @@ var TransactionBuilder = class extends Base {
     return this;
   }
   async removeElevatedPayload(payload) {
-    const hash = await PayloadBuilder10.hash(payload);
-    const existingHashes = await PayloadBuilder10.hashes(this._elevatedPayloads);
+    const hash = await PayloadBuilder11.hash(payload);
+    const existingHashes = await PayloadBuilder11.hashes(this._elevatedPayloads);
     const existingPayloadIndex = existingHashes.indexOf(hash);
     if (existingPayloadIndex === -1) {
       throw new Error("Payload not found in the transaction");
@@ -2448,8 +2558,8 @@ var TransactionBuilder = class extends Base {
     return this;
   }
   async removePayload(payload) {
-    const hash = await PayloadBuilder10.hash(payload);
-    const existingHashes = await PayloadBuilder10.hashes(this._payloads);
+    const hash = await PayloadBuilder11.hash(payload);
+    const existingHashes = await PayloadBuilder11.hashes(this._payloads);
     const existingPayloadIndex = existingHashes.indexOf(hash);
     if (existingPayloadIndex === -1) {
       throw new Error("Payload not found in the transaction");
@@ -2481,20 +2591,20 @@ var hydratedTransactionToPayloadBundle = (transaction) => {
 };
 var bundle2 = (root, transaction) => {
   const payloads = flattenHydratedTransaction(transaction);
-  return new PayloadBuilder11({ schema: PayloadBundleSchema2 }).fields({ payloads, root }).build();
+  return new PayloadBuilder12({ schema: PayloadBundleSchema2 }).fields({ payloads, root }).build();
 };
 
 // src/context/Actor.ts
 var ActorConfigContext = BaseConfigContextZod.extend({ config: ActorConfigZod });
 var isActorConfigContext = zodIsFactory5(ActorConfigContext);
-var asActorConfigContext = zodAsFactory5(ActorConfigContext, "asActorConfigContext");
+var asActorConfigContext = zodAsFactory6(ActorConfigContext, "asActorConfigContext");
 var toActorConfigContext = zodToFactory5(ActorConfigContext, "toActorConfigContext");
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
 import {
-  AbstractCreatable as AbstractCreatable2,
+  AbstractCreatable,
   assertEx as assertEx23,
-  IdLogger as IdLogger2
+  IdLogger
 } from "@xylabs/sdk-js";
 
 // src/CreatableProvider/ProviderFactory.ts
@@ -2582,14 +2692,14 @@ var ProviderFactory = class _ProviderFactory {
 };
 
 // src/CreatableProvider/AbstractCreatableProvider.ts
-var AbstractCreatableProvider = class extends AbstractCreatable2 {
+var AbstractCreatableProvider = class extends AbstractCreatable {
   dependencies = {};
   _contextCache;
   _logger;
   get logger() {
     if (this._logger === void 0) {
       const providedLogger = this.params.logger ?? this.context.logger;
-      this._logger = providedLogger ? new IdLogger2(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
+      this._logger = providedLogger ? new IdLogger(providedLogger, () => `${this.moniker} [${this.constructor.name}]`) : null;
     }
     return this._logger ?? void 0;
   }
@@ -2870,24 +2980,24 @@ function getEmptyContext(config) {
 
 // src/context/HostActor.ts
 import {
-  zodAsFactory as zodAsFactory6,
+  zodAsFactory as zodAsFactory7,
   zodIsFactory as zodIsFactory6,
   zodToFactory as zodToFactory6
 } from "@xylabs/sdk-js";
 var HostActorConfigContext = BaseConfigContextZod.extend({ config: HostActorConfigZod });
 var isHostActorConfigContext = zodIsFactory6(HostActorConfigContext);
-var asHostActorConfigContext = zodAsFactory6(HostActorConfigContext, "asHostActorConfigContext");
+var asHostActorConfigContext = zodAsFactory7(HostActorConfigContext, "asHostActorConfigContext");
 var toHostActorConfigContext = zodToFactory6(HostActorConfigContext, "toHostActorConfigContext");
 
 // src/createDeclarationPayload.ts
 import { isDefined as isDefined15 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder12 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
 import {
   ChainStakeIntentSchema
 } from "@xyo-network/xl1-protocol-lib";
 var createDeclarationIntent = (address, intent, nbf, exp) => {
   const expiration = isDefined15(exp) ? exp : nbf + 1e4;
-  const redeclarationIntent = new PayloadBuilder12({ schema: ChainStakeIntentSchema }).fields({
+  const redeclarationIntent = new PayloadBuilder13({ schema: ChainStakeIntentSchema }).fields({
     from: address,
     intent,
     nbf,
@@ -2898,10 +3008,10 @@ var createDeclarationIntent = (address, intent, nbf, exp) => {
 
 // src/createTransferPayload.ts
 import { toHex as toHex3 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder13 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/sdk-js";
 import { TransferSchema } from "@xyo-network/xl1-protocol-lib";
 function createTransferPayload(from, transfers, context) {
-  return new PayloadBuilder13({ schema: TransferSchema }).fields({
+  return new PayloadBuilder14({ schema: TransferSchema }).fields({
     epoch: Date.now(),
     from,
     transfers: Object.fromEntries(Object.entries(transfers).map(([k, v]) => [k, toHex3(v)])),
@@ -2915,26 +3025,26 @@ import {
   asSchema as asSchema2,
   isPayloadOfZodType
 } from "@xyo-network/sdk-js";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/eip-712/Types.ts
-import { z as z22 } from "zod";
-var TypedDataDomainZod = z22.object({
-  name: z22.string().nullable().optional(),
-  version: z22.string().nullable().optional(),
-  chainId: z22.union([z22.string(), z22.number(), z22.bigint()]).nullable().optional(),
-  verifyingContract: z22.string().nullable().optional(),
-  salt: z22.union([z22.string(), z22.instanceof(Uint8Array)]).nullable().optional()
+import { z as z23 } from "zod";
+var TypedDataDomainZod = z23.object({
+  name: z23.string().nullable().optional(),
+  version: z23.string().nullable().optional(),
+  chainId: z23.union([z23.string(), z23.number(), z23.bigint()]).nullable().optional(),
+  verifyingContract: z23.string().nullable().optional(),
+  salt: z23.union([z23.string(), z23.instanceof(Uint8Array)]).nullable().optional()
 });
-var TypedDataFieldZod = z22.object({
-  name: z22.string(),
-  type: z22.string()
+var TypedDataFieldZod = z23.object({
+  name: z23.string(),
+  type: z23.string()
 });
-var TypedDataTypesZod = z22.record(z22.string(), z22.array(TypedDataFieldZod));
-var TypedDataValueZod = z22.record(z22.string(), z22.any());
+var TypedDataTypesZod = z23.record(z23.string(), z23.array(TypedDataFieldZod));
+var TypedDataValueZod = z23.record(z23.string(), z23.any());
 
 // src/eip-712/Payloads/EIP712Data.ts
-var EIP712DataPayloadFieldsZod = z23.object({
+var EIP712DataPayloadFieldsZod = z24.object({
   domain: TypedDataDomainZod,
   types: TypedDataTypesZod,
   values: TypedDataValueZod
@@ -2952,11 +3062,11 @@ import {
   asSchema as asSchema3,
   isPayloadOfZodType as isPayloadOfZodType2
 } from "@xyo-network/sdk-js";
-import { z as z24 } from "zod";
-var EIP712SignaturePayloadFieldsZod = z24.object({
-  address: z24.string(),
+import { z as z25 } from "zod";
+var EIP712SignaturePayloadFieldsZod = z25.object({
+  address: z25.string(),
   hash: HashZod,
-  signature: z24.string()
+  signature: z25.string()
 });
 var EIP712SignaturePayloadSchema = asSchema3("network.xyo.chains.ethereum.eip712.signature", true);
 var isEIP712SignaturePayload = isPayloadOfZodType2(
@@ -2966,7 +3076,7 @@ var isEIP712SignaturePayload = isPayloadOfZodType2(
 var asEIP712SignaturePayload = AsObjectFactory3.create(isEIP712SignaturePayload);
 
 // src/eip-712/sign.ts
-import { PayloadBuilder as PayloadBuilder14 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
 var signEIP712Message = async (signer, data) => {
   const {
     domain,
@@ -2974,7 +3084,7 @@ var signEIP712Message = async (signer, data) => {
     values
   } = data;
   const signature = await signer.signTypedData(domain, types, values);
-  const hash = await PayloadBuilder14.hash(data);
+  const hash = await PayloadBuilder15.hash(data);
   const address = await signer.getAddress();
   return {
     address,
@@ -2986,7 +3096,7 @@ var signEIP712Message = async (signer, data) => {
 
 // src/eip-712/verify.ts
 import { asHash as asHash3, isUndefined as isUndefined5 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder15 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder16 } from "@xyo-network/sdk-js";
 import { verifyTypedData } from "ethers";
 var verifyEIP712Message = async (data, sig) => {
   const {
@@ -2996,7 +3106,7 @@ var verifyEIP712Message = async (data, sig) => {
   } = sig;
   const { schema, ...fields } = data;
   const signedHash = asHash3(hash);
-  if (isUndefined5(signedHash) || signedHash !== await PayloadBuilder15.hash(data)) return false;
+  if (isUndefined5(signedHash) || signedHash !== await PayloadBuilder16.hash(data)) return false;
   const recoveredAddress = verifyTypedData(fields.domain, fields.types, fields.values, signature);
   return recoveredAddress.toLowerCase() === address.toLowerCase();
 };
@@ -3082,7 +3192,7 @@ import {
   StepSizes as StepSizes11,
   TransferSchema as TransferSchema2
 } from "@xyo-network/xl1-protocol-lib";
-import { Semaphore as Semaphore2 } from "async-mutex";
+import { Semaphore } from "async-mutex";
 
 // src/summary/model/BalancesStepSummary.ts
 import { AsObjectFactory as AsObjectFactory5 } from "@xylabs/sdk-js";
@@ -3138,7 +3248,7 @@ var asTransfersStepSummaryWithStorageMeta = AsObjectFactory7.create(isTransfersS
 // src/summary/primitives/balances/balancesStepSummaryFromRange.ts
 import { spanRootAsync as spanRootAsync2 } from "@xylabs/sdk-js";
 import { assertEx as assertEx25 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload2 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload3 } from "@xyo-network/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber5, StepSizes as StepSizes8 } from "@xyo-network/xl1-protocol-lib";
 async function balancesStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
   const cacheKey = `${range[0]}|${range[1]}`;
@@ -3163,7 +3273,7 @@ async function balancesStepSummaryFromRange(context, semaphores, blockViewer, su
         const step = StepSizes8.indexOf(asXL1BlockNumber5(frameSize, true));
         assertEx25(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes8.join(", ")}`);
         const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`);
-        if (isAnyPayload2(summaryResult)) {
+        if (isAnyPayload3(summaryResult)) {
           return summaryResult;
         } else {
           await semaphores[step].acquire();
@@ -3206,12 +3316,12 @@ async function balancesStepSummaryFromRange(context, semaphores, blockViewer, su
 
 // src/summary/primitives/balances/balancesSummary.ts
 import {
-  asAddress as asAddress2,
+  asAddress,
   assertEx as assertEx26,
   spanRootAsync as spanRootAsync3
 } from "@xylabs/sdk-js";
 import {
-  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta2,
+  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3,
   asXL1BlockRange as asXL1BlockRange7,
   isChainQualifiedHeadConfig,
   isChainQualifiedRangeConfig
@@ -3220,7 +3330,7 @@ async function balancesSummary(context, semaphores, blockViewer, summaryMap, con
   return await spanRootAsync3("balancesSummary", async () => {
     const headHash = isChainQualifiedHeadConfig(config) ? config.head : await blockViewer.currentBlockHash();
     const [head] = assertEx26(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta2(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig(config) ? config.range : asXL1BlockRange7([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange7(
       range,
@@ -3230,7 +3340,7 @@ async function balancesSummary(context, semaphores, blockViewer, summaryMap, con
     const balances = {};
     for (const summary of summaries) {
       for (const [address, balance] of Object.entries(summary.balances)) {
-        const validAddress = asAddress2(address, () => `Invalid address: ${address}`);
+        const validAddress = asAddress(address, () => `Invalid address: ${address}`);
         balances[validAddress] = (balances[validAddress] ?? 0n) + parseSignedBigInt(balance);
       }
     }
@@ -3241,10 +3351,10 @@ async function balancesSummary(context, semaphores, blockViewer, summaryMap, con
 // src/summary/primitives/schemas/schemasStepSummaryFromRange.ts
 import { assertEx as assertEx27 } from "@xylabs/sdk-js";
 import {
-  isAnyPayload as isAnyPayload3,
-  isBoundWitness,
+  isAnyPayload as isAnyPayload4,
+  isBoundWitness as isBoundWitness2,
   isHashMeta,
-  PayloadBuilder as PayloadBuilder16
+  PayloadBuilder as PayloadBuilder17
 } from "@xyo-network/sdk-js";
 import { StepSizes as StepSizes9 } from "@xyo-network/xl1-protocol-lib";
 async function schemasStepSummaryFromRange(context, semaphores, blockViewer, summaryMap, range) {
@@ -3253,7 +3363,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
   let result;
   if (frameSize === 1) {
     const [block, payloads] = assertEx27(await blockViewer.blockByNumber(range[0]), () => `Block not found for number: ${range[0]}`);
-    const boundWitnesses = [block, ...payloads.filter((x) => isBoundWitness(x) && isHashMeta(x))];
+    const boundWitnesses = [block, ...payloads.filter((x) => isBoundWitness2(x) && isHashMeta(x))];
     const schemas = {};
     for (const bw of boundWitnesses) {
       schemas[bw.schema] = (schemas[bw.schema] ?? 0) + 1;
@@ -3261,7 +3371,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
         schemas[schema] = (schemas[schema] ?? 0) + 1;
       }
     }
-    result = await PayloadBuilder16.addHashMeta({
+    result = await PayloadBuilder17.addHashMeta({
       schema: SchemasStepSummarySchema,
       hash: frameHead._hash,
       stepSize: -1,
@@ -3271,7 +3381,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
     const step = StepSizes9.indexOf(frameSize);
     assertEx27(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes9.join(", ")}`);
     const summaryResult = await summaryMap.get(`${frameHead._hash}|${frameSize}`);
-    if (isAnyPayload3(summaryResult)) {
+    if (isAnyPayload4(summaryResult)) {
       result = summaryResult;
     } else {
       await semaphores[step].acquire();
@@ -3292,7 +3402,7 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
             schemas[typedSchema] = (schemas[typedSchema] ?? 0) + count;
           }
         }
-        result = await PayloadBuilder16.addHashMeta({
+        result = await PayloadBuilder17.addHashMeta({
           schema: SchemasStepSummarySchema,
           hash: frameHead._hash,
           stepSize: frameSize,
@@ -3304,13 +3414,13 @@ async function schemasStepSummaryFromRange(context, semaphores, blockViewer, sum
       }
     }
   }
-  return await PayloadBuilder16.addHashMeta(result);
+  return await PayloadBuilder17.addHashMeta(result);
 }
 
 // src/summary/primitives/schemas/schemasSummary.ts
 import { assertEx as assertEx28, spanRootAsync as spanRootAsync4 } from "@xylabs/sdk-js";
 import {
-  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta3,
+  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4,
   asXL1BlockRange as asXL1BlockRange8,
   isChainQualifiedHeadConfig as isChainQualifiedHeadConfig2,
   isChainQualifiedRangeConfig as isChainQualifiedRangeConfig2
@@ -3319,7 +3429,7 @@ async function schemasSummary(context, semaphores, blockViewer, summaryMap, conf
   return await spanRootAsync4("schemasSummary", async () => {
     const headHash = isChainQualifiedHeadConfig2(config) ? config.head : await blockViewer.currentBlockHash();
     const [head] = assertEx28(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta3(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig2(config) ? config.range : asXL1BlockRange8([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange8(
       range,
@@ -3339,7 +3449,7 @@ async function schemasSummary(context, semaphores, blockViewer, summaryMap, conf
 
 // src/summary/primitives/transfers/transfersStepSummaryFromRange.ts
 import { assertEx as assertEx29, spanRootAsync as spanRootAsync5 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload4 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload5 } from "@xyo-network/sdk-js";
 import { asXL1BlockNumber as asXL1BlockNumber6, StepSizes as StepSizes10 } from "@xyo-network/xl1-protocol-lib";
 function transfersSummaryKey(frameHeadHash, frameSize) {
   return `${frameHeadHash}|${frameSize}`;
@@ -3371,7 +3481,7 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
         assertEx29(step !== -1, () => `Invalid step size: ${frameSize}. Must be one of ${StepSizes10.join(", ")}`);
         const key = transfersSummaryKey(frameHead._hash, frameSize);
         const summaryResult = await summaryMap.get(key);
-        if (isAnyPayload4(summaryResult)) {
+        if (isAnyPayload5(summaryResult)) {
           result = asTransfersStepSummary(summaryResult, { required: true });
         } else {
           await semaphores[step].acquire();
@@ -3420,12 +3530,12 @@ async function transfersStepSummaryFromRange(context, semaphores, blockViewer, s
 
 // src/summary/primitives/transfers/transfersSummary.ts
 import {
-  asAddress as asAddress3,
+  asAddress as asAddress2,
   assertEx as assertEx30,
   spanRootAsync as spanRootAsync6
 } from "@xylabs/sdk-js";
 import {
-  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta4,
+  asBlockBoundWitnessWithStorageMeta as asBlockBoundWitnessWithStorageMeta5,
   asXL1BlockRange as asXL1BlockRange9,
   isChainQualifiedHeadConfig as isChainQualifiedHeadConfig3,
   isChainQualifiedRangeConfig as isChainQualifiedRangeConfig3
@@ -3434,7 +3544,7 @@ async function transfersSummary(context, semaphores, blockViewer, summaryMap, co
   return await spanRootAsync6("transferSummary", async () => {
     const headHash = isChainQualifiedHeadConfig3(config) ? config.head : await blockViewer.currentBlockHash();
     const [head] = assertEx30(await blockViewer.blockByHash(headHash), () => `Block not found for hash: ${headHash}`);
-    const headBoundWitness = asBlockBoundWitnessWithStorageMeta4(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
+    const headBoundWitness = asBlockBoundWitnessWithStorageMeta5(head, () => `Found Block not a BlockWithHashMeta: ${headHash}`);
     const range = isChainQualifiedRangeConfig3(config) ? config.range : asXL1BlockRange9([0, headBoundWitness.block], true);
     const ranges = deepCalculateFramesFromRange(asXL1BlockRange9(
       range,
@@ -3444,10 +3554,10 @@ async function transfersSummary(context, semaphores, blockViewer, summaryMap, co
     const transfers = {};
     for (const summary of summaries) {
       for (const [from, toMap] of Object.entries(summary.transfers)) {
-        const validFrom = asAddress3(from, () => `Invalid address: ${from}`);
+        const validFrom = asAddress2(from, () => `Invalid address: ${from}`);
         transfers[validFrom] = transfers[validFrom] ?? {};
         for (const [to, transfer] of Object.entries(toMap)) {
-          const validTo = asAddress3(to, () => `Invalid address: ${to}`);
+          const validTo = asAddress2(to, () => `Invalid address: ${to}`);
           transfers[validFrom][validTo] = (transfers[validFrom][validTo] ?? 0n) + parseSignedBigInt(transfer);
         }
       }
@@ -3459,9 +3569,9 @@ async function transfersSummary(context, semaphores, blockViewer, summaryMap, co
 // src/simple/accountBalance/SimpleAccountBalanceViewer.ts
 var SimpleAccountBalanceViewer = class extends AbstractCreatableProvider {
   moniker = SimpleAccountBalanceViewer.defaultMoniker;
-  _balanceStepSemaphores = StepSizes11.map(() => new Semaphore2(20));
+  _balanceStepSemaphores = StepSizes11.map(() => new Semaphore(20));
   _blockViewer;
-  _transferStepSemaphores = StepSizes11.map(() => new Semaphore2(20));
+  _transferStepSemaphores = StepSizes11.map(() => new Semaphore(20));
   get balancesSummaryMap() {
     return this.params.balancesSummaryMap;
   }
@@ -3672,7 +3782,7 @@ import {
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/utils/HydratedCache.ts
-import { LRUCache as LRUCache2 } from "lru-cache";
+import { LRUCache as LRUCache3 } from "lru-cache";
 var HydratedCache = class {
   cache;
   context;
@@ -3680,7 +3790,7 @@ var HydratedCache = class {
   constructor(context, hydrateFunction, maxCount = 2e3, ttl = Number.MAX_SAFE_INTEGER) {
     this.context = context;
     this.hydrateFunction = hydrateFunction;
-    this.cache = new LRUCache2({ max: maxCount, ttl });
+    this.cache = new LRUCache3({ max: maxCount, ttl });
   }
   async get(hash) {
     const existing = this.cache.get(hash);
@@ -3695,12 +3805,12 @@ var HydratedCache = class {
 };
 
 // src/utils/isZodError.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var isZodError = (error) => {
-  return error instanceof z25.ZodError;
+  return error instanceof z26.ZodError;
 };
 var prettifyZodError = (error) => {
-  return z25.prettifyError(error);
+  return z26.prettifyError(error);
 };
 
 // src/simple/block/SimpleBlockViewer.ts
@@ -3941,13 +4051,14 @@ SimpleBlockRewardViewer = __decorateClass([
 
 // src/simple/blockValidation/SimpleBlockValidationViewer.ts
 import { assertEx as assertEx33 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder17 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder18 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker2,
   asXL1BlockRange as asXL1BlockRange11,
   BlockValidationViewerMoniker,
   BlockViewerMoniker as BlockViewerMoniker3,
   ChainContractViewerMoniker,
+  HydratedBlockValidationError,
   isChainQualifiedHeadConfig as isChainQualifiedHeadConfig5,
   isHydratedBlock
 } from "@xyo-network/xl1-protocol-lib";
@@ -3991,7 +4102,7 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
       state: true,
       head: void 0
     };
-    const blocksWithMeta = await Promise.all(blocks.map((b) => Promise.all([PayloadBuilder17.addHashMeta(b[0]), PayloadBuilder17.addHashMeta(b[1])])));
+    const blocksWithMeta = await Promise.all(blocks.map((b) => Promise.all([PayloadBuilder18.addHashMeta(b[0]), PayloadBuilder18.addHashMeta(b[1])])));
     const head = isChainQualifiedHeadConfig5(config) ? assertEx33(
       (await this.blockViewer.blockByHash(config.head))?.[0],
       () => `Specified a head that is not in the chain [${config.head}]`
@@ -4046,7 +4157,7 @@ var SimpleBlockValidationViewer = class extends AbstractCreatableProvider {
       this.logger?.warn(`Unexpected uncle count during block validation [uncles=${uncles.length}, blocks=${blocks.length}]`);
       this.logger?.debug(JSON.stringify({ uncles, blocks: blocks.length }, null, 2));
       this.logger?.debug(JSON.stringify(windowedUncleChain, null, 2));
-      throw new Error(`No uncles or greater than one uncle found in block validation, which is not supported [${uncles.length}, ${blocks.length}]`);
+      return blocks.map((block) => [new HydratedBlockValidationError(block[0]._hash, block, "Unexpected uncle count during state validation", { uncles: uncles.length, blocks: blocks.length })]);
     }
     return await Promise.all(uncles[0].map(async (block) => {
       const errors = await this.params.state(
@@ -4150,18 +4261,18 @@ import {
   assertEx as assertEx35,
   exists as exists6
 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload6, PayloadZodLoose } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload7, PayloadZodLoose } from "@xyo-network/sdk-js";
 import {
   DataLakeRunnerMoniker
 } from "@xyo-network/xl1-protocol-lib";
-import z26 from "zod";
+import z27 from "zod";
 
 // src/simple/datalake/AbstractRestDataLake.ts
 import { axiosJsonConfig } from "@xylabs/sdk-js";
 import {
   exists as exists5
 } from "@xylabs/sdk-js";
-import { asAnyPayload as asAnyPayload4, isAnyPayload as isAnyPayload5 } from "@xyo-network/sdk-js";
+import { asAnyPayload as asAnyPayload4, isAnyPayload as isAnyPayload6 } from "@xyo-network/sdk-js";
 import { Axios } from "axios";
 var AbstractRestDataLake = class extends AbstractCreatableProvider {
   get allowedSchemas() {
@@ -4186,7 +4297,7 @@ var AbstractRestDataLake = class extends AbstractCreatableProvider {
     return asAnyPayload4((await this.axios.get(`${this.params.endpoint}/get/${hash}`)).data);
   }
   isAllowed(value) {
-    if (isAnyPayload5(value)) {
+    if (isAnyPayload6(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return false;
@@ -4213,7 +4324,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
   }
   async insert(items) {
     const allowedItems = items.map((item) => {
-      if (isAnyPayload6(item) && this.isAllowed(item)) {
+      if (isAnyPayload7(item) && this.isAllowed(item)) {
         assertEx35(typeof item === "object" && item !== null, () => "Data must be an object");
         return item;
       }
@@ -4221,7 +4332,7 @@ var RestDataLakeRunner = class extends AbstractRestDataLake {
     }).filter(exists6);
     if (allowedItems.length > 0) {
       const result = await this.axios.post(`${this.params.endpoint}/insert`, allowedItems);
-      return z26.array(PayloadZodLoose).parse(result.data);
+      return z27.array(PayloadZodLoose).parse(result.data);
     } else {
       return [];
     }
@@ -4250,13 +4361,13 @@ RestDataLakeViewer = __decorateClass([
 
 // src/simple/datalake/SimpleDataLakeRunner.ts
 import { exists as exists7 } from "@xylabs/sdk-js";
-import { isAnyPayload as isAnyPayload8, PayloadBuilder as PayloadBuilder18 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload9, PayloadBuilder as PayloadBuilder19 } from "@xyo-network/sdk-js";
 import {
   DataLakeRunnerMoniker as DataLakeRunnerMoniker2
 } from "@xyo-network/xl1-protocol-lib";
 
 // src/simple/datalake/AbstractSimpleDataLake.ts
-import { isAnyPayload as isAnyPayload7 } from "@xyo-network/sdk-js";
+import { isAnyPayload as isAnyPayload8 } from "@xyo-network/sdk-js";
 var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
   get allowedSchemas() {
     return this.params.allowedSchemas;
@@ -4275,7 +4386,7 @@ var AbstractSimpleDataLake = class extends AbstractCreatableProvider {
     throw new Error("Method not implemented.");
   }
   isAllowed(value) {
-    if (isAnyPayload7(value)) {
+    if (isAnyPayload8(value)) {
       return this.isAllowedSchema(value.schema);
     }
     return true;
@@ -4304,8 +4415,8 @@ var SimpleDataLakeRunner = class extends AbstractSimpleDataLake {
     }))).filter(exists7);
   }
   async insert(items) {
-    const payloads = items.filter(isAnyPayload8).filter((i) => this.isAllowed(i));
-    const hashPairs = await PayloadBuilder18.hashPairs(payloads);
+    const payloads = items.filter(isAnyPayload9).filter((i) => this.isAllowed(i));
+    const hashPairs = await PayloadBuilder19.hashPairs(payloads);
     for (const [payload, hash] of hashPairs) {
       await this.map.set(hash, payload);
     }
@@ -4474,7 +4585,7 @@ import {
   BigIntToJsonZod,
   isDefined as isDefined17
 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder19 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder20 } from "@xyo-network/sdk-js";
 import {
   asXL1BlockNumber as asXL1BlockNumber9,
   DataLakeRunnerMoniker as DataLakeRunnerMoniker3,
@@ -4514,7 +4625,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     const resolvedNbf = asXL1BlockNumber9(isDefined17(nbf) ? nbf : await viewer.currentBlockNumber(), true);
     const resolvedExp = asXL1BlockNumber9(isDefined17(exp) ? exp : resolvedNbf + 10, true);
     const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees);
-    return await this.addTransactionToChain(tx, await PayloadBuilder19.addHashMeta(offChain));
+    return await this.addTransactionToChain(tx, await PayloadBuilder20.addHashMeta(offChain));
   }
   async addTransactionToChain(tx, offChain = []) {
     const connection = this.connection;
@@ -4523,8 +4634,8 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
     let signedTx;
     if (isSignedHydratedTransaction(tx)) {
       const [bw, payloads] = tx;
-      const hashedBw = await PayloadBuilder19.addHashMeta(bw);
-      const hashedPayloads = await PayloadBuilder19.addHashMeta(payloads);
+      const hashedBw = await PayloadBuilder20.addHashMeta(bw);
+      const hashedPayloads = await PayloadBuilder20.addHashMeta(payloads);
       signedTx = [hashedBw, hashedPayloads];
     } else {
       signedTx = await signer.signTransaction(tx);
@@ -4556,7 +4667,7 @@ var SimpleXyoGatewayRunner = class _SimpleXyoGatewayRunner extends AbstractCreat
         BigIntToJsonZod.parse(amount)
       ])
     );
-    const transfer = new PayloadBuilder19({ schema: TransferSchema3 }).fields({
+    const transfer = new PayloadBuilder20({ schema: TransferSchema3 }).fields({
       from,
       transfers: hexTransfers,
       epoch: Date.now()
@@ -4573,16 +4684,18 @@ import {
 } from "@xylabs/sdk-js";
 import {
   isPayloadBundle,
-  PayloadBuilder as PayloadBuilder20
+  PayloadBuilder as PayloadBuilder21
 } from "@xyo-network/sdk-js";
 import {
   BlockValidationViewerMoniker as BlockValidationViewerMoniker2,
   ChainContractViewerMoniker as ChainContractViewerMoniker4,
+  DeadLetterQueueRunnerMoniker,
   DEFAULT_MAX_EXP_AHEAD,
   FinalizationViewerMoniker as FinalizationViewerMoniker4,
   isSignedHydratedBlockWithHashMeta,
   isSignedHydratedTransactionWithHashMeta,
   MempoolRunnerMoniker,
+  TransactionRejectionSchema,
   TransactionValidationViewerMoniker
 } from "@xyo-network/xl1-protocol-lib";
 import { Mutex } from "async-mutex";
@@ -4592,6 +4705,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   moniker = SimpleMempoolRunner.defaultMoniker;
   _blockValidationViewer;
   _chainContractViewer;
+  _deadLetterQueueRunner;
   _finalizationViewer;
   _transactionValidationViewer;
   _syncMutex = new Mutex();
@@ -4639,6 +4753,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     this._chainContractViewer = await this.locator.getInstance(ChainContractViewerMoniker4);
     this._finalizationViewer = await this.locator.getInstance(FinalizationViewerMoniker4);
     this._transactionValidationViewer = await this.locator.getInstance(TransactionValidationViewerMoniker);
+    this._deadLetterQueueRunner = await this.locator.tryGetInstance(DeadLetterQueueRunnerMoniker);
   }
   async prunePendingBlocks({
     batchSize = 10,
@@ -4741,6 +4856,7 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
         if (!validated) {
           this.logger?.debug(`Pruning transaction ${bundles[remainingTransactionMap[i]]._hash} during transaction validation`);
           this.logger?.debug(`  - validation result: ${r.at(0)?.message}`);
+          await this.routeRejectedTransaction(remainingTransactions[i], r);
         }
         valid[remainingTransactionMap[i]] = validated;
       }
@@ -4767,8 +4883,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
   async submitBlocks(blocks) {
     const bundles = await Promise.all(blocks.map(async ([bw, payloads]) => {
       return hydratedBlockToPayloadBundle([
-        await PayloadBuilder20.addHashMeta(bw),
-        await PayloadBuilder20.addHashMeta(payloads)
+        await PayloadBuilder21.addHashMeta(bw),
+        await PayloadBuilder21.addHashMeta(payloads)
       ]);
     }));
     const inserted = await this.pendingBlocksArchivist.insert(bundles);
@@ -4786,8 +4902,8 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
     });
     const bundles = await Promise.all(validTransactions.map(async ([tx, payloads]) => {
       return hydratedTransactionToPayloadBundle([
-        await PayloadBuilder20.addHashMeta(tx),
-        await PayloadBuilder20.addHashMeta(payloads)
+        await PayloadBuilder21.addHashMeta(tx),
+        await PayloadBuilder21.addHashMeta(payloads)
       ]);
     }));
     const inserted = await this.pendingTransactionsArchivist.insert(bundles);
@@ -4809,6 +4925,20 @@ var SimpleMempoolRunner = class extends AbstractCreatableProvider {
       this._syncTimerId = null;
     }
   }
+  async routeRejectedTransaction(transaction, errors) {
+    if (!this._deadLetterQueueRunner) return;
+    const rejectionErrors = errors.map((e) => ({
+      hash: transaction[0]._hash,
+      name: e.name ?? "TransactionStateValidationError",
+      message: String(e.message ?? e)
+    }));
+    await this._deadLetterQueueRunner.rejectTransaction({
+      schema: TransactionRejectionSchema,
+      transaction,
+      errors: rejectionErrors,
+      rejector: "mempool"
+    });
+  }
   async simpleBlockValidationCheck(payloads) {
     const headNumber = await this.finalizationViewer.headNumber();
     const chainId = await this.chainContractViewer.chainId();
@@ -5208,7 +5338,7 @@ var MemoryPermissionsStore = class {
 };
 
 // src/simple/runner/SimpleXyoRunner.ts
-import { PayloadBuilder as PayloadBuilder21 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder22 } from "@xyo-network/sdk-js";
 import {
   MempoolRunnerMoniker as MempoolRunnerMoniker2,
   XyoRunnerMoniker
@@ -5221,7 +5351,7 @@ var SimpleXyoRunner = class extends AbstractCreatableProvider {
   }
   async broadcastTransaction(transaction) {
     await this.mempool.submitTransactions([transaction]);
-    const hash = await PayloadBuilder21.hash(transaction[0]);
+    const hash = await PayloadBuilder22.hash(transaction[0]);
     this.logger?.info(`Broadcasted transaction with hash ${hash}`);
     return hash;
   }
@@ -5238,7 +5368,7 @@ SimpleXyoRunner = __decorateClass([
 ], SimpleXyoRunner);
 
 // src/simple/signer/SimpleXyoSigner.ts
-import { Account, PayloadBuilder as PayloadBuilder22 } from "@xyo-network/sdk-js";
+import { Account, PayloadBuilder as PayloadBuilder23 } from "@xyo-network/sdk-js";
 import {
   SignedHydratedTransactionWithHashMetaZod,
   XyoSignerMoniker as XyoSignerMoniker2
@@ -5281,7 +5411,7 @@ var SimpleXyoSigner = class _SimpleXyoSigner extends AbstractCreatableProvider {
   }
   async signTransaction(tx) {
     const txBW = await signTransaction(tx[0], this.params.account);
-    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder22.addStorageMeta(txBW), await PayloadBuilder22.addStorageMeta(tx[1])]);
+    return SignedHydratedTransactionWithHashMetaZod.parse([await PayloadBuilder23.addStorageMeta(txBW), await PayloadBuilder23.addStorageMeta(tx[1])]);
   }
 };
 
@@ -5366,7 +5496,7 @@ SimpleStakeEventsViewer = __decorateClass([
 ], SimpleStakeEventsViewer);
 
 // src/simple/StakeTotalsViewer/SimpleStakeTotalsViewer.ts
-import { asAddress as asAddress4 } from "@xylabs/sdk-js";
+import { asAddress as asAddress3 } from "@xylabs/sdk-js";
 import { assertEx as assertEx41 } from "@xylabs/sdk-js";
 import {
   StakeTotalsViewerMoniker,
@@ -5392,7 +5522,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
     let active = 0n;
     const positions = await this.stakeViewer.activeStakes();
     for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress4(position.staked) === asAddress4(staked)) {
+      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress3(position.staked) === asAddress3(staked)) {
         active += position.amount;
       }
     }
@@ -5402,7 +5532,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
     let active = 0n;
     const positions = await this.stakeViewer.activeStakes();
     for (const position of positions) {
-      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress4(position.staker) === asAddress4(staker)) {
+      if ((position.removeBlock === 0 || position.removeBlock > time) && asAddress3(position.staker) === asAddress3(staker)) {
         active += position.amount;
       }
     }
@@ -5429,7 +5559,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
     let pending = 0n;
     const positions = await this.stakeViewer.removedStakes();
     for (const position of positions) {
-      if (position.removeBlock !== 0 && position.removeBlock <= time && (position.withdrawBlock === 0 || position.withdrawBlock > time) && asAddress4(position.staker) === asAddress4(staker)) {
+      if (position.removeBlock !== 0 && position.removeBlock <= time && (position.withdrawBlock === 0 || position.withdrawBlock > time) && asAddress3(position.staker) === asAddress3(staker)) {
         pending += position.amount;
       }
     }
@@ -5449,7 +5579,7 @@ var SimpleStakeTotalsViewer = class extends AbstractCreatableProvider {
     let withdrawn = 0n;
     const positions = await this.stakeViewer.withdrawnStakes();
     for (const position of positions) {
-      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time && asAddress4(position.staker) === asAddress4(staker)) {
+      if (position.withdrawBlock !== 0 && position.withdrawBlock <= time && asAddress3(position.staker) === asAddress3(staker)) {
         withdrawn += position.amount;
       }
     }
@@ -5465,7 +5595,7 @@ SimpleStakeTotalsViewer = __decorateClass([
 
 // src/simple/StakeViewer/SimpleStakeViewer.ts
 import {
-  asAddress as asAddress5,
+  asAddress as asAddress4,
   toAddress as toAddress6
 } from "@xylabs/sdk-js";
 import { assertEx as assertEx42 } from "@xylabs/sdk-js";
@@ -5496,7 +5626,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     let active = 0n;
     const positions = await this.activeStakes();
     for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress5(position.staked) === asAddress5(staked)) {
+      if (position.removeBlock === 0 && asAddress4(position.staked) === asAddress4(staked)) {
         active += position.amount;
       }
     }
@@ -5506,7 +5636,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     let active = 0n;
     const positions = await this.activeStakes();
     for (const position of positions) {
-      if (position.removeBlock === 0 && asAddress5(position.staker) === asAddress5(staker)) {
+      if (position.removeBlock === 0 && asAddress4(position.staker) === asAddress4(staker)) {
         active += position.amount;
       }
     }
@@ -5539,7 +5669,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     let pending = 0n;
     const positions = await this.removedStakes();
     for (const position of positions) {
-      if (position.removeBlock !== 0 && position.withdrawBlock === 0 && asAddress5(position.staker) === asAddress5(staker)) {
+      if (position.removeBlock !== 0 && position.withdrawBlock === 0 && asAddress4(position.staker) === asAddress4(staker)) {
         pending += position.amount;
       }
     }
@@ -5555,15 +5685,15 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     return assertEx42(this.positions[id], () => new Error(`Stake with id ${id} not found`));
   }
   stakeByStaker(staker, slot) {
-    return this.positions.filter((s) => asAddress5(s.staker) === asAddress5(staker))[slot];
+    return this.positions.filter((s) => asAddress4(s.staker) === asAddress4(staker))[slot];
   }
   stakesByStaked(staked, range = [0, void 0]) {
     const endBlock = range[1] ?? Number.MAX_SAFE_INTEGER;
-    return this.positions.filter((s) => asAddress5(s.staked) === asAddress5(staked) && s.addBlock <= endBlock && s.removeBlock <= endBlock);
+    return this.positions.filter((s) => asAddress4(s.staked) === asAddress4(staked) && s.addBlock <= endBlock && s.removeBlock <= endBlock);
   }
   stakesByStaker(staker, range = [0, void 0]) {
     const endBlock = range[1] ?? Number.MAX_SAFE_INTEGER;
-    return this.positions.filter((s) => asAddress5(s.staker) === asAddress5(staker) && s.addBlock <= endBlock && s.removeBlock <= endBlock);
+    return this.positions.filter((s) => asAddress4(s.staker) === asAddress4(staker) && s.addBlock <= endBlock && s.removeBlock <= endBlock);
   }
   stakingTokenAddress() {
     return toAddress6("0x000000000000000000000000000011");
@@ -5582,7 +5712,7 @@ var SimpleStakeViewer = class extends AbstractCreatableProvider {
     let withdrawn = 0n;
     const positions = await this.withdrawnStakes();
     for (const position of positions) {
-      if (position.withdrawBlock !== 0 && asAddress5(position.staker) === asAddress5(staker)) {
+      if (position.withdrawBlock !== 0 && asAddress4(position.staker) === asAddress4(staker)) {
         withdrawn += position.amount;
       }
     }
@@ -5718,7 +5848,7 @@ SimpleTimeSyncViewer = __decorateClass([
 
 // src/simple/transactionValidation/SimpleTransactionValidationViewer.ts
 import { assertEx as assertEx44 } from "@xylabs/sdk-js";
-import { PayloadBuilder as PayloadBuilder23 } from "@xyo-network/sdk-js";
+import { PayloadBuilder as PayloadBuilder24 } from "@xyo-network/sdk-js";
 import {
   AccountBalanceViewerMoniker as AccountBalanceViewerMoniker3,
   asXL1BlockRange as asXL1BlockRange12,
@@ -5767,7 +5897,7 @@ var SimpleTransactionValidationViewer = class extends AbstractCreatableProvider
       state: true,
       head: void 0
     };
-    const transactionsWithMeta = await Promise.all(transactions.map((b) => Promise.all([PayloadBuilder23.addHashMeta(b[0]), PayloadBuilder23.addHashMeta(b[1])])));
+    const transactionsWithMeta = await Promise.all(transactions.map((b) => Promise.all([PayloadBuilder24.addHashMeta(b[0]), PayloadBuilder24.addHashMeta(b[1])])));
     const head = isChainQualifiedHeadConfig6(config) ? assertEx44(
       (await this.blockViewer.blockByHash(config.head))?.[0],
       () => `Specified a head that is not in the chain [${config.head}]`
@@ -6187,8 +6317,8 @@ var getUrl = (host, port) => {
 var TODO = true;
 
 // src/validation/schema/Mnemonic.ts
-import { z as z27 } from "zod";
-var MnemonicStringZod = z27.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
+import { z as z28 } from "zod";
+var MnemonicStringZod = z28.string().transform((s) => s.trim().replaceAll(/\s+/g, " ")).refine(
   (s) => [12, 15, 18, 21, 24].includes(s.split(" ").length),
   { message: "Mnemonic must contain 12, 15, 18, 21, or 24 words." }
 ).describe("BIP-39 mnemonic string");
@@ -6214,16 +6344,15 @@ export {
   ADDRESS_INDEX,
   AbstractCreatableProvider,
   AccountPathZod,
-  Actor,
   ActorConfigContext,
   ActorConfigZod,
-  ActorParamsV3Zod,
-  ActorV3,
   ActorsConfigZod,
   AddressPairSchema,
   BalancesStepSummarySchema,
   BaseConfigContextZod,
   BaseConfigZod,
+  BoundWitnessHydrator,
+  BoundWitnessWithStorageMetaZod,
   CHANGE_ADDRESS,
   COIN_TYPES,
   ChainIndexingServiceStateSchema,
@@ -6245,6 +6374,7 @@ export {
   HostActorConfigContext,
   HostActorConfigZod,
   HttpRpcRemoteConfigZod,
+  HydratedBoundWitnessWithStorageMetaZod,
   HydratedCache,
   JSONSchemaMetaSchema,
   LoggerStatusReporter,
@@ -6325,6 +6455,7 @@ export {
   asBalancesStepSummary,
   asBalancesStepSummaryWithStorageMeta,
   asBaseConfigContext,
+  asBoundWitnessWithStorageMeta,
   asChainIndexingServiceState,
   asChainIndexingServiceStateWithStorageMeta,
   asCreatableProviderContext,
@@ -6332,6 +6463,7 @@ export {
   asEIP712SignaturePayload,
   asHostActorConfig,
   asHostActorConfigContext,
+  asHydratedBoundWitnessWithStorageMeta,
   asOptionalAddressPairPayload,
   asProviderConfig,
   asSchemasStepSummary,
@@ -6358,7 +6490,10 @@ export {
   crackOperation,
   crackOperations,
   creatableProvider,
+  createBlockHydrator,
+  createBoundWitnessHydrator,
   createDeclarationIntent,
+  createTransactionHydrator,
   createTransferPayload,
   deepCalculateFramesFromRange,
   externalBlockNumberFromXL1BlockNumber,