@xyo-network/event-kit-statement-graph 0.1.5 → 0.1.8

package/dist/neutral/index.mjs

@@ -217,9 +217,9 @@ var EventKitClaimedObjectSchemas = Object.freeze([
 var EventKitClaimedObjectSchemaSet = new Set(EventKitClaimedObjectSchemas);
 
 // src/finalizedReplayController.ts
-import { HashZod as HashZod3 } from "@ariestools/sdk";
+import { HashZod as HashZod4 } from "@ariestools/sdk";
 import {
-  ChainIdZod as ChainIdZod2,
+  ChainIdZod as ChainIdZod3,
   normalizeAddress as normalizeAddress3,
   NormalizedAddressZod as NormalizedAddressZod3,
   WakeSubscriptionAcceptanceSchema as WakeSubscriptionAcceptanceSchema2,
@@ -231,13 +231,70 @@ import {
   scanFinalizedStatements
 } from "@xyo-network/xl1-statement-graph-sdk";
 
-// src/replayCheckpoint.ts
+// src/finalizedReplayChain.ts
 import { HashZod as HashZod2 } from "@ariestools/sdk";
+import { ChainIdZod } from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import { isBlockBoundWitness } from "@xyo-network/xl1-protocol";
+async function requireBlockIdentity(chain, raw, chainId, requestedBlock) {
+  if (!Array.isArray(raw) || raw.length !== 2 || !Array.isArray(raw[1])) {
+    throw new TypeError(requestedBlock === void 0 ? "finalized block is unavailable" : `finalized block ${requestedBlock} is unavailable`);
+  }
+  const header = raw[0];
+  if (!isBlockBoundWitness(header) || !Number.isSafeInteger(header.block) || header.block < 0) {
+    throw new TypeError("finalized block has an invalid header");
+  }
+  const block = header.block;
+  const expectedChainId = chain.chainId === void 0 ? chainId : ChainIdZod.parse(String(await chain.chainId(block)).toLowerCase());
+  if (requestedBlock !== void 0 && block !== requestedBlock || header.chain !== expectedChainId) {
+    throw new TypeError(`finalized block ${block} does not match the configured chain`);
+  }
+  return header;
+}
+async function exactFinalizedBlockHash(chain, block, chainId) {
+  const raw = await chain.block.blockByNumber(block);
+  const header = await requireBlockIdentity(chain, raw, chainId, block);
+  const hash = await PayloadBuilder.hash(PayloadBuilder.omitStorageMeta(header));
+  const storageHash = header._hash;
+  if (typeof storageHash === "string" && storageHash !== hash) {
+    throw new TypeError(`finalized block ${block} has invalid storage hash metadata`);
+  }
+  return HashZod2.parse(hash);
+}
+function lineageValidatingScanChain(chain, chainId) {
+  return {
+    block: {
+      async blockByNumber(block) {
+        const raw = await chain.block.blockByNumber(block);
+        await requireBlockIdentity(chain, raw, chainId, block);
+        return raw;
+      },
+      ...chain.block.blocksByNumber === void 0 ? {} : {
+        async blocksByNumber(high, count) {
+          const values = await chain.block.blocksByNumber?.(high, count) ?? [];
+          for (const value of values) await requireBlockIdentity(chain, value, chainId);
+          return values;
+        }
+      }
+    },
+    finalization: chain.finalization
+  };
+}
+async function requireCurrentReplayChain(chain, finalizedHead, chainId) {
+  if (chain.chainId === void 0) return;
+  const headChainId = ChainIdZod.parse(String(await chain.chainId(finalizedHead)).toLowerCase());
+  if (headChainId !== chainId) {
+    throw new TypeError(`finalized head ${finalizedHead} does not match the configured current chain`);
+  }
+}
+
+// src/replayCheckpoint.ts
+import { HashZod as HashZod3 } from "@ariestools/sdk";
 import {
-  ChainIdZod,
+  ChainIdZod as ChainIdZod2,
   NormalizedAddressZod as NormalizedAddressZod2
 } from "@xyo-network/event-kit-schemas";
-import { PayloadBuilder } from "@xyo-network/sdk";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
 import {
   AppliedEventRecordZod,
   BlockNumberZod,
@@ -249,10 +306,10 @@ import {
   StatementScanCheckpointZod
 } from "@xyo-network/xl1-statement-graph-sdk";
 import { z } from "zod";
-var EVENT_KIT_REPLAY_CHECKPOINT_VERSION = 2;
+var EVENT_KIT_REPLAY_CHECKPOINT_VERSION = 3;
 var ResolvedReplayBodyZod = z.strictObject({
   body: z.record(z.string(), z.unknown()),
-  hash: HashZod2
+  hash: HashZod3
 });
 var ReplayCorruptBodyZod = z.strictObject({
   claimedHash: z.string().optional(),
@@ -261,18 +318,19 @@ var ReplayCorruptBodyZod = z.strictObject({
 var ReplayBlockedStateZod = z.strictObject({
   atBlock: BlockNumberZod,
   corrupt: z.array(ReplayCorruptBodyZod),
-  objectHashes: z.array(HashZod2),
+  objectHashes: z.array(HashZod3),
   unresolvedEvents: z.array(UnresolvedEventReferenceZod)
 });
 var EventKitReplayCheckpointZod = z.strictObject({
   applied: z.array(AppliedEventRecordZod),
   blocked: ReplayBlockedStateZod.optional(),
   bodies: z.array(ResolvedReplayBodyZod),
-  chainId: ChainIdZod,
+  chainId: ChainIdZod2,
   finalizedHead: BlockNumberZod,
   floorBlock: BlockNumberZod,
   foldVersion: z.literal(STATEMENT_FOLD_VERSION),
   indexedThrough: z.union([BlockNumberZod, z.null()]),
+  indexedThroughHash: z.union([HashZod3, z.null()]),
   network: z.string().min(1),
   objectSchemas: z.tuple(EventKitClaimedObjectSchemas.map((schema) => z.literal(schema))),
   publisher: NormalizedAddressZod2,
@@ -280,6 +338,22 @@ var EventKitReplayCheckpointZod = z.strictObject({
   sourceId: z.string().min(1),
   version: z.literal(EVENT_KIT_REPLAY_CHECKPOINT_VERSION)
 });
+var LegacyEventKitReplayCheckpointIdentityZod = z.looseObject({
+  chainId: ChainIdZod2,
+  floorBlock: BlockNumberZod,
+  network: z.string().min(1),
+  publisher: NormalizedAddressZod2,
+  sourceId: z.string().min(1),
+  version: z.literal(2)
+});
+function checkpointIdentityError(checkpoint, identity) {
+  if (checkpoint.chainId !== identity.chainId) return `chainId ${checkpoint.chainId} != ${identity.chainId}`;
+  if (checkpoint.floorBlock !== identity.floorBlock) return `floorBlock ${checkpoint.floorBlock} != ${identity.floorBlock}`;
+  if (checkpoint.network !== identity.network) return `network ${checkpoint.network} != ${identity.network}`;
+  if (checkpoint.sourceId !== identity.sourceId) return `sourceId ${checkpoint.sourceId} != ${identity.sourceId}`;
+  if (checkpoint.publisher !== identity.publisher) return `publisher ${checkpoint.publisher} != ${identity.publisher}`;
+  return void 0;
+}
 function appliedKey(record) {
   return `${record.txHash}:${record.eventHash}:${record.hashIndex}`;
 }
@@ -328,7 +402,7 @@ function sameClaimRecords(left, right) {
   });
 }
 function progressIntegrityError(checkpoint) {
-  const { indexedThrough } = checkpoint;
+  const { indexedThrough, indexedThroughHash } = checkpoint;
   if (indexedThrough !== null && indexedThrough > checkpoint.finalizedHead) {
     return `indexedThrough ${indexedThrough} exceeds finalizedHead ${checkpoint.finalizedHead}`;
   }
@@ -341,6 +415,9 @@ function progressIntegrityError(checkpoint) {
   if (indexedThrough !== null && checkpoint.scan === null) {
     return "scan checkpoint is missing for indexed state";
   }
+  if (indexedThrough === null !== (indexedThroughHash === null)) {
+    return "indexedThrough and indexedThroughHash must be present together";
+  }
   if (indexedThrough === null && checkpoint.applied.length > 0) {
     return "applied events exist before floorBlock has been indexed";
   }
@@ -500,7 +577,7 @@ async function persistedBodyIntegrityError(checkpoint) {
   for (const entry of checkpoint.bodies) {
     let computedHash;
     try {
-      computedHash = await PayloadBuilder.dataHash(entry.body);
+      computedHash = await PayloadBuilder2.dataHash(entry.body);
     } catch {
       return `persisted body ${entry.hash} cannot be hashed`;
     }
@@ -512,26 +589,21 @@ async function persistedBodyIntegrityError(checkpoint) {
 }
 async function loadEventKitReplayCheckpoint(value, identity) {
   if (value === void 0 || value === null) return { status: "missing" };
+  if (typeof value === "object" && value !== null && value.version === 2) {
+    const legacy = LegacyEventKitReplayCheckpointIdentityZod.safeParse(value);
+    if (!legacy.success) {
+      return { detail: "recognized Event Kit replay checkpoint v2 has invalid identity", status: "corrupt" };
+    }
+    const mismatch2 = checkpointIdentityError(legacy.data, identity);
+    return mismatch2 === void 0 ? { status: "missing" } : { detail: mismatch2, status: "identity-mismatch" };
+  }
   const parsed = EventKitReplayCheckpointZod.safeParse(value);
   if (!parsed.success) {
     return { detail: "recognized Event Kit replay checkpoint has invalid content", status: "corrupt" };
   }
   const checkpoint = parsed.data;
-  if (checkpoint.chainId !== identity.chainId) {
-    return { detail: `chainId ${checkpoint.chainId} != ${identity.chainId}`, status: "identity-mismatch" };
-  }
-  if (checkpoint.floorBlock !== identity.floorBlock) {
-    return { detail: `floorBlock ${checkpoint.floorBlock} != ${identity.floorBlock}`, status: "identity-mismatch" };
-  }
-  if (checkpoint.network !== identity.network) {
-    return { detail: `network ${checkpoint.network} != ${identity.network}`, status: "identity-mismatch" };
-  }
-  if (checkpoint.sourceId !== identity.sourceId) {
-    return { detail: `sourceId ${checkpoint.sourceId} != ${identity.sourceId}`, status: "identity-mismatch" };
-  }
-  if (checkpoint.publisher !== identity.publisher) {
-    return { detail: `publisher ${checkpoint.publisher} != ${identity.publisher}`, status: "identity-mismatch" };
-  }
+  const mismatch = checkpointIdentityError(checkpoint, identity);
+  if (mismatch !== void 0) return { detail: mismatch, status: "identity-mismatch" };
   const bodyIntegrityError = await persistedBodyIntegrityError(checkpoint);
   if (bodyIntegrityError !== void 0) return { detail: bodyIntegrityError, status: "corrupt" };
   const integrityError = checkpointIntegrityError(checkpoint);
@@ -540,6 +612,8 @@ async function loadEventKitReplayCheckpoint(value, identity) {
 }
 
 // src/finalizedReplayController.ts
+var DEFAULT_CHECKPOINT_BATCH_SIZE = 4096;
+var DEFAULT_SCAN_BATCH_SIZE = 16;
 function requireHead(value) {
   const head = Number(value);
   if (!Number.isSafeInteger(head) || head < 0) {
@@ -553,6 +627,19 @@ function requireFloor(value) {
   }
   return value;
 }
+function requirePositiveInteger(value, fallback, name) {
+  const selected = value ?? fallback;
+  if (!Number.isSafeInteger(selected) || selected < 1) {
+    throw new TypeError(`${name} must be a positive safe integer, received ${String(selected)}`);
+  }
+  return selected;
+}
+function requireMaxBlocks(value) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new TypeError(`maxBlocks must be a nonnegative safe integer, received ${String(value)}`);
+  }
+  return value;
+}
 function replayContract(options, throughBlock) {
   return {
     eventBodyCorpus: { sourceId: options.sourceId },
@@ -572,6 +659,7 @@ function initialCheckpoint(options) {
     floorBlock: options.floorBlock,
     foldVersion: STATEMENT_FOLD_VERSION2,
     indexedThrough: null,
+    indexedThroughHash: null,
     network: options.network,
     objectSchemas: [...EventKitClaimedObjectSchemas],
     publisher: options.publisher,
@@ -613,23 +701,9 @@ function mergeBodies(existing, additions) {
     }
     merged.set(hash, body);
   }
-  return [...merged].map(([hash, body]) => ({ body, hash: HashZod3.parse(hash) })).toSorted((left, right) => left.hash.localeCompare(right.hash));
+  return [...merged].map(([hash, body]) => ({ body, hash: HashZod4.parse(hash) })).toSorted((left, right) => left.hash.localeCompare(right.hash));
 }
-async function stageBlock(options, prior, block) {
-  const result = await scanFinalizedStatements(
-    options.chain,
-    options.bodies,
-    replayContract(options, block),
-    {
-      batchSize: 1,
-      ...prior.scan === null ? {} : { resumeFrom: prior.scan },
-      strict: { rejectAmbiguousSchemaDeclarations: true },
-      through: block
-    }
-  );
-  const applied = result.fold.applied.filter(
-    (record) => normalizeAddress3(record.subject) === options.publisher
-  );
+async function stageAppliedBlock(options, applied) {
   const appliedObjectHashes = uniqueStrings(applied.map((record) => record.objectHash));
   const objects = await resolveVerifiedBodies(options.bodies, appliedObjectHashes);
   const missingObjects = appliedObjectHashes.filter((hash) => !objects.bodies.has(hash));
@@ -654,20 +728,73 @@ async function stageBlock(options, prior, block) {
     ...missingObjects,
     ...schemaMismatchedObjects,
     ...missingAttachments
-  ]).map((hash) => HashZod3.parse(hash));
-  const isBlocked = result.unresolved.length > 0 || objectHashes.length > 0 || corrupt.length > 0;
+  ]).map((hash) => HashZod4.parse(hash));
   return {
-    applied,
     bodies: new Map([...objects.bodies, ...attachments.bodies]),
+    corrupt,
+    objectHashes
+  };
+}
+async function stageRange(options, prior, fromBlock, throughBlock, signal) {
+  signal?.throwIfAborted();
+  const beforeHash = await exactFinalizedBlockHash(options.chain, throughBlock, options.chainId);
+  signal?.throwIfAborted();
+  const result = await scanFinalizedStatements(
+    lineageValidatingScanChain(options.chain, options.chainId),
+    options.bodies,
+    replayContract(options, throughBlock),
+    {
+      batchSize: requirePositiveInteger(options.scanBatchSize, DEFAULT_SCAN_BATCH_SIZE, "scanBatchSize"),
+      ...prior.scan === null ? {} : { resumeFrom: prior.scan },
+      ...signal === void 0 ? {} : { signal },
+      strict: { rejectAmbiguousSchemaDeclarations: true },
+      through: throughBlock
+    }
+  );
+  signal?.throwIfAborted();
+  const throughHash = await exactFinalizedBlockHash(options.chain, throughBlock, options.chainId);
+  signal?.throwIfAborted();
+  if (beforeHash !== throughHash) {
+    throw new Error(`finalized block root changed while staging through ${throughBlock}`);
+  }
+  if (result.head !== throughBlock || result.checkpoint.contract.throughBlock !== throughBlock) {
+    throw new RangeError(
+      `finalized range scan stopped at ${result.head}/${result.checkpoint.contract.throughBlock}; requested ${throughBlock}`
+    );
+  }
+  const applied = result.fold.applied.filter((record) => record.block >= fromBlock && record.block <= throughBlock && normalizeAddress3(record.subject) === options.publisher);
+  const appliedByBlock = Map.groupBy(applied, (record) => record.block);
+  const unresolvedByBlock = Map.groupBy(
+    result.unresolved.filter((event) => event.block >= fromBlock && event.block <= throughBlock),
+    (event) => event.block
+  );
+  const relevantBlocks = [.../* @__PURE__ */ new Set([...appliedByBlock.keys(), ...unresolvedByBlock.keys()])].toSorted((left, right) => left - right);
+  const bodies = /* @__PURE__ */ new Map();
+  for (const block of relevantBlocks) {
+    signal?.throwIfAborted();
+    const staged = await stageAppliedBlock(options, appliedByBlock.get(block) ?? []);
+    for (const [hash, body] of staged.bodies) bodies.set(hash, body);
+    const unresolvedEvents = unresolvedByBlock.get(block) ?? [];
+    if (unresolvedEvents.length > 0 || staged.objectHashes.length > 0 || staged.corrupt.length > 0) {
+      return {
+        applied,
+        blocked: {
+          atBlock: block,
+          corrupt: staged.corrupt,
+          objectHashes: staged.objectHashes,
+          unresolvedEvents
+        },
+        bodies,
+        scan: result.checkpoint,
+        throughHash
+      };
+    }
+  }
+  return {
+    applied,
+    bodies,
     scan: result.checkpoint,
-    ...isBlocked ? {
-      blocked: {
-        atBlock: block,
-        corrupt,
-        objectHashes,
-        unresolvedEvents: result.unresolved
-      }
-    } : {}
+    throughHash
   };
 }
 var DefaultFinalizedEventKitReplayController = class {
@@ -678,6 +805,9 @@ var DefaultFinalizedEventKitReplayController = class {
     this.#options = options;
     this.#checkpoint = checkpoint;
   }
+  anchor() {
+    return this.#checkpoint.indexedThrough === null || this.#checkpoint.indexedThroughHash === null ? null : Object.freeze({ block: this.#checkpoint.indexedThrough, hash: this.#checkpoint.indexedThroughHash });
+  }
   body(hash) {
     return this.#checkpoint.bodies.find((entry) => entry.hash === hash)?.body;
   }
@@ -691,8 +821,8 @@ var DefaultFinalizedEventKitReplayController = class {
       indexedThrough: this.#checkpoint.indexedThrough
     };
   }
-  sync() {
-    const result = this.#syncTail.then(async () => await this.#syncOnce());
+  sync(options) {
+    const result = this.#syncTail.then(async () => await this.#syncOnce(options));
     this.#syncTail = result.then(
       () => true,
       () => false
@@ -702,8 +832,56 @@ var DefaultFinalizedEventKitReplayController = class {
   viewer() {
     return createCheckpointStatementGraphViewer(this.#checkpoint);
   }
-  async #syncOnce() {
+  async #commitRange(fromBlock, throughBlock, finalizedHead, signal) {
+    const staged = await stageRange(this.#options, this.#checkpoint, fromBlock, throughBlock, signal);
+    signal?.throwIfAborted();
+    if (staged.blocked !== void 0) {
+      const blockedAt = staged.blocked.atBlock;
+      if (blockedAt > fromBlock) {
+        const prefixBlocked = await this.#commitRange(fromBlock, blockedAt - 1, finalizedHead, signal);
+        if (prefixBlocked) return true;
+      }
+      const exact = await stageRange(this.#options, this.#checkpoint, blockedAt, blockedAt, signal);
+      signal?.throwIfAborted();
+      if (exact.blocked === void 0) {
+        await this.#commitStaged(exact, blockedAt, finalizedHead, signal);
+        return blockedAt === throughBlock ? false : await this.#commitRange(blockedAt + 1, throughBlock, finalizedHead, signal);
+      }
+      const blocked = EventKitReplayCheckpointZod.parse({
+        ...this.#checkpoint,
+        blocked: exact.blocked,
+        finalizedHead
+      });
+      signal?.throwIfAborted();
+      await this.#options.checkpointStore.save(blocked);
+      this.#checkpoint = blocked;
+      return true;
+    }
+    await this.#commitStaged(staged, throughBlock, finalizedHead, signal);
+    return false;
+  }
+  async #commitStaged(staged, throughBlock, finalizedHead, signal) {
+    const committed = EventKitReplayCheckpointZod.parse({
+      ...this.#checkpoint,
+      applied: mergeApplied(this.#checkpoint.applied, staged.applied),
+      bodies: mergeBodies(this.#checkpoint.bodies, staged.bodies),
+      blocked: void 0,
+      finalizedHead,
+      indexedThrough: throughBlock,
+      indexedThroughHash: staged.throughHash,
+      scan: staged.scan
+    });
+    signal?.throwIfAborted();
+    await this.#options.checkpointStore.save(committed);
+    this.#checkpoint = committed;
+  }
+  async #syncOnce(rawOptions) {
+    const maxBlocks = requireMaxBlocks(rawOptions?.maxBlocks);
+    const signal = rawOptions?.signal;
+    signal?.throwIfAborted();
     const finalizedHead = requireHead(await this.#options.chain.finalization.headNumber());
+    signal?.throwIfAborted();
+    await requireCurrentReplayChain(this.#options.chain, finalizedHead, this.#options.chainId);
     if (finalizedHead < this.#checkpoint.finalizedHead) {
       throw new RangeError(
         `finalized head regressed from ${this.#checkpoint.finalizedHead} to ${finalizedHead}; refusing to roll back`
@@ -714,39 +892,26 @@ var DefaultFinalizedEventKitReplayController = class {
       throw new RangeError(`finalized head ${finalizedHead} is behind indexedThrough ${indexedThrough}`);
     }
     let next = indexedThrough === null ? this.#options.floorBlock : indexedThrough + 1;
-    let changed = finalizedHead !== this.#checkpoint.finalizedHead;
-    while (next <= finalizedHead) {
-      const staged = await stageBlock(this.#options, this.#checkpoint, next);
-      if (staged.blocked !== void 0) {
-        const blocked = EventKitReplayCheckpointZod.parse({
-          ...this.#checkpoint,
-          blocked: staged.blocked,
-          finalizedHead
-        });
-        await this.#options.checkpointStore.save(blocked);
-        this.#checkpoint = blocked;
-        return this.status();
-      }
-      const committed = EventKitReplayCheckpointZod.parse({
-        ...this.#checkpoint,
-        applied: mergeApplied(this.#checkpoint.applied, staged.applied),
-        bodies: mergeBodies(this.#checkpoint.bodies, staged.bodies),
-        blocked: void 0,
-        finalizedHead,
-        indexedThrough: next,
-        scan: staged.scan
-      });
-      await this.#options.checkpointStore.save(committed);
-      this.#checkpoint = committed;
-      changed = false;
-      next += 1;
+    const remaining = next <= finalizedHead ? finalizedHead - next + 1 : 0;
+    const budget = maxBlocks === void 0 ? remaining : Math.min(maxBlocks, remaining);
+    const target = budget === 0 ? next - 1 : next + budget - 1;
+    const checkpointBatchSize = requirePositiveInteger(
+      this.#options.checkpointBatchSize,
+      DEFAULT_CHECKPOINT_BATCH_SIZE,
+      "checkpointBatchSize"
+    );
+    while (next <= target) {
+      signal?.throwIfAborted();
+      const throughBlock = Math.min(target, next + Math.min(checkpointBatchSize, target - next + 1) - 1);
+      if (await this.#commitRange(next, throughBlock, finalizedHead, signal)) return this.status();
+      next = throughBlock + 1;
     }
-    if (changed || this.#checkpoint.blocked !== void 0) {
+    if (this.#checkpoint.finalizedHead !== finalizedHead) {
       const observed = EventKitReplayCheckpointZod.parse({
         ...this.#checkpoint,
-        blocked: void 0,
         finalizedHead
       });
+      signal?.throwIfAborted();
       await this.#options.checkpointStore.save(observed);
       this.#checkpoint = observed;
     }
@@ -756,10 +921,16 @@ var DefaultFinalizedEventKitReplayController = class {
 async function createFinalizedEventKitReplayController(rawOptions) {
   const options = {
     ...rawOptions,
-    chainId: ChainIdZod2.parse(rawOptions.chainId),
+    chainId: ChainIdZod3.parse(rawOptions.chainId),
+    checkpointBatchSize: requirePositiveInteger(
+      rawOptions.checkpointBatchSize,
+      DEFAULT_CHECKPOINT_BATCH_SIZE,
+      "checkpointBatchSize"
+    ),
     floorBlock: requireFloor(rawOptions.floorBlock),
     network: rawOptions.network.trim(),
     publisher: NormalizedAddressZod3.parse(rawOptions.publisher),
+    scanBatchSize: requirePositiveInteger(rawOptions.scanBatchSize, DEFAULT_SCAN_BATCH_SIZE, "scanBatchSize"),
     sourceId: rawOptions.sourceId.trim()
   };
   if (options.network.length === 0) throw new TypeError("network must not be empty");
@@ -787,7 +958,7 @@ function createMemoryEventKitReplayCheckpointStore(initial) {
 }
 
 // src/grantReadModel.ts
-import { HashZod as HashZod4 } from "@ariestools/sdk";
+import { HashZod as HashZod5 } from "@ariestools/sdk";
 import { XyoAddressZod } from "@xyo-network/sdk-protocol/address";
 function createStatementGraphGrantReadModel(options) {
   const { viewer } = options;
@@ -800,7 +971,7 @@ function createStatementGraphGrantReadModel(options) {
       return Object.freeze(records.map(toGrantClaim));
     },
     async object(objectHash) {
-      const record = await viewer.object(HashZod4.parse(objectHash));
+      const record = await viewer.object(HashZod5.parse(objectHash));
       return record === void 0 ? void 0 : toGrantObject(record);
     }
   });
@@ -809,7 +980,7 @@ function toClaimQuery(query) {
   if (query === void 0) return void 0;
   return {
     ...query.declaredObjectSchemaPrefix === void 0 ? {} : { declaredObjectSchemaPrefix: query.declaredObjectSchemaPrefix },
-    ...query.objectHash === void 0 ? {} : { objectHash: HashZod4.parse(query.objectHash) },
+    ...query.objectHash === void 0 ? {} : { objectHash: HashZod5.parse(query.objectHash) },
     ...query.subject === void 0 ? {} : { subject: XyoAddressZod.parse(query.subject) }
   };
 }
@@ -862,7 +1033,7 @@ import {
   selectPublisherService
 } from "@xyo-network/event-kit-protocol";
 import {
-  ChainIdZod as ChainIdZod3,
+  ChainIdZod as ChainIdZod4,
   NormalizedAddressZod as NormalizedAddressZod4,
   PublisherEncryptionKeyRevocationSchema as PublisherEncryptionKeyRevocationSchema2,
   PublisherEncryptionKeyRevocationZod,
@@ -874,7 +1045,7 @@ import {
   PublisherServiceZod,
   SOURCE_WAKE_EVENT_KIND as SOURCE_WAKE_EVENT_KIND2
 } from "@xyo-network/event-kit-schemas";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+import { PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk";
 import { XyoAddressZod as XyoAddressZod2 } from "@xyo-network/sdk-protocol/address";
 function handshakeEvidence(record) {
   return {
@@ -914,12 +1085,12 @@ async function verifiedHandshakeObjectBody(viewer, record) {
   const object = await viewer.object(record.objectHash);
   if (object?.assurance !== "resolved" || object.declaredSchema !== record.objectSchema || object.params === null) return void 0;
   const body = { schema: object.declaredSchema, ...object.params };
-  return await PayloadBuilder2.dataHash(body) === record.objectHash ? body : void 0;
+  return await PayloadBuilder3.dataHash(body) === record.objectHash ? body : void 0;
 }
 async function verifiedHandshakeAttachmentBody(resolver, hash) {
   const body = resolver?.(hash);
   if (body === void 0) return void 0;
-  return await PayloadBuilder2.dataHash(body) === hash ? { ...body } : void 0;
+  return await PayloadBuilder3.dataHash(body) === hash ? { ...body } : void 0;
 }
 function firstHandshakeRevocation(revocations, target) {
   const blocks = revocations.filter((item) => item.target === target).map((item) => item.block);
@@ -1070,7 +1241,7 @@ function hasPendingPublisherService(catalogs, query) {
 async function discoverHandshakeService(options, rawQuery) {
   const query = {
     ...rawQuery,
-    chainId: ChainIdZod3.parse(rawQuery.chainId),
+    chainId: ChainIdZod4.parse(rawQuery.chainId),
     eventKind: rawQuery.eventKind ?? SOURCE_WAKE_EVENT_KIND2,
     publisher: NormalizedAddressZod4.parse(rawQuery.publisher)
   };