@xyo-network/event-kit-xl1 0.0.1 → 0.1.0

package/dist/neutral/index.mjs

@@ -16,7 +16,857 @@ function createXl1FinalizedHeadSource(options) {
     }
   };
 }
+
+// src/finalizedStatementPublication.ts
+import {
+  WakeSubscriptionAcceptanceSchema,
+  WakeSubscriptionAcceptanceZod
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder } from "@xyo-network/sdk";
+import {
+  broadcastXl1Transaction,
+  buildXl1Transaction,
+  createSignedXl1TransactionEvidence,
+  observeXl1TransactionFinality,
+  observeXl1TransactionInclusion,
+  signXl1Transaction,
+  verifyXl1TransactionContent,
+  writeXl1TransactionContent
+} from "@xyo-network/xl1-sdk";
+import { insertVerified, prepareStatements } from "@xyo-network/xl1-statement-graph-sdk";
+
+// src/memoryFinalizedStatementPublicationJournal.ts
+var PublicationPhases = [
+  "signed",
+  "content-written",
+  "content-verified",
+  "broadcast",
+  "included",
+  "finalized"
+];
+function sameStrings(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameValue(value, right[index]));
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord).sort();
+  const rightKeys = Object.keys(rightRecord).sort();
+  return sameStrings(leftKeys, rightKeys) && leftKeys.every((key) => sameValue(leftRecord[key], rightRecord[key]));
+}
+function sameIntent(left, right) {
+  return left.operationId === right.operationId && left.source === right.source && left.chainId === right.chainId && sameStrings(left.eventHashes, right.eventHashes) && sameStrings(left.attachmentHashes, right.attachmentHashes);
+}
+function publicationKey(intent) {
+  return `${intent.chainId}\0${intent.source}\0${intent.operationId}`;
+}
+function intentFromRecord(record2) {
+  return {
+    attachmentHashes: record2.attachmentHashes,
+    chainId: record2.chainId,
+    eventHashes: record2.eventHashes,
+    operationId: record2.operationId,
+    source: record2.source
+  };
+}
+function createMemoryFinalizedStatementPublicationJournal() {
+  const records = [];
+  const publications = /* @__PURE__ */ new Map();
+  function phasesForExactIntent(intent) {
+    const phases = publications.get(publicationKey(intent));
+    const signed = phases?.get("signed");
+    if (signed !== void 0 && !sameIntent(intentFromRecord(signed), intent)) {
+      throw new Error("publication journal intent collision");
+    }
+    return phases;
+  }
+  return {
+    records,
+    async load(intent) {
+      const phases = phasesForExactIntent(intent);
+      if (phases === void 0) return void 0;
+      for (const phase of PublicationPhases.toReversed()) {
+        const candidate = phases.get(phase);
+        if (candidate !== void 0) return structuredClone(candidate);
+      }
+      throw new Error("publication journal has an intent without signed evidence");
+    },
+    async save(record2) {
+      let phases = phasesForExactIntent(record2);
+      if (phases === void 0) {
+        if (record2.phase !== "signed") throw new Error("publication journal must bind signed evidence first");
+        phases = /* @__PURE__ */ new Map();
+        publications.set(publicationKey(record2), phases);
+      }
+      const signed = phases.get("signed");
+      if (signed !== void 0 && !sameValue(signed.evidence, record2.evidence)) {
+        throw new Error("publication journal evidence collision");
+      }
+      const existing = phases.get(record2.phase);
+      if (existing !== void 0) {
+        if (!sameValue(existing, record2)) throw new Error(`publication journal collision at ${record2.phase}`);
+        return;
+      }
+      const durable = structuredClone(record2);
+      phases.set(record2.phase, durable);
+      records.push(structuredClone(durable));
+    }
+  };
+}
+
+// src/finalizedStatementPublication.ts
+function positiveInteger(value, fallback, name) {
+  const selected = value ?? fallback;
+  if (!Number.isSafeInteger(selected) || selected < 1) throw new TypeError(`${name} must be a positive safe integer`);
+  return selected;
+}
+function nonnegativeInteger(value, fallback, name) {
+  const selected = value ?? fallback;
+  if (!Number.isSafeInteger(selected) || selected < 0) throw new TypeError(`${name} must be a nonnegative safe integer`);
+  return selected;
+}
+function safeBlockNumber(value, name) {
+  if (typeof value === "bigint") {
+    if (value < 0n || value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new TypeError(`${name} must be a nonnegative safe integer`);
+    }
+    return Number(value);
+  }
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${name} must be a nonnegative safe integer`);
+  }
+  return value;
+}
+function validateInclusion(inclusion, name) {
+  const blockNumber = safeBlockNumber(inclusion.blockNumber, `${name}.blockNumber`);
+  if (!Number.isSafeInteger(inclusion.transactionIndex) || inclusion.transactionIndex < 0) {
+    throw new TypeError(`${name}.transactionIndex must be a nonnegative safe integer`);
+  }
+  return blockNumber;
+}
+function assertSameInclusion(inclusion, inclusionBlock, finalized, finalizedBlock) {
+  if (finalized.blockHash !== inclusion.blockHash || finalizedBlock !== inclusionBlock || finalized.transactionHash !== inclusion.transactionHash || finalized.transactionIndex !== inclusion.transactionIndex) {
+    throw new Error("Finality evidence does not match the observed transaction inclusion");
+  }
+}
+function sameStrings2(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+var PublicationPhases2 = [
+  "signed",
+  "content-written",
+  "content-verified",
+  "broadcast",
+  "included",
+  "finalized"
+];
+var PublicationPhaseSet = new Set(PublicationPhases2);
+function publicationOperationId(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 256) {
+    throw new TypeError("operationId must be a nonempty string of at most 256 characters");
+  }
+  return value;
+}
+function sameValue2(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameValue2(value, right[index]));
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord).sort();
+  const rightKeys = Object.keys(rightRecord).sort();
+  return sameStrings2(leftKeys, rightKeys) && leftKeys.every((key) => sameValue2(leftRecord[key], rightRecord[key]));
+}
+function sameIntent2(left, right) {
+  return left.operationId === right.operationId && left.source === right.source && left.chainId === right.chainId && sameStrings2(left.eventHashes, right.eventHashes) && sameStrings2(left.attachmentHashes, right.attachmentHashes);
+}
+function intentFromRecord2(record2) {
+  return {
+    attachmentHashes: record2.attachmentHashes,
+    chainId: record2.chainId,
+    eventHashes: record2.eventHashes,
+    operationId: record2.operationId,
+    source: record2.source
+  };
+}
+function acceptanceAttachmentHashes(statements) {
+  const hashes = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    for (const object of statement.objects) {
+      if (object.schema !== WakeSubscriptionAcceptanceSchema) continue;
+      const acceptance = WakeSubscriptionAcceptanceZod.safeParse(object);
+      if (!acceptance.success) throw new TypeError("Claimed wake subscription acceptance is malformed");
+      hashes.add(acceptance.data.challenge);
+      hashes.add(acceptance.data.response);
+    }
+  }
+  return hashes;
+}
+async function assertExactAcceptanceAttachments(statements, attachments) {
+  const missing = acceptanceAttachmentHashes(statements);
+  const supplied = /* @__PURE__ */ new Set();
+  const hashes = [];
+  for (const attachment of attachments) {
+    const hash = String(await PayloadBuilder.dataHash(attachment));
+    if (supplied.has(hash)) {
+      throw new Error(`Duplicate publication attachment ${hash}`);
+    }
+    if (!missing.delete(hash)) {
+      throw new Error(`Publication attachment ${hash} is not referenced by a wake subscription acceptance`);
+    }
+    supplied.add(hash);
+    hashes.push(hash);
+  }
+  if (missing.size > 0) {
+    throw new Error(`Wake subscription acceptance is missing publication attachment ${[...missing].join(", ")}`);
+  }
+  return hashes;
+}
+function signingIntent(transaction) {
+  const intent = structuredClone(transaction);
+  intent.$signatures.splice(0);
+  intent.addresses.splice(0);
+  intent.previous_hashes.splice(0);
+  return intent;
+}
+async function assertSignedPublicationIntent(unsigned, evidence, signerAddress) {
+  const signed = evidence.transaction;
+  if (String(evidence.from) !== signerAddress || String(signed[0].from) !== signerAddress) {
+    throw new Error("Signed transaction from address does not match the requested signer");
+  }
+  if (signed[0].addresses.length !== 1 || String(signed[0].addresses[0]) !== signerAddress) {
+    throw new Error("Signed transaction witness does not contain exactly the requested signer");
+  }
+  const [unsignedIntentHash, signedIntentHash, unsignedPayloadHashes, signedPayloadHashes] = await Promise.all([
+    PayloadBuilder.hash(signingIntent(unsigned[0])),
+    PayloadBuilder.hash(signingIntent(signed[0])),
+    PayloadBuilder.hashes([...unsigned[1]]),
+    PayloadBuilder.hashes([...signed[1]])
+  ]);
+  if (unsignedIntentHash !== signedIntentHash || !sameStrings2(unsignedPayloadHashes, signedPayloadHashes)) {
+    throw new Error("Signed transaction content differs from the transaction submitted for signing");
+  }
+}
+async function assertPreparedPublicationIntent(prepared, evidence, intent) {
+  const signed = evidence.transaction;
+  if (String(evidence.from) !== intent.source || String(signed[0].from) !== intent.source) {
+    throw new Error("Signed transaction from address does not match the requested signer");
+  }
+  if (signed[0].addresses.length !== 1 || String(signed[0].addresses[0]) !== intent.source) {
+    throw new Error("Signed transaction witness does not contain exactly the requested signer");
+  }
+  if (String(evidence.chainId) !== intent.chainId || String(signed[0].chain) !== intent.chainId) {
+    throw new Error("Signed transaction chain does not match the requested publication chain");
+  }
+  const [expectedPayloadHashes, signedPayloadHashes, elevatedHashes] = await Promise.all([
+    PayloadBuilder.hashes([...prepared.transactionPayloads]),
+    PayloadBuilder.hashes([...signed[1]]),
+    PayloadBuilder.hashes([...prepared.onChainPayloads])
+  ]);
+  const expectedSchemas = prepared.transactionPayloads.map((payload) => String(payload.schema));
+  const expectedScript = elevatedHashes.map((hash) => `elevate|${hash}`);
+  if (!sameStrings2(expectedPayloadHashes, signedPayloadHashes) || !sameStrings2(expectedPayloadHashes, signed[0].payload_hashes) || !sameStrings2(expectedSchemas, signed[0].payload_schemas) || !sameStrings2(expectedScript, signed[0].script ?? [])) {
+    throw new Error("Signed transaction content differs from the requested publication intent");
+  }
+}
+async function assertResumableEvidence(evidence) {
+  const reconstructed = await createSignedXl1TransactionEvidence(evidence.transaction);
+  if (!sameValue2(reconstructed, evidence)) {
+    throw new Error("Publication journal evidence does not match its signed transaction");
+  }
+}
+async function assertPublicationRecord(record2, intent, prepared) {
+  if (typeof record2 !== "object" || record2 === null) {
+    throw new Error("Publication journal returned a malformed record");
+  }
+  if (!PublicationPhaseSet.has(record2.phase)) throw new Error("Publication journal returned an unknown phase");
+  if (!sameIntent2(intentFromRecord2(record2), intent)) {
+    throw new Error("Publication journal returned a different publication intent");
+  }
+  await assertResumableEvidence(record2.evidence);
+  await assertPreparedPublicationIntent(prepared, record2.evidence, intent);
+  const requiresInclusion = record2.phase === "included" || record2.phase === "finalized";
+  if (requiresInclusion !== (record2.inclusion !== void 0)) {
+    throw new Error(`Publication journal ${record2.phase} record has invalid inclusion evidence`);
+  }
+  if (record2.inclusion !== void 0) {
+    validateInclusion(record2.inclusion, record2.phase);
+    if (record2.inclusion.transactionHash !== record2.evidence.transactionHash) {
+      throw new Error("Publication journal inclusion does not identify the signed transaction");
+    }
+  }
+}
+async function defaultWait(delayMs) {
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function poll(operation, options, label) {
+  const attempts = positiveInteger(options?.attempts, 120, "polling.attempts");
+  const delayMs = nonnegativeInteger(options?.delayMs, 500, "polling.delayMs");
+  const wait = options?.wait ?? defaultWait;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const result = await operation();
+    if (result !== null) return result;
+    if (attempt < attempts) await wait(delayMs);
+  }
+  throw new Error(`${label} was not observed after ${attempts} attempts`);
+}
+async function record(journal, phase, evidence, intent, inclusion) {
+  const result = {
+    ...intent,
+    evidence,
+    ...inclusion === void 0 ? {} : { inclusion },
+    phase
+  };
+  await journal.save(result);
+  return result;
+}
+function finalizedResult(record2) {
+  if (record2.phase !== "finalized" || record2.inclusion === void 0) {
+    throw new Error("Cannot construct finalized publication result from an incomplete record");
+  }
+  const finalizedBlock = validateInclusion(record2.inclusion, "finality");
+  if (record2.inclusion.transactionHash !== record2.evidence.transactionHash) throw new Error("Inclusion does not identify signed publication");
+  return {
+    attachmentHashes: record2.attachmentHashes,
+    eventHashes: record2.eventHashes,
+    evidence: record2.evidence,
+    finalizedBlock,
+    inclusion: record2.inclusion,
+    transactionHash: record2.evidence.transactionHash
+  };
+}
+async function bindSignedPublication(options, prepared, intent) {
+  const pinnedSigner = {
+    address: () => intent.source,
+    signTransaction: (transaction) => options.signer.signTransaction(transaction)
+  };
+  const pinnedViewer = {
+    chainId: () => intent.chainId,
+    currentBlockNumber: () => options.viewer.currentBlockNumber()
+  };
+  const unsigned = await buildXl1Transaction(
+    pinnedViewer,
+    pinnedSigner,
+    // Statement Graph 0.5 guarantees this partition contains only the Claim
+    // events from StatementToPublish. Its published PreparedStatements type is
+    // broader (`Payload[]`) than that runtime contract, while XL1 correctly
+    // requires the narrower elevated-payload union.
+    prepared.onChainPayloads,
+    prepared.offChainPayloads,
+    options.broadcast
+  );
+  const evidence = await signXl1Transaction(pinnedSigner, unsigned);
+  await assertSignedPublicationIntent(unsigned, evidence, intent.source);
+  await assertPreparedPublicationIntent(prepared, evidence, intent);
+  return await record(options.journal, "signed", evidence, intent);
+}
+async function exactPublicationInclusion(options, evidence) {
+  const inclusion = await observeXl1TransactionInclusion(options.viewer.block, evidence.transactionHash);
+  if (inclusion === null) return null;
+  validateInclusion(inclusion, "inclusion");
+  if (inclusion.transactionHash !== evidence.transactionHash) throw new Error("Inclusion does not identify signed publication");
+  return inclusion;
+}
+async function advanceBroadcast(options, intent, publication, resumed) {
+  const evidence = publication.evidence;
+  if (resumed) {
+    const inclusion = await exactPublicationInclusion(options, evidence);
+    if (inclusion !== null) return await record(options.journal, "included", evidence, intent, inclusion);
+  }
+  try {
+    await broadcastXl1Transaction(options.runner, evidence);
+  } catch (error) {
+    if (!resumed) throw error;
+    const inclusion = await exactPublicationInclusion(options, evidence);
+    if (inclusion === null) throw error;
+    return await record(options.journal, "included", evidence, intent, inclusion);
+  }
+  return publication.phase === "content-verified" ? await record(options.journal, "broadcast", evidence, intent) : publication;
+}
+async function completePublication(options, intent, initial, resumedFromBroadcastBoundary) {
+  let publication = initial;
+  const evidence = publication.evidence;
+  if (publication.phase === "signed") {
+    await writeXl1TransactionContent(options.bodyWriter, evidence);
+    publication = await record(options.journal, "content-written", evidence, intent);
+  }
+  if (publication.phase === "content-written") {
+    await verifyXl1TransactionContent(options.bodyReader, evidence);
+    publication = await record(options.journal, "content-verified", evidence, intent);
+  }
+  if (publication.phase === "content-verified" || publication.phase === "broadcast") {
+    publication = await advanceBroadcast(options, intent, publication, resumedFromBroadcastBoundary);
+  }
+  if (publication.phase === "broadcast") {
+    const inclusion = await poll(
+      async () => await observeXl1TransactionInclusion(options.viewer.block, evidence.transactionHash),
+      options.polling,
+      `transaction ${evidence.transactionHash} inclusion`
+    );
+    validateInclusion(inclusion, "inclusion");
+    if (inclusion.transactionHash !== evidence.transactionHash) throw new Error("Inclusion does not identify signed publication");
+    publication = await record(options.journal, "included", evidence, intent, inclusion);
+  }
+  if (publication.phase === "included") {
+    const inclusion = publication.inclusion;
+    if (inclusion === void 0) throw new Error("Included publication is missing inclusion evidence");
+    const inclusionBlock = validateInclusion(inclusion, "inclusion");
+    const finalized = await poll(
+      async () => await observeXl1TransactionFinality(options.viewer.block, inclusion),
+      options.polling,
+      `transaction ${evidence.transactionHash} finality`
+    );
+    const finalizedBlock = validateInclusion(finalized, "finality");
+    assertSameInclusion(inclusion, inclusionBlock, finalized, finalizedBlock);
+    publication = await record(options.journal, "finalized", evidence, intent, finalized);
+  }
+  return publication;
+}
+async function publishFinalizedStatements(options) {
+  const chainId = String(await options.viewer.chainId());
+  if (options.expectedChainId !== void 0 && chainId !== options.expectedChainId) {
+    throw new Error("XL1 viewer chain does not match the expected publication chain");
+  }
+  const signerAddress = String(await options.signer.address());
+  if (options.expectedSource !== void 0 && signerAddress !== options.expectedSource) {
+    throw new Error("XL1 signer does not match the expected publication source");
+  }
+  const prepared = await prepareStatements(options.statements, [signerAddress]);
+  const attachmentHashes = await assertExactAcceptanceAttachments(
+    options.statements,
+    options.attachments ?? []
+  );
+  const intent = {
+    attachmentHashes,
+    chainId,
+    eventHashes: prepared.eventHashes,
+    operationId: publicationOperationId(options.operationId),
+    source: signerAddress
+  };
+  let publication = await options.journal.load(intent);
+  const resumedFromBroadcastBoundary = publication?.phase === "content-verified" || publication?.phase === "broadcast";
+  if (publication !== void 0) {
+    await assertPublicationRecord(publication, intent, prepared);
+    if (publication.phase === "finalized") return finalizedResult(publication);
+  }
+  const verifiedAttachmentHashes = await insertVerified(
+    {
+      get: async (hashes) => await options.bodyReader.get(hashes),
+      insert: async (payloads) => await options.bodyWriter.insert(payloads)
+    },
+    options.attachments ?? []
+  );
+  if (!sameStrings2(attachmentHashes, verifiedAttachmentHashes)) {
+    throw new Error("Verified publication attachment hashes differ from the supplied attachment bodies");
+  }
+  publication ??= await bindSignedPublication(options, prepared, intent);
+  publication = await completePublication(options, intent, publication, resumedFromBroadcastBoundary);
+  return finalizedResult(publication);
+}
+
+// src/handshakePublication.ts
+import {
+  EncryptedWakeSubscriptionZod,
+  EndpointChallengeResponseZod,
+  EndpointChallengeZod,
+  normalizeAddress,
+  NormalizedAddressZod,
+  PublisherEncryptionKeyRevocationZod,
+  PublisherEncryptionKeyZod,
+  PublisherServiceRevocationZod,
+  PublisherServiceZod,
+  WakeGrantObjectZod,
+  WakeGrantRevocationZod,
+  WakeSubscriptionAcceptanceRevocationZod,
+  WakeSubscriptionAcceptanceZod as WakeSubscriptionAcceptanceZod2,
+  WakeSubscriptionRevocationZod
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+import { buildClaim } from "@xyo-network/xl1-statement-graph-sdk";
+
+// src/networkSession.ts
+import { ChainIdZod } from "@xyo-network/event-kit-schemas";
+import {
+  DefaultNetworks,
+  MainNetwork,
+  NetworkDataLakeUrls,
+  SequenceNetwork
+} from "@xyo-network/xl1-sdk";
+var EVENT_KIT_NETWORK_IDS = ["local", "sequence", "mainnet"];
+function configuredNetwork(network) {
+  const found = DefaultNetworks.find((candidate) => candidate.id === network);
+  if (found === void 0) {
+    throw new Error(`XL1 SDK does not define the Event Kit network ${network}`);
+  }
+  return found;
+}
+function parseNetworkId(value) {
+  if (EVENT_KIT_NETWORK_IDS.includes(value)) return value;
+  throw new TypeError(`network must be one of ${EVENT_KIT_NETWORK_IDS.join("|")}`);
+}
+function endpoint(value, name) {
+  const trimmed = value.trim();
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new TypeError(`${name} must be an absolute HTTP(S) URL`);
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username !== "" || parsed.password !== "" || parsed.hash !== "") {
+    throw new TypeError(`${name} must be an absolute HTTP(S) URL without userinfo or a fragment`);
+  }
+  return parsed.href;
+}
+function defaultRpcUrl(network) {
+  return `${network.url.replace(/\/$/u, "")}/rpc`;
+}
+function sdkChainId(network) {
+  return network.chain === void 0 ? void 0 : ChainIdZod.parse(String(network.chain).toLowerCase());
+}
+function publicNetworkForChain(chainId) {
+  if (chainId === sdkChainId(MainNetwork)) return "mainnet";
+  if (chainId === sdkChainId(SequenceNetwork)) return "sequence";
+  return void 0;
+}
+function assertResolutionChain(resolution, chainId) {
+  const publicNetwork = publicNetworkForChain(chainId);
+  if (publicNetwork !== void 0 && publicNetwork !== resolution.network) {
+    throw new Error(`Connected chain ${chainId} is ${publicNetwork}, not ${resolution.network}`);
+  }
+  if (resolution.expectedChainId !== void 0 && resolution.expectedChainId !== chainId) {
+    throw new Error(
+      `Connected chain ID ${chainId} does not match ${resolution.network} chain ID ${resolution.expectedChainId}`
+    );
+  }
+}
+async function observedChainId(viewer) {
+  return ChainIdZod.parse(String(await viewer.chainId()).toLowerCase());
+}
+function resolveEventKitNetwork(options) {
+  const networkId = parseNetworkId(options.network);
+  const network = configuredNetwork(networkId);
+  const defaultDataLake = NetworkDataLakeUrls[networkId];
+  if (defaultDataLake === void 0) throw new Error(`XL1 SDK does not define a datalake for ${networkId}`);
+  const expectedChainId = sdkChainId(network);
+  return Object.freeze({
+    dataLakeUrl: endpoint(options.dataLakeUrl ?? defaultDataLake, "dataLakeUrl"),
+    ...expectedChainId === void 0 ? {} : { expectedChainId },
+    network: networkId,
+    rpcUrl: endpoint(options.rpcUrl ?? defaultRpcUrl(network), "rpcUrl")
+  });
+}
+async function pinEventKitNetworkSession(options) {
+  const chainId = await observedChainId(options.viewer);
+  const requestedPin = options.expectedChainId === void 0 ? void 0 : ChainIdZod.parse(options.expectedChainId.toLowerCase());
+  if (requestedPin !== void 0 && requestedPin !== chainId) {
+    throw new Error(`Connected chain ID ${chainId} does not match requested chain ID ${requestedPin}`);
+  }
+  assertResolutionChain(options.resolution, chainId);
+  return Object.freeze({ ...options.resolution, chainId });
+}
+async function assertEventKitNetworkSession(session, viewer) {
+  const network = parseNetworkId(session.network);
+  const chainId = ChainIdZod.parse(session.chainId.toLowerCase());
+  assertResolutionChain({ ...session, network }, chainId);
+  const observed = await observedChainId(viewer);
+  if (observed !== chainId) {
+    throw new Error(`Connected chain ID ${observed} does not match pinned chain ID ${chainId}`);
+  }
+}
+async function assertEventKitNetworkWrite(session, viewer) {
+  if (session.network === "mainnet" || session.chainId === sdkChainId(MainNetwork)) {
+    throw new Error("Event Kit Mainnet writes are disabled until the Phase 7 canary interlock exists");
+  }
+  await assertEventKitNetworkSession(session, viewer);
+}
+
+// src/handshakePublication.ts
+async function objectHash(object) {
+  return String(await PayloadBuilder2.dataHash(object));
+}
+async function signerSource(options) {
+  const raw = String(await options.signer.address());
+  const normalized = NormalizedAddressZod.parse(normalizeAddress(raw));
+  if (raw !== normalized) {
+    throw new TypeError("XL1 signer address must be canonical lowercase hexadecimal without 0x");
+  }
+  return normalized;
+}
+function failBinding(message) {
+  throw new Error(`Invalid Event Kit handshake publication: ${message}`);
+}
+async function publishHandshakeObjects(transport, source, subject, objects, identities, attachments = []) {
+  await assertEventKitNetworkWrite(transport.session, transport.viewer);
+  if (source !== await signerSource(transport)) failBinding("Claim source does not match the transaction signer");
+  const hashes = identities.map((identity) => identity.objectHash);
+  const claim = buildClaim({
+    hashes,
+    source,
+    subject
+  });
+  const claimHash = await objectHash(claim);
+  const { session: _session, ...publication } = transport;
+  const result = await publishFinalizedStatements({
+    ...publication,
+    attachments,
+    expectedChainId: transport.session.chainId,
+    expectedSource: source,
+    statements: [{ event: claim, objects }]
+  });
+  if (result.eventHashes.length !== 1 || result.eventHashes[0] !== claimHash) {
+    throw new Error("Finalized publication evidence does not identify the exact Event Kit Claim");
+  }
+  return {
+    ...result,
+    chainId: transport.session.chainId,
+    claim,
+    claimHash,
+    network: transport.session.network,
+    objects: identities,
+    source,
+    subject
+  };
+}
+async function publishPublisherService(options) {
+  const {
+    encryptionKeys: rawKeys,
+    service: rawService,
+    ...transport
+  } = options;
+  const service = PublisherServiceZod.parse(rawService);
+  const keys = rawKeys.map((key) => PublisherEncryptionKeyZod.parse(key));
+  const source = await signerSource(transport);
+  const [serviceHash, keyEntries] = await Promise.all([
+    objectHash(service),
+    Promise.all(keys.map(async (key) => ({ hash: await objectHash(key), key })))
+  ]);
+  const keysByHash = new Map(keyEntries.map((entry) => [entry.hash, entry.key]));
+  if (keysByHash.size !== keyEntries.length) failBinding("encryption key descriptor bodies must be unique");
+  if (keysByHash.size !== service.encryptionKeys.length || service.encryptionKeys.some((hash) => !keysByHash.has(hash))) {
+    failBinding("service.encryptionKeys must exactly identify the supplied key descriptors");
+  }
+  const orderedKeys = service.encryptionKeys.map((hash) => {
+    const key = keysByHash.get(hash);
+    if (key === void 0) return failBinding(`missing encryption key descriptor ${hash}`);
+    return { hash, key };
+  });
+  return await publishHandshakeObjects(
+    transport,
+    source,
+    source,
+    [service, ...orderedKeys.map((entry) => entry.key)],
+    [
+      {
+        kind: "publisher-service",
+        objectHash: serviceHash,
+        revision: service.revision,
+        schema: service.schema,
+        serviceId: service.serviceId
+      },
+      ...orderedKeys.map(({ hash, key }) => ({
+        keyId: key.keyId,
+        kind: "publisher-encryption-key",
+        objectHash: hash,
+        schema: key.schema
+      }))
+    ]
+  );
+}
+async function publishWakeSubscription(options) {
+  const {
+    encryptionKey: rawKey,
+    grant: rawGrant,
+    service: rawService,
+    subscription: rawSubscription,
+    ...transport
+  } = options;
+  const key = PublisherEncryptionKeyZod.parse(rawKey);
+  const grant = WakeGrantObjectZod.parse(rawGrant);
+  const service = PublisherServiceZod.parse(rawService);
+  const subscription = EncryptedWakeSubscriptionZod.parse(rawSubscription);
+  const [keyHash, grantHash, serviceHash, subscriptionHash] = await Promise.all([
+    objectHash(key),
+    objectHash(grant),
+    objectHash(service),
+    objectHash(subscription)
+  ]);
+  if (subscription.chainId !== transport.session.chainId) failBinding("subscription chainId does not match the pinned session");
+  if (subscription.publisher !== grant.publisher) failBinding("subscription publisher does not match grant.publisher");
+  if (subscription.service !== serviceHash) failBinding("subscription service does not match the supplied service");
+  if (subscription.grant !== grantHash) failBinding("subscription grant does not match the supplied grant");
+  if (subscription.encryptionKey !== keyHash || subscription.keyId !== key.keyId) {
+    failBinding("subscription encryption key does not match the supplied descriptor");
+  }
+  if (service.preferredEncryptionKey !== keyHash || !service.encryptionKeys.includes(keyHash)) {
+    failBinding("subscription must use the selected service preferred encryption key");
+  }
+  const source = await signerSource(transport);
+  const subject = NormalizedAddressZod.parse(subscription.publisher);
+  return await publishHandshakeObjects(
+    transport,
+    source,
+    subject,
+    [service, grant, subscription],
+    [
+      {
+        kind: "publisher-service",
+        objectHash: serviceHash,
+        revision: service.revision,
+        schema: service.schema,
+        serviceId: service.serviceId
+      },
+      {
+        deploymentId: grant.deploymentId,
+        grantId: grant.grantId,
+        kind: "wake-grant",
+        objectHash: grantHash,
+        schema: grant.schema
+      },
+      {
+        kind: "wake-subscription",
+        objectHash: subscriptionHash,
+        revision: subscription.revision,
+        schema: subscription.schema,
+        subscriptionId: subscription.subscriptionId
+      }
+    ]
+  );
+}
+async function publishWakeSubscriptionAcceptance(options) {
+  const {
+    acceptance: rawAcceptance,
+    challenge: rawChallenge,
+    response: rawResponse,
+    ...transport
+  } = options;
+  const acceptance = WakeSubscriptionAcceptanceZod2.parse(rawAcceptance);
+  const challenge = EndpointChallengeZod.parse(rawChallenge);
+  const response = EndpointChallengeResponseZod.parse(rawResponse);
+  const [acceptanceHash, challengeHash, responseHash] = await Promise.all([
+    objectHash(acceptance),
+    objectHash(challenge),
+    objectHash(response)
+  ]);
+  const source = await signerSource(transport);
+  if (challenge.publisher !== source) failBinding("challenge publisher does not match the transaction signer");
+  if (challenge.chainId !== transport.session.chainId) failBinding("challenge chainId does not match the pinned session");
+  if (response.challenge !== challengeHash) failBinding("response does not reference the supplied challenge");
+  if (acceptance.challenge !== challengeHash || acceptance.response !== responseHash) {
+    failBinding("acceptance does not reference the supplied challenge and response");
+  }
+  if (acceptance.service !== challenge.service || acceptance.encryptionKey !== challenge.encryptionKey || acceptance.subscription !== challenge.subscription || acceptance.grant !== challenge.grant) {
+    failBinding("acceptance tuple does not match the supplied challenge");
+  }
+  return await publishHandshakeObjects(
+    transport,
+    source,
+    source,
+    [acceptance],
+    [{
+      challenge: challengeHash,
+      kind: "wake-subscription-acceptance",
+      objectHash: acceptanceHash,
+      response: responseHash,
+      schema: acceptance.schema,
+      subscription: acceptance.subscription
+    }],
+    [challenge, response]
+  );
+}
+async function publishRevocation(transport, publisher, revocation, kind, targetHash) {
+  const source = await signerSource(transport);
+  const subject = NormalizedAddressZod.parse(publisher);
+  const revocationHash = await objectHash(revocation);
+  return await publishHandshakeObjects(
+    transport,
+    source,
+    subject,
+    [revocation],
+    [{
+      kind,
+      objectHash: revocationHash,
+      schema: String(revocation.schema),
+      targetHash
+    }]
+  );
+}
+async function publishPublisherServiceRevocation(options) {
+  const { revocation: rawRevocation, ...transport } = options;
+  const revocation = PublisherServiceRevocationZod.parse(rawRevocation);
+  const publisher = await signerSource(transport);
+  return await publishRevocation(transport, publisher, revocation, "publisher-service-revocation", revocation.service);
+}
+async function publishPublisherEncryptionKeyRevocation(options) {
+  const { revocation: rawRevocation, ...transport } = options;
+  const revocation = PublisherEncryptionKeyRevocationZod.parse(rawRevocation);
+  const publisher = await signerSource(transport);
+  return await publishRevocation(
+    transport,
+    publisher,
+    revocation,
+    "publisher-encryption-key-revocation",
+    revocation.key
+  );
+}
+async function publishWakeSubscriptionRevocation(options) {
+  const {
+    publisher,
+    revocation: rawRevocation,
+    ...transport
+  } = options;
+  const revocation = WakeSubscriptionRevocationZod.parse(rawRevocation);
+  return await publishRevocation(
+    transport,
+    publisher,
+    revocation,
+    "wake-subscription-revocation",
+    revocation.subscription
+  );
+}
+async function publishWakeGrantRevocation(options) {
+  const {
+    publisher,
+    revocation: rawRevocation,
+    ...transport
+  } = options;
+  const revocation = WakeGrantRevocationZod.parse(rawRevocation);
+  return await publishRevocation(transport, publisher, revocation, "wake-grant-revocation", revocation.grant);
+}
+async function publishWakeSubscriptionAcceptanceRevocation(options) {
+  const { revocation: rawRevocation, ...transport } = options;
+  const revocation = WakeSubscriptionAcceptanceRevocationZod.parse(rawRevocation);
+  const publisher = await signerSource(transport);
+  return await publishRevocation(
+    transport,
+    publisher,
+    revocation,
+    "wake-subscription-acceptance-revocation",
+    revocation.acceptance
+  );
+}
 export {
-  createXl1FinalizedHeadSource
+  EVENT_KIT_NETWORK_IDS,
+  assertEventKitNetworkSession,
+  assertEventKitNetworkWrite,
+  createMemoryFinalizedStatementPublicationJournal,
+  createXl1FinalizedHeadSource,
+  pinEventKitNetworkSession,
+  publishFinalizedStatements,
+  publishPublisherEncryptionKeyRevocation,
+  publishPublisherService,
+  publishPublisherServiceRevocation,
+  publishWakeGrantRevocation,
+  publishWakeSubscription,
+  publishWakeSubscriptionAcceptance,
+  publishWakeSubscriptionAcceptanceRevocation,
+  publishWakeSubscriptionRevocation,
+  resolveEventKitNetwork
 };
 //# sourceMappingURL=index.mjs.map