@xyo-network/event-kit-protocol 0.0.1 → 0.1.1

package/dist/neutral/index.mjs

@@ -239,28 +239,723 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/canonicalJson.ts
+var textEncoder = new TextEncoder();
+function hasUnpairedSurrogate(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const codePoint = value.codePointAt(index);
+    if (codePoint === void 0 || codePoint >= 55296 && codePoint <= 57343) return true;
+    if (codePoint > 65535) index += 1;
+  }
+  return false;
+}
+function canonicalize(value) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number": {
+      if (!Number.isFinite(value)) throw new TypeError("Canonical JSON numbers must be finite");
+      return JSON.stringify(value);
+    }
+    case "string": {
+      if (hasUnpairedSurrogate(value)) throw new TypeError("Canonical JSON strings must be valid Unicode");
+      return JSON.stringify(value);
+    }
+    case "object": {
+      if (Array.isArray(value)) return `[${value.map((item) => canonicalize(item)).join(",")}]`;
+      const prototype = Reflect.getPrototypeOf(value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("Canonical JSON objects must be plain records");
+      }
+      const record = value;
+      const members = Object.keys(record).sort().map((key) => {
+        if (hasUnpairedSurrogate(key)) throw new TypeError("Canonical JSON keys must be valid Unicode");
+        const member = record[key];
+        if (member === void 0) throw new TypeError("Canonical JSON does not permit undefined members");
+        return `${JSON.stringify(key)}:${canonicalize(member)}`;
+      });
+      return `{${members.join(",")}}`;
+    }
+    default:
+      throw new TypeError(`Canonical JSON cannot encode ${typeof value}`);
+  }
+}
+function canonicalJson(value) {
+  return canonicalize(value);
+}
+function canonicalJsonBytes(value) {
+  return textEncoder.encode(canonicalize(value));
+}
+
+// src/endpointChallenge.ts
+import {
+  Base64Url32BytesZod,
+  bytesToCanonicalBase64Url,
+  canonicalBase64UrlToBytes,
+  EndpointChallengeResponseSchema,
+  EndpointChallengeResponseZod,
+  EndpointChallengeSchema,
+  EndpointChallengeZod,
+  generateChallengeNonce,
+  generateHandshakeId,
+  MAX_ENDPOINT_CHALLENGE_LIFETIME_SECONDS
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder } from "@xyo-network/sdk";
+function hashBytes(hash) {
+  return Uint8Array.from({ length: 32 }, (_, index) => Number.parseInt(hash.slice(index * 2, index * 2 + 2), 16));
+}
+async function hmacProof(secret, challengeHash) {
+  const secretBytes = canonicalBase64UrlToBytes(Base64Url32BytesZod.parse(secret));
+  if (secretBytes?.length !== 32) throw new TypeError("Expected 32-byte challenge secret");
+  const cryptoKey = await globalThis.crypto.subtle.importKey(
+    "raw",
+    Uint8Array.from(secretBytes),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await globalThis.crypto.subtle.sign("HMAC", cryptoKey, hashBytes(challengeHash));
+  return Base64Url32BytesZod.parse(bytesToCanonicalBase64Url(new Uint8Array(signature)));
+}
+function equalProof(left, right) {
+  const leftBytes = canonicalBase64UrlToBytes(left);
+  const rightBytes = canonicalBase64UrlToBytes(right);
+  if (leftBytes?.length !== 32 || rightBytes?.length !== 32) return false;
+  let difference = 0;
+  for (let index = 0; index < 32; index += 1) difference |= leftBytes[index] ^ rightBytes[index];
+  return difference === 0;
+}
+async function endpointChallengeHash(challenge) {
+  const parsed = EndpointChallengeZod.parse(challenge);
+  return await PayloadBuilder.dataHash(parsed);
+}
+function createEndpointChallenge(input) {
+  const lifetimeSeconds = input.lifetimeSeconds ?? MAX_ENDPOINT_CHALLENGE_LIFETIME_SECONDS;
+  if (!Number.isSafeInteger(lifetimeSeconds) || lifetimeSeconds < 1) {
+    throw new RangeError("Challenge lifetime must be a positive safe integer");
+  }
+  if (!Number.isSafeInteger(input.issuedAt) || input.issuedAt < 0) {
+    throw new RangeError("Challenge issuedAt must be a nonnegative safe integer");
+  }
+  if (input.issuedAt > Number.MAX_SAFE_INTEGER - lifetimeSeconds) {
+    throw new RangeError("Challenge expiry exceeds the JSON safe-integer range");
+  }
+  return EndpointChallengeZod.parse(new PayloadBuilder({ schema: EndpointChallengeSchema }).fields({
+    challengeId: generateHandshakeId(),
+    chainId: input.chainId,
+    publisher: input.publisher,
+    subscriber: input.subscriber,
+    service: input.service,
+    encryptionKey: input.encryptionKey,
+    keyId: input.keyId,
+    subscription: input.subscription,
+    grant: input.grant,
+    eventKind: input.eventKind,
+    nonce: generateChallengeNonce(),
+    issuedAt: input.issuedAt,
+    expiresAt: input.issuedAt + lifetimeSeconds
+  }).build());
+}
+async function createEndpointChallengeResponse(challenge, secret) {
+  const challengeHash = await endpointChallengeHash(challenge);
+  return EndpointChallengeResponseZod.parse(new PayloadBuilder({ schema: EndpointChallengeResponseSchema }).fields({
+    challenge: challengeHash,
+    proof: await hmacProof(secret, challengeHash)
+  }).build());
+}
+async function verifyEndpointChallengeProof(input) {
+  try {
+    const challenge = EndpointChallengeZod.parse(input.challenge);
+    const response = EndpointChallengeResponseZod.parse(input.response);
+    const challengeHash = await endpointChallengeHash(challenge);
+    if (response.challenge !== challengeHash) return false;
+    return equalProof(response.proof, await hmacProof(input.secret, challengeHash));
+  } catch {
+    return false;
+  }
+}
+async function verifyEndpointChallengeResponse(input) {
+  try {
+    const challenge = EndpointChallengeZod.parse(input.challenge);
+    if (!Number.isSafeInteger(input.nowSeconds) || input.nowSeconds < challenge.issuedAt || input.nowSeconds >= challenge.expiresAt) return false;
+    return await verifyEndpointChallengeProof(input);
+  } catch {
+    return false;
+  }
+}
+
+// src/handshakeConstruction.ts
+import {
+  bytesToCanonicalBase64Url as bytesToCanonicalBase64Url3,
+  EncryptedWakeSubscriptionSchema,
+  EncryptedWakeSubscriptionZod as EncryptedWakeSubscriptionZod3,
+  ENDPOINT_CHALLENGE_HMAC_SHA256_PROFILE,
+  EndpointChallengeResponseZod as EndpointChallengeResponseZod2,
+  EndpointChallengeZod as EndpointChallengeZod2,
+  FINALIZED_HEAD_EVENT_KIND,
+  FINALIZED_HEAD_FILTER_PROFILE,
+  generateGrantId,
+  generateHandshakeId as generateHandshakeId2,
+  HashZod as HashZod2,
+  MAX_SUBSCRIPTION_PLAINTEXT_BYTES as MAX_SUBSCRIPTION_PLAINTEXT_BYTES2,
+  PublisherEncryptionKeyRevocationSchema,
+  PublisherEncryptionKeyRevocationZod,
+  PublisherEncryptionKeySchema,
+  PublisherEncryptionKeyZod,
+  PublisherServiceRevocationSchema,
+  PublisherServiceRevocationZod,
+  PublisherServiceSchema,
+  PublisherServiceZod,
+  WAKE_SUBSCRIPTION_HPKE_PROFILE as WAKE_SUBSCRIPTION_HPKE_PROFILE3,
+  WAKE_WALLET_JWT_DELIVERY_PROFILE,
+  WakeGrantObjectSchema,
+  WakeGrantObjectZod,
+  WakeGrantRevocationSchema,
+  WakeGrantRevocationZod,
+  WakeSubscriptionAcceptanceRevocationSchema,
+  WakeSubscriptionAcceptanceRevocationZod,
+  WakeSubscriptionAcceptanceSchema,
+  WakeSubscriptionAcceptanceZod,
+  WakeSubscriptionCleartextZod as WakeSubscriptionCleartextZod3,
+  WakeSubscriptionPlaintextSchema,
+  WakeSubscriptionPlaintextZod as WakeSubscriptionPlaintextZod2,
+  WakeSubscriptionRevocationSchema,
+  WakeSubscriptionRevocationZod
+} from "@xyo-network/event-kit-schemas";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/sdk";
+
+// src/wakeSubscriptionHpke.ts
+import {
+  Aes128Gcm,
+  CipherSuite,
+  DhkemX25519HkdfSha256,
+  HkdfSha256
+} from "@hpke/core";
+import {
+  Base64Url32BytesZod as Base64Url32BytesZod2,
+  bytesToCanonicalBase64Url as bytesToCanonicalBase64Url2,
+  canonicalBase64UrlToBytes as canonicalBase64UrlToBytes2,
+  EncryptedWakeSubscriptionZod as EncryptedWakeSubscriptionZod2,
+  HandshakeIdZod,
+  HashZod,
+  NormalizedAddressZod as NormalizedAddressZod2,
+  WAKE_SUBSCRIPTION_HPKE_PROFILE as WAKE_SUBSCRIPTION_HPKE_PROFILE2,
+  WakeSubscriptionCleartextZod as WakeSubscriptionCleartextZod2
+} from "@xyo-network/event-kit-schemas";
+
+// src/wakeSubscriptionEncoding.ts
+import {
+  EncryptedWakeSubscriptionZod,
+  MAX_SUBSCRIPTION_PLAINTEXT_BYTES,
+  NormalizedAddressZod,
+  WAKE_SUBSCRIPTION_HPKE_PROFILE,
+  WakeSubscriptionCleartextZod,
+  WakeSubscriptionPlaintextZod
+} from "@xyo-network/event-kit-schemas";
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function equalBytes(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) difference |= left[index] ^ right[index];
+  return difference === 0;
+}
+function cleartextFromEncrypted(subscription) {
+  const { encryption: _encryption, ...cleartext } = subscription;
+  return cleartext;
+}
+function wakeSubscriptionAadBytes(subscription, subscriber) {
+  const parsedSubscriber = NormalizedAddressZod.parse(subscriber);
+  const parsedSubscription = "encryption" in subscription ? cleartextFromEncrypted(EncryptedWakeSubscriptionZod.parse(subscription)) : WakeSubscriptionCleartextZod.parse(subscription);
+  return canonicalJsonBytes({
+    schema: parsedSubscription.schema,
+    chainId: parsedSubscription.chainId,
+    subscriber: parsedSubscriber,
+    publisher: parsedSubscription.publisher,
+    service: parsedSubscription.service,
+    encryptionKey: parsedSubscription.encryptionKey,
+    keyId: parsedSubscription.keyId,
+    grant: parsedSubscription.grant,
+    subscriptionId: parsedSubscription.subscriptionId,
+    revision: parsedSubscription.revision,
+    supersedes: parsedSubscription.supersedes ?? null,
+    eventKind: parsedSubscription.eventKind,
+    expiresAtBlock: parsedSubscription.expiresAtBlock,
+    profile: WAKE_SUBSCRIPTION_HPKE_PROFILE
+  });
+}
+function wakeSubscriptionPlaintextBytes(plaintext) {
+  const parsed = WakeSubscriptionPlaintextZod.parse(plaintext);
+  const encoded = canonicalJsonBytes(parsed);
+  if (encoded.length > MAX_SUBSCRIPTION_PLAINTEXT_BYTES) {
+    throw new RangeError(`Wake subscription plaintext exceeds ${MAX_SUBSCRIPTION_PLAINTEXT_BYTES} bytes`);
+  }
+  return encoded;
+}
+function wakeSubscriptionPlaintextFromBytes(encoded) {
+  if (encoded.length > MAX_SUBSCRIPTION_PLAINTEXT_BYTES) {
+    throw new RangeError(`Wake subscription plaintext exceeds ${MAX_SUBSCRIPTION_PLAINTEXT_BYTES} bytes`);
+  }
+  const decoded = textDecoder.decode(encoded);
+  const parsed = WakeSubscriptionPlaintextZod.parse(JSON.parse(decoded));
+  if (!equalBytes(encoded, canonicalJsonBytes(parsed))) {
+    throw new TypeError("Wake subscription plaintext is not canonically encoded");
+  }
+  return parsed;
+}
+
+// src/wakeSubscriptionHpke.ts
+var suite = new CipherSuite({
+  kem: new DhkemX25519HkdfSha256(),
+  kdf: new HkdfSha256(),
+  aead: new Aes128Gcm()
+});
+var hpkeInfo = new TextEncoder().encode(WAKE_SUBSCRIPTION_HPKE_PROFILE2);
+function asInternalHpkeKeyPair(value) {
+  if (typeof value !== "object" || value === null || !("privateKey" in value) || !("publicKey" in value)) {
+    throw new TypeError("HPKE implementation returned an invalid key pair");
+  }
+  return {
+    privateKey: value.privateKey,
+    publicKey: value.publicKey
+  };
+}
+var WakeSubscriptionDecryptionError = class extends Error {
+  name = "WakeSubscriptionDecryptionError";
+  constructor() {
+    super("Wake subscription cryptographic validation failed");
+  }
+};
+function parsePublicKey(value) {
+  return {
+    encryptionKey: HashZod.parse(value.encryptionKey),
+    keyId: HandshakeIdZod.parse(value.keyId),
+    publicKey: Base64Url32BytesZod2.parse(value.publicKey)
+  };
+}
+function parsePrivateKey(value) {
+  return {
+    encryptionKey: HashZod.parse(value.encryptionKey),
+    keyId: HandshakeIdZod.parse(value.keyId),
+    privateKey: Base64Url32BytesZod2.parse(value.privateKey)
+  };
+}
+function decoded32(value) {
+  const decoded = canonicalBase64UrlToBytes2(value);
+  if (decoded?.length !== 32) throw new TypeError("Expected 32 canonical bytes");
+  return decoded;
+}
+async function generateWakeSubscriptionEncryptionKeyPair() {
+  const generated = await suite.kem.generateKeyPair();
+  const keyPair = asInternalHpkeKeyPair(generated);
+  const [publicKey, privateKey] = await Promise.all([
+    suite.kem.serializePublicKey(keyPair.publicKey),
+    suite.kem.serializePrivateKey(keyPair.privateKey)
+  ]);
+  return {
+    publicKey: Base64Url32BytesZod2.parse(bytesToCanonicalBase64Url2(new Uint8Array(publicKey))),
+    privateKey: Base64Url32BytesZod2.parse(bytesToCanonicalBase64Url2(new Uint8Array(privateKey)))
+  };
+}
+async function encryptWakeSubscription(input) {
+  const subscription = WakeSubscriptionCleartextZod2.parse(input.subscription);
+  const subscriber = NormalizedAddressZod2.parse(input.subscriber);
+  const publisherKey = parsePublicKey(input.publisherKey);
+  if (subscription.encryptionKey !== publisherKey.encryptionKey || subscription.keyId !== publisherKey.keyId) {
+    throw new TypeError("Subscription key reference does not match the supplied publisher key");
+  }
+  const recipientPublicKey = await suite.kem.deserializePublicKey(decoded32(publisherKey.publicKey));
+  const { ct, enc } = await suite.seal(
+    { recipientPublicKey, info: hpkeInfo },
+    wakeSubscriptionPlaintextBytes(input.plaintext),
+    wakeSubscriptionAadBytes(subscription, subscriber)
+  );
+  return EncryptedWakeSubscriptionZod2.parse({
+    ...subscription,
+    encryption: {
+      profile: WAKE_SUBSCRIPTION_HPKE_PROFILE2,
+      enc: bytesToCanonicalBase64Url2(new Uint8Array(enc)),
+      ciphertext: bytesToCanonicalBase64Url2(new Uint8Array(ct))
+    }
+  });
+}
+async function decryptWakeSubscription(input) {
+  try {
+    const subscription = EncryptedWakeSubscriptionZod2.parse(input.subscription);
+    const subscriber = NormalizedAddressZod2.parse(input.subscriber);
+    const publisherKey = parsePrivateKey(input.publisherKey);
+    if (subscription.encryptionKey !== publisherKey.encryptionKey || subscription.keyId !== publisherKey.keyId) throw new TypeError("Key reference mismatch");
+    const recipientKey = await suite.kem.deserializePrivateKey(decoded32(publisherKey.privateKey));
+    const plaintext = await suite.open(
+      {
+        recipientKey,
+        enc: decoded32(subscription.encryption.enc),
+        info: hpkeInfo
+      },
+      canonicalBase64UrlToBytes2(subscription.encryption.ciphertext) ?? new Uint8Array(),
+      wakeSubscriptionAadBytes(subscription, subscriber)
+    );
+    return wakeSubscriptionPlaintextFromBytes(new Uint8Array(plaintext));
+  } catch {
+    throw new WakeSubscriptionDecryptionError();
+  }
+}
+
+// src/handshakeConstruction.ts
+var publicObjectParsers = [
+  PublisherServiceZod,
+  PublisherEncryptionKeyZod,
+  PublisherServiceRevocationZod,
+  PublisherEncryptionKeyRevocationZod,
+  EncryptedWakeSubscriptionZod3,
+  WakeGrantObjectZod,
+  WakeGrantRevocationZod,
+  WakeSubscriptionRevocationZod,
+  WakeSubscriptionAcceptanceZod,
+  WakeSubscriptionAcceptanceRevocationZod,
+  EndpointChallengeZod2,
+  EndpointChallengeResponseZod2
+];
+function parseHandshakePublicObject(value) {
+  for (const parser of publicObjectParsers) {
+    const parsed = parser.safeParse(value);
+    if (parsed.success) return parsed.data;
+  }
+  throw new TypeError("Expected a strict Event Kit handshake public object");
+}
+async function handshakeObjectHash(object) {
+  return HashZod2.parse(await PayloadBuilder2.dataHash(parseHandshakePublicObject(object)));
+}
+async function withHandshakeObjectHash(body) {
+  return Object.freeze({ body, objectHash: await handshakeObjectHash(body) });
+}
+function createPublisherEncryptionKey(input) {
+  return PublisherEncryptionKeyZod.parse(new PayloadBuilder2({ schema: PublisherEncryptionKeySchema }).fields({
+    keyId: input.keyId ?? generateHandshakeId2(),
+    profile: WAKE_SUBSCRIPTION_HPKE_PROFILE3,
+    publicKey: input.publicKey,
+    validFromBlock: input.validFromBlock,
+    ...input.expiresAtBlock === void 0 ? {} : { expiresAtBlock: input.expiresAtBlock }
+  }).build());
+}
+async function generatePublisherEncryptionKey(input) {
+  const material = await generateWakeSubscriptionEncryptionKeyPair();
+  const descriptor = createPublisherEncryptionKey({
+    ...input,
+    publicKey: material.publicKey
+  });
+  const descriptorHash = await handshakeObjectHash(descriptor);
+  return Object.freeze({
+    descriptor,
+    descriptorHash,
+    privateKey: Object.freeze({
+      encryptionKey: descriptorHash,
+      keyId: descriptor.keyId,
+      privateKey: material.privateKey
+    }),
+    publicKey: Object.freeze({
+      encryptionKey: descriptorHash,
+      keyId: descriptor.keyId,
+      publicKey: descriptor.publicKey
+    })
+  });
+}
+function createPublisherService(input) {
+  return PublisherServiceZod.parse(new PayloadBuilder2({ schema: PublisherServiceSchema }).fields({
+    serviceId: input.serviceId ?? generateHandshakeId2(),
+    revision: input.revision ?? 1,
+    ...input.supersedes === void 0 ? {} : { supersedes: input.supersedes },
+    validFromBlock: input.validFromBlock,
+    ...input.expiresAtBlock === void 0 ? {} : { expiresAtBlock: input.expiresAtBlock },
+    events: [{ kind: FINALIZED_HEAD_EVENT_KIND, filterProfile: FINALIZED_HEAD_FILTER_PROFILE }],
+    deliveryProfile: WAKE_WALLET_JWT_DELIVERY_PROFILE,
+    challengeProfile: ENDPOINT_CHALLENGE_HMAC_SHA256_PROFILE,
+    encryptionProfile: WAKE_SUBSCRIPTION_HPKE_PROFILE3,
+    encryptionKeys: [...input.encryptionKeys],
+    preferredEncryptionKey: input.preferredEncryptionKey,
+    limits: {
+      maxBlocksPerWake: input.maxBlocksPerWake,
+      maxSubscriptionLifetimeBlocks: input.maxSubscriptionLifetimeBlocks,
+      maxPlaintextBytes: MAX_SUBSCRIPTION_PLAINTEXT_BYTES2
+    },
+    retirementPolicy: "existing-acceptances-continue"
+  }).build());
+}
+function createWakeGrant(input) {
+  return WakeGrantObjectZod.parse(new PayloadBuilder2({ schema: WakeGrantObjectSchema }).fields({
+    grantId: input.grantId ?? generateGrantId(),
+    deploymentId: input.deploymentId,
+    publisher: input.publisher,
+    ...input.queueId === void 0 ? {} : { queueId: input.queueId },
+    permissions: ["enqueue"]
+  }).build());
+}
+function createWakeSubscriptionPlaintext(input) {
+  const secretBytes = new Uint8Array(32);
+  if (input.challengeSecret === void 0) {
+    globalThis.crypto.getRandomValues(secretBytes);
+  }
+  const challengeSecret = input.challengeSecret ?? bytesToCanonicalBase64Url3(secretBytes);
+  return WakeSubscriptionPlaintextZod2.parse(new PayloadBuilder2({ schema: WakeSubscriptionPlaintextSchema }).fields({
+    endpoint: input.endpoint,
+    audience: input.audience,
+    deploymentId: input.deploymentId,
+    queueId: input.queueId ?? null,
+    filter: {
+      schema: FINALIZED_HEAD_FILTER_PROFILE,
+      maxBlocksPerWake: input.maxBlocksPerWake
+    },
+    challenge: {
+      profile: ENDPOINT_CHALLENGE_HMAC_SHA256_PROFILE,
+      secret: challengeSecret
+    }
+  }).build());
+}
+async function createEncryptedWakeSubscription(input) {
+  const cleartext = WakeSubscriptionCleartextZod3.parse(
+    new PayloadBuilder2({ schema: EncryptedWakeSubscriptionSchema }).fields({
+      subscriptionId: input.subscriptionId ?? generateHandshakeId2(),
+      revision: input.revision ?? 1,
+      ...input.supersedes === void 0 ? {} : { supersedes: input.supersedes },
+      chainId: input.chainId,
+      publisher: input.publisher,
+      service: input.service,
+      encryptionKey: input.publisherKey.encryptionKey,
+      keyId: input.publisherKey.keyId,
+      grant: input.grant,
+      eventKind: FINALIZED_HEAD_EVENT_KIND,
+      expiresAtBlock: input.expiresAtBlock
+    }).build()
+  );
+  return await encryptWakeSubscription({
+    plaintext: input.plaintext,
+    publisherKey: input.publisherKey,
+    subscriber: input.subscriber,
+    subscription: cleartext
+  });
+}
+function createWakeSubscriptionAcceptance(input) {
+  return WakeSubscriptionAcceptanceZod.parse(new PayloadBuilder2({ schema: WakeSubscriptionAcceptanceSchema }).fields({
+    challenge: input.challenge,
+    encryptionKey: input.encryptionKey,
+    grant: input.grant,
+    response: input.response,
+    service: input.service,
+    subscription: input.subscription
+  }).build());
+}
+function createPublisherServiceRevocation(service) {
+  return PublisherServiceRevocationZod.parse(new PayloadBuilder2({ schema: PublisherServiceRevocationSchema }).fields({ service }).build());
+}
+function createPublisherEncryptionKeyRevocation(key) {
+  return PublisherEncryptionKeyRevocationZod.parse(
+    new PayloadBuilder2({ schema: PublisherEncryptionKeyRevocationSchema }).fields({ key }).build()
+  );
+}
+function createWakeGrantRevocation(grant) {
+  return WakeGrantRevocationZod.parse(new PayloadBuilder2({ schema: WakeGrantRevocationSchema }).fields({ grant }).build());
+}
+function createWakeSubscriptionRevocation(subscription) {
+  return WakeSubscriptionRevocationZod.parse(new PayloadBuilder2({ schema: WakeSubscriptionRevocationSchema }).fields({ subscription }).build());
+}
+function createWakeSubscriptionAcceptanceRevocation(acceptance) {
+  return WakeSubscriptionAcceptanceRevocationZod.parse(
+    new PayloadBuilder2({ schema: WakeSubscriptionAcceptanceRevocationSchema }).fields({ acceptance }).build()
+  );
+}
+
+// src/lifecycleSelection.ts
+function isNonnegativeSafeInteger2(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isVisible(claimedAtBlock, finalizedHead) {
+  return isNonnegativeSafeInteger2(claimedAtBlock) && claimedAtBlock <= finalizedHead;
+}
+function isRevoked(revokedAtBlock, finalizedHead) {
+  return revokedAtBlock !== void 0 && revokedAtBlock <= finalizedHead;
+}
+function isUnrevokedEvidence(claimedAtBlock, revokedAtBlock, finalizedHead) {
+  return isVisible(claimedAtBlock, finalizedHead) && (revokedAtBlock === void 0 || isNonnegativeSafeInteger2(revokedAtBlock) && revokedAtBlock >= claimedAtBlock) && !isRevoked(revokedAtBlock, finalizedHead);
+}
+function isInsideExclusiveWindow(finalizedHead, validFromBlock, expiresAtBlock) {
+  if (!isNonnegativeSafeInteger2(validFromBlock) || finalizedHead < validFromBlock) return false;
+  return expiresAtBlock === void 0 || isNonnegativeSafeInteger2(expiresAtBlock) && expiresAtBlock > validFromBlock && finalizedHead < expiresAtBlock;
+}
+function isRevisionShapeValid(revision) {
+  if (!Number.isSafeInteger(revision.revision) || revision.revision < 1) return false;
+  if (!isNonnegativeSafeInteger2(revision.claimedAtBlock)) return false;
+  if (revision.revokedAtBlock !== void 0 && (!isNonnegativeSafeInteger2(revision.revokedAtBlock) || revision.revokedAtBlock < revision.claimedAtBlock)) return false;
+  return revision.revision === 1 ? revision.supersedes === void 0 : revision.supersedes !== void 0;
+}
+function resolveLinearChain(revisions, finalizedHead) {
+  const visible = revisions.filter((revision) => isVisible(revision.claimedAtBlock, finalizedHead));
+  if (visible.length === 0) return { ok: true, chain: [] };
+  if (visible.some((revision) => !isRevisionShapeValid(revision))) return { ok: false };
+  const byHash = /* @__PURE__ */ new Map();
+  const childByParent = /* @__PURE__ */ new Map();
+  let root;
+  for (const revision of visible) {
+    if (byHash.has(revision.objectHash)) return { ok: false };
+    byHash.set(revision.objectHash, revision);
+    if (revision.revision === 1) {
+      if (root !== void 0) return { ok: false };
+      root = revision;
+    }
+  }
+  if (root === void 0) return { ok: false };
+  for (const revision of visible) {
+    if (revision.revision === 1) continue;
+    const parentHash = revision.supersedes;
+    if (parentHash === void 0 || childByParent.has(parentHash)) return { ok: false };
+    const parent = byHash.get(parentHash);
+    if (parent === void 0 || revision.revision !== parent.revision + 1 || revision.claimedAtBlock < parent.claimedAtBlock) return { ok: false };
+    childByParent.set(parentHash, revision);
+  }
+  const chain = [root];
+  let current = root;
+  while (childByParent.has(current.objectHash)) {
+    const child = childByParent.get(current.objectHash);
+    if (child === void 0) return { ok: false };
+    chain.push(child);
+    current = child;
+  }
+  return chain.length === visible.length ? { ok: true, chain } : { ok: false };
+}
+function groupServicesByIdentity(services, input) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const service of services) {
+    if (service.source !== input.publisherSource) continue;
+    if (input.serviceId !== void 0 && service.serviceId !== input.serviceId) continue;
+    const group = groups.get(service.serviceId) ?? [];
+    group.push(service);
+    groups.set(service.serviceId, group);
+  }
+  return groups;
+}
+function authoritativeService(chain, finalizedHead) {
+  let authoritative;
+  for (const service of chain) {
+    if (service.validFromBlock <= finalizedHead) authoritative = service;
+  }
+  return authoritative;
+}
+function isActiveService(service, finalizedHead) {
+  return isUnrevokedEvidence(service.claimedAtBlock, service.revokedAtBlock, finalizedHead) && isInsideExclusiveWindow(finalizedHead, service.validFromBlock, service.expiresAtBlock);
+}
+function selectPublisherService(input) {
+  const groups = groupServicesByIdentity(input.services, input);
+  const selectable = [];
+  for (const revisions of groups.values()) {
+    if (input.serviceId === void 0 && !revisions.some((service2) => service2.eventKinds.includes(input.eventKind))) {
+      continue;
+    }
+    const resolution = resolveLinearChain(revisions, input.finalizedHead);
+    if (!resolution.ok) return { ok: false, reason: "invalid-revision-chain" };
+    const service = authoritativeService(resolution.chain, input.finalizedHead);
+    if (service?.eventKinds.includes(input.eventKind) && isActiveService(service, input.finalizedHead)) {
+      selectable.push(service);
+    }
+  }
+  if (selectable.length === 0) return { ok: false, reason: "service-not-found" };
+  if (selectable.length > 1) return { ok: false, reason: "ambiguous-service" };
+  return { ok: true, service: selectable[0] };
+}
+function resolvePreferredEncryptionKey(input) {
+  const preferredHash = input.service.preferredEncryptionKey;
+  if (!input.service.encryptionKeys.includes(preferredHash)) {
+    return { ok: false, reason: "preferred-key-not-referenced" };
+  }
+  const exact = input.keys.filter((key2) => key2.source === input.service.source && key2.objectHash === preferredHash && isVisible(key2.claimedAtBlock, input.finalizedHead));
+  if (exact.length === 0) return { ok: false, reason: "preferred-key-not-found" };
+  if (exact.length > 1) return { ok: false, reason: "ambiguous-key" };
+  const key = exact[0];
+  const sameStableIdentity = input.keys.filter((candidate) => candidate.source === key.source && candidate.keyId === key.keyId && candidate.objectHash !== key.objectHash && isVisible(candidate.claimedAtBlock, input.finalizedHead));
+  if (sameStableIdentity.length > 0) return { ok: false, reason: "ambiguous-key" };
+  if (!isUnrevokedEvidence(key.claimedAtBlock, key.revokedAtBlock, input.finalizedHead) || !isInsideExclusiveWindow(input.finalizedHead, key.validFromBlock, key.expiresAtBlock)) {
+    return { ok: false, reason: "preferred-key-inactive" };
+  }
+  return { ok: true, key };
+}
+function acceptanceFor(subscription, input) {
+  return input.acceptances.filter((acceptance) => acceptance.source === input.publisherSource && acceptance.subscription === subscription.objectHash && isVisible(acceptance.acceptanceBlock, input.finalizedHead));
+}
+function acceptedSubscription(subscription, input) {
+  const acceptances = acceptanceFor(subscription, input);
+  if (acceptances.length > 1) return "ambiguous";
+  const acceptance = acceptances[0];
+  if (acceptance === void 0 || !isNonnegativeSafeInteger2(acceptance.acceptanceBlock)) return void 0;
+  if (!Number.isSafeInteger(subscription.expiresAtBlock) || subscription.expiresAtBlock < 1) return void 0;
+  if (acceptance.acceptanceBlock <= subscription.claimedAtBlock || acceptance.acceptanceBlock >= Number.MAX_SAFE_INTEGER) return void 0;
+  const activeFromBlock = acceptance.acceptanceBlock + 1;
+  if (activeFromBlock >= subscription.expiresAtBlock) return void 0;
+  return {
+    acceptance,
+    activeFromBlock,
+    subscription
+  };
+}
+function isActiveAcceptedSubscription(accepted, finalizedHead) {
+  return isUnrevokedEvidence(
+    accepted.subscription.claimedAtBlock,
+    accepted.subscription.revokedAtBlock,
+    finalizedHead
+  ) && isUnrevokedEvidence(
+    accepted.acceptance.acceptanceBlock,
+    accepted.acceptance.revokedAtBlock,
+    finalizedHead
+  ) && finalizedHead < accepted.subscription.expiresAtBlock;
+}
+function selectSubscriptionActivation(input) {
+  const revisions = input.subscriptions.filter((subscription) => subscription.source === input.subscriberSource && subscription.subscriptionId === input.subscriptionId);
+  const resolution = resolveLinearChain(revisions, input.finalizedHead);
+  if (!resolution.ok) return { ok: false, reason: "invalid-revision-chain" };
+  if (resolution.chain.length === 0) return { ok: false, reason: "subscription-not-found" };
+  let selected;
+  for (const subscription of resolution.chain) {
+    const accepted = acceptedSubscription(subscription, input);
+    if (accepted === "ambiguous") return { ok: false, reason: "ambiguous-acceptance" };
+    if (accepted !== void 0 && accepted.activeFromBlock <= input.finalizedHead) selected = accepted;
+  }
+  if (selected === void 0) return { ok: false, reason: "subscription-pending" };
+  const latest = resolution.chain.at(-1);
+  if (!isActiveAcceptedSubscription(selected, input.finalizedHead)) {
+    if (latest?.objectHash !== selected.subscription.objectHash) {
+      return { ok: false, reason: "subscription-pending" };
+    }
+    return { ok: false, reason: "subscription-inactive" };
+  }
+  return {
+    acceptance: selected.acceptance,
+    activeFromBlock: selected.activeFromBlock,
+    ok: true,
+    pendingReplacement: latest?.objectHash !== selected.subscription.objectHash,
+    subscription: selected.subscription
+  };
+}
+
 // src/memoryStatementGrantGraph.ts
 import {
   normalizeAddress,
-  WakeGrantObjectSchema,
-  WakeGrantRevocationSchema
+  WakeGrantObjectSchema as WakeGrantObjectSchema2,
+  WakeGrantRevocationSchema as WakeGrantRevocationSchema2
 } from "@xyo-network/event-kit-schemas";
 function createMemoryStatementGrantGraph(initialHead = 0) {
   let head = initialHead;
   const claims = /* @__PURE__ */ new Map();
   const objects = /* @__PURE__ */ new Map();
-  function claimKey(source, objectHash) {
-    return `${normalizeAddress(source)}|${objectHash}`;
+  function claimKey(source, subject, objectHash) {
+    return `${normalizeAddress(source)}|${normalizeAddress(subject)}|${objectHash}`;
   }
   function materialize(input) {
     const source = normalizeAddress(input.source);
+    const subject = normalizeAddress(input.subject);
     objects.set(input.objectHash, Object.freeze({
       assurance: "resolved",
       declaredSchema: input.declaredSchema,
       objectHash: input.objectHash,
       params: Object.freeze({ ...input.params })
     }));
-    const key = claimKey(source, input.objectHash);
+    const key = claimKey(source, subject, input.objectHash);
     const existing = claims.get(key);
     claims.set(key, Object.freeze(existing === void 0 ? {
       declaredObjectSchema: input.declaredSchema,
@@ -268,7 +963,8 @@ function createMemoryStatementGrantGraph(initialHead = 0) {
       firstEventHash: input.eventHash,
       lastBlock: input.block,
       objectHash: input.objectHash,
-      source
+      source,
+      subject
     } : { ...existing, lastBlock: Math.max(existing.lastBlock, input.block) }));
     if (input.block > head) head = input.block;
   }
@@ -284,6 +980,7 @@ function createMemoryStatementGrantGraph(initialHead = 0) {
       const records = [];
       for (const record of claims.values()) {
         if (record.source !== normalizedSource) continue;
+        if (query?.subject !== void 0 && record.subject !== normalizeAddress(query.subject)) continue;
         if (query?.objectHash !== void 0 && record.objectHash !== query.objectHash) continue;
         if (query?.declaredObjectSchemaPrefix !== void 0 && !record.declaredObjectSchema.startsWith(query.declaredObjectSchemaPrefix)) {
           continue;
@@ -296,31 +993,43 @@ function createMemoryStatementGrantGraph(initialHead = 0) {
       return objects.get(objectHash);
     },
     claim(input) {
-      if (input.grant.schema !== WakeGrantObjectSchema) {
-        throw new Error(`expected ${WakeGrantObjectSchema}`);
+      if (input.grant.schema !== WakeGrantObjectSchema2) {
+        throw new Error(`expected ${WakeGrantObjectSchema2}`);
       }
       const { schema: _schema, ...params } = input.grant;
       materialize({
         block: input.block,
-        declaredSchema: WakeGrantObjectSchema,
+        declaredSchema: WakeGrantObjectSchema2,
         eventHash: input.eventHash,
         objectHash: input.objectHash,
         params: {
           ...params,
           permissions: Object.freeze([...params.permissions])
         },
-        source: input.source
+        source: input.source,
+        subject: input.subject ?? input.grant.publisher
       });
     },
     revoke(input) {
       const revocation = { grant: input.grantObjectHash };
+      const source = normalizeAddress(input.source);
+      const subjects = [...claims.values()].filter((claim) => claim.source === source && claim.objectHash === input.grantObjectHash).map((claim) => claim.subject);
+      const uniqueSubjects = [...new Set(subjects)];
+      if (input.subject === void 0 && uniqueSubjects.length > 1) {
+        throw new Error(`cannot infer one subject for ambiguous grant Claim ${input.grantObjectHash}`);
+      }
+      const subject = input.subject ?? uniqueSubjects[0];
+      if (subject === void 0) {
+        throw new Error(`cannot infer subject for unknown grant Claim ${input.grantObjectHash}`);
+      }
       materialize({
         block: input.block,
-        declaredSchema: WakeGrantRevocationSchema,
+        declaredSchema: WakeGrantRevocationSchema2,
         eventHash: input.eventHash,
         objectHash: input.objectHash,
         params: revocation,
-        source: input.source
+        source: input.source,
+        subject
       });
     }
   };
@@ -447,15 +1156,284 @@ function createMemoryWakeQueue() {
   };
 }
 
+// src/publisherSubscription.ts
+import {
+  ChainIdZod,
+  EncryptedWakeSubscriptionZod as EncryptedWakeSubscriptionZod4,
+  EndpointChallengeZod as EndpointChallengeZod3,
+  HashZod as HashZod3,
+  NormalizedAddressZod as NormalizedAddressZod3,
+  PublisherEncryptionKeyZod as PublisherEncryptionKeyZod2,
+  PublisherServiceZod as PublisherServiceZod2,
+  WakeGrantObjectZod as WakeGrantObjectZod2
+} from "@xyo-network/event-kit-schemas";
+function rejectPublisherSubscription(reason) {
+  return Object.freeze({ ok: false, reason });
+}
+function isNonnegativeSafeInteger3(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isActiveAt(value, block) {
+  return value.validFromBlock <= block && (value.expiresAtBlock === void 0 || block < value.expiresAtBlock);
+}
+function occursExactlyOnce(hashes, expected) {
+  return hashes.filter((hash) => hash === expected).length === 1;
+}
+function hasExactGrantBinding(grant, publisher) {
+  return grant.publisher === publisher && grant.permissions.length === 1 && grant.permissions[0] === "enqueue";
+}
+function hasExactQueueScope(grant, plaintext) {
+  const grantQueue = Object.hasOwn(grant, "queueId") ? grant.queueId : null;
+  return plaintext.deploymentId === grant.deploymentId && plaintext.queueId === grantQueue;
+}
+function hasExactSubscriptionBinding(candidate, subscription) {
+  return subscription.chainId === candidate.chainId && subscription.publisher === candidate.publisher && subscription.service === candidate.service.objectHash && subscription.encryptionKey === candidate.key.objectHash && subscription.keyId === candidate.key.body.keyId && subscription.grant === candidate.grant.objectHash;
+}
+function hasExactKeyBinding(service, key, subscription) {
+  return service.encryptionKeys.includes(key.objectHash) && service.preferredEncryptionKey === key.objectHash && key.body.keyId === subscription.keyId && key.objectHash === subscription.encryptionKey;
+}
+function expiryWithinServicePolicy(subscription, service, tupleBlock) {
+  return subscription.expiresAtBlock > tupleBlock && subscription.expiresAtBlock - tupleBlock <= service.limits.maxSubscriptionLifetimeBlocks;
+}
+function parsePublisherSubscriptionCandidate(candidate) {
+  try {
+    return {
+      chainId: ChainIdZod.parse(candidate.chainId),
+      grant: WakeGrantObjectZod2.parse(candidate.grant.body),
+      key: PublisherEncryptionKeyZod2.parse(candidate.key.body),
+      publisher: NormalizedAddressZod3.parse(candidate.publisher),
+      service: PublisherServiceZod2.parse(candidate.service.body),
+      subscriber: NormalizedAddressZod3.parse(candidate.subscriber),
+      subscription: EncryptedWakeSubscriptionZod4.parse(candidate.subscription.body),
+      tupleObjectHashes: candidate.tupleObjectHashes.map((hash) => HashZod3.parse(hash)),
+      tupleSubject: NormalizedAddressZod3.parse(candidate.tupleSubject)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function tupleBindingIsValid(candidate, parsed) {
+  return isNonnegativeSafeInteger3(candidate.tupleBlock) && isNonnegativeSafeInteger3(candidate.finalizedHead) && candidate.finalizedHead >= candidate.tupleBlock && parsed.tupleSubject === parsed.publisher && occursExactlyOnce(parsed.tupleObjectHashes, candidate.service.objectHash) && occursExactlyOnce(parsed.tupleObjectHashes, candidate.grant.objectHash) && occursExactlyOnce(parsed.tupleObjectHashes, candidate.subscription.objectHash);
+}
+async function bodyHashesAreValid(candidate, parsed) {
+  const canonicalHashes = await Promise.all([
+    handshakeObjectHash(parsed.service),
+    handshakeObjectHash(parsed.key),
+    handshakeObjectHash(parsed.grant),
+    handshakeObjectHash(parsed.subscription)
+  ]);
+  return canonicalHashes[0] === candidate.service.objectHash && canonicalHashes[1] === candidate.key.objectHash && canonicalHashes[2] === candidate.grant.objectHash && canonicalHashes[3] === candidate.subscription.objectHash;
+}
+function publicBindingFailure(candidate, parsed) {
+  if (!hasExactGrantBinding(parsed.grant, parsed.publisher)) return "grant-binding-invalid";
+  if (!hasExactSubscriptionBinding(candidate, parsed.subscription)) return "subscription-binding-invalid";
+  const hashedKey = { body: parsed.key, objectHash: candidate.key.objectHash };
+  if (!hasExactKeyBinding(parsed.service, hashedKey, parsed.subscription)) return "key-binding-invalid";
+  if (!isActiveAt(parsed.service, candidate.tupleBlock) || !isActiveAt(parsed.service, candidate.finalizedHead)) return "service-inactive";
+  if (!isActiveAt(parsed.key, candidate.tupleBlock) || !isActiveAt(parsed.key, candidate.finalizedHead)) return "key-inactive";
+  if (!expiryWithinServicePolicy(parsed.subscription, parsed.service, candidate.tupleBlock) || parsed.subscription.expiresAtBlock - candidate.finalizedHead <= 2) return "subscription-expiry-invalid";
+  return void 0;
+}
+async function decryptCandidate(candidate, parsed) {
+  let privateKey;
+  try {
+    privateKey = await candidate.keys.getPrivateKey({
+      encryptionKey: candidate.key.objectHash,
+      keyId: parsed.key.keyId,
+      publisher: parsed.publisher
+    });
+  } catch {
+    return rejectPublisherSubscription("key-store-unavailable");
+  }
+  if (privateKey === void 0) return rejectPublisherSubscription("private-key-not-found");
+  if (privateKey.encryptionKey !== candidate.key.objectHash || privateKey.keyId !== parsed.key.keyId) {
+    return rejectPublisherSubscription("key-binding-invalid");
+  }
+  try {
+    return {
+      plaintext: await decryptWakeSubscription({
+        publisherKey: privateKey,
+        subscriber: parsed.subscriber,
+        subscription: parsed.subscription
+      })
+    };
+  } catch {
+    return rejectPublisherSubscription("decryption-failed");
+  }
+}
+function validatedPublisherSubscription(candidate, parsed, plaintext) {
+  return Object.freeze({
+    context: Object.freeze({
+      chainId: parsed.chainId,
+      encryptionKey: candidate.key.objectHash,
+      eventKind: parsed.subscription.eventKind,
+      grant: candidate.grant.objectHash,
+      keyId: parsed.subscription.keyId,
+      publisher: parsed.publisher,
+      service: candidate.service.objectHash,
+      subscriber: parsed.subscriber,
+      subscription: candidate.subscription.objectHash
+    }),
+    finalizedHead: candidate.finalizedHead,
+    grant: Object.freeze({ body: parsed.grant, objectHash: candidate.grant.objectHash }),
+    key: Object.freeze({ body: parsed.key, objectHash: candidate.key.objectHash }),
+    ok: true,
+    plaintext,
+    service: Object.freeze({ body: parsed.service, objectHash: candidate.service.objectHash }),
+    subscription: Object.freeze({ body: parsed.subscription, objectHash: candidate.subscription.objectHash }),
+    tupleBlock: candidate.tupleBlock
+  });
+}
+async function validateAndDecryptPublisherSubscription(candidate) {
+  const parsed = parsePublisherSubscriptionCandidate(candidate);
+  if (parsed === void 0) return rejectPublisherSubscription("malformed-candidate");
+  if (!tupleBindingIsValid(candidate, parsed)) return rejectPublisherSubscription("tuple-binding-invalid");
+  if (!await bodyHashesAreValid(candidate, parsed)) return rejectPublisherSubscription("body-hash-mismatch");
+  const publicFailure = publicBindingFailure(candidate, parsed);
+  if (publicFailure !== void 0) return rejectPublisherSubscription(publicFailure);
+  const decrypted = await decryptCandidate(candidate, parsed);
+  if ("ok" in decrypted) return decrypted;
+  if (!hasExactQueueScope(parsed.grant, decrypted.plaintext)) {
+    return rejectPublisherSubscription("grant-scope-invalid");
+  }
+  if (decrypted.plaintext.filter.maxBlocksPerWake > parsed.service.limits.maxBlocksPerWake) {
+    return rejectPublisherSubscription("service-limit-invalid");
+  }
+  return validatedPublisherSubscription(candidate, parsed, decrypted.plaintext);
+}
+function endpointChallengeMatchesPublisherContext(challenge, context) {
+  const parsed = EndpointChallengeZod3.safeParse(challenge);
+  if (!parsed.success) return false;
+  return parsed.data.chainId === context.chainId && parsed.data.publisher === context.publisher && parsed.data.subscriber === context.subscriber && parsed.data.service === context.service && parsed.data.encryptionKey === context.encryptionKey && parsed.data.keyId === context.keyId && parsed.data.subscription === context.subscription && parsed.data.grant === context.grant && parsed.data.eventKind === context.eventKind;
+}
+async function challengeRecordMatches(record, challenge, challengeHash, responseHash) {
+  if (record.challengeHash !== challengeHash || await endpointChallengeHash(record.challenge) !== challengeHash || await endpointChallengeHash(challenge) !== challengeHash) return false;
+  return responseHash === void 0 || record.responseHash === responseHash;
+}
+async function issuePublisherEndpointChallenge(input) {
+  const challenge = createEndpointChallenge({
+    ...input.subscription.context,
+    issuedAt: input.issuedAt,
+    ...input.lifetimeSeconds === void 0 ? {} : { lifetimeSeconds: input.lifetimeSeconds }
+  });
+  const challengeHash = await endpointChallengeHash(challenge);
+  try {
+    const result = await input.store.issue({ challenge, challengeHash });
+    if (result.kind === "collision") return { ok: false, reason: "challenge-collision" };
+    if (result.kind !== "duplicate" && result.kind !== "issued" || !await challengeRecordMatches(result.record, challenge, challengeHash)) {
+      return { ok: false, reason: "challenge-store-invalid" };
+    }
+    return Object.freeze({
+      challenge,
+      challengeHash,
+      disposition: result.kind,
+      ok: true
+    });
+  } catch {
+    return { ok: false, reason: "challenge-store-unavailable" };
+  }
+}
+async function beginPublisherEndpointChallengeAttempt(input) {
+  if (!isNonnegativeSafeInteger3(input.nowSeconds)) return { kind: "store-invalid" };
+  try {
+    const result = await input.store.beginAttempt({
+      challengeHash: HashZod3.parse(input.challengeHash),
+      nowSeconds: input.nowSeconds
+    });
+    if (!["already-attempted", "expired", "missing", "started", "verified"].includes(result.kind)) {
+      return { kind: "store-invalid" };
+    }
+    if (result.kind !== "missing" && !await challengeRecordMatches(
+      result.record,
+      result.record.challenge,
+      HashZod3.parse(input.challengeHash)
+    )) return { kind: "store-invalid" };
+    if ((result.kind === "started" || result.kind === "already-attempted") && result.record.state !== "attempted") return { kind: "store-invalid" };
+    if (result.kind === "verified" && result.record.state !== "verified") return { kind: "store-invalid" };
+    return result;
+  } catch {
+    return { kind: "store-unavailable" };
+  }
+}
+function completeFailure(reason) {
+  return Object.freeze({ ok: false, reason });
+}
+async function validateChallengeCompletion(input, result, challengeHash, responseHash, insideDecisionWindow, proofValid) {
+  if (!insideDecisionWindow && result.kind !== "duplicate") {
+    return completeFailure(result.kind === "collision" ? "challenge-response-collision" : "challenge-expired");
+  }
+  if (!proofValid) return completeFailure("invalid-proof");
+  if (result.kind === "missing") return completeFailure("challenge-not-found");
+  if (result.kind === "expired") return completeFailure("challenge-expired");
+  if (result.kind === "not-attempted") return completeFailure("challenge-not-attempted");
+  if (result.kind === "collision") return completeFailure("challenge-response-collision");
+  if (result.kind !== "duplicate" && result.kind !== "verified" || !await challengeRecordMatches(result.record, input.challenge, challengeHash, responseHash)) {
+    return completeFailure("challenge-store-invalid");
+  }
+  return result;
+}
+async function completePublisherEndpointChallenge(input) {
+  if (!endpointChallengeMatchesPublisherContext(input.challenge, input.subscription.context)) {
+    return completeFailure("challenge-context-invalid");
+  }
+  if (!isNonnegativeSafeInteger3(input.nowSeconds)) return completeFailure("challenge-expired");
+  const insideDecisionWindow = input.challenge.issuedAt <= input.nowSeconds && input.nowSeconds < input.challenge.expiresAt;
+  const proofInput = {
+    challenge: input.challenge,
+    response: input.response,
+    secret: input.subscription.plaintext.challenge.secret
+  };
+  const proofValid = insideDecisionWindow ? await verifyEndpointChallengeResponse({ ...proofInput, nowSeconds: input.nowSeconds }) : await verifyEndpointChallengeProof(proofInput);
+  if (insideDecisionWindow && !proofValid) return completeFailure("invalid-proof");
+  const [challengeHash, responseHash] = await Promise.all([
+    endpointChallengeHash(input.challenge),
+    handshakeObjectHash(input.response)
+  ]);
+  try {
+    const result = await input.store.completeVerified({
+      challengeHash,
+      nowSeconds: input.nowSeconds,
+      responseHash
+    });
+    const completion = await validateChallengeCompletion(
+      input,
+      result,
+      challengeHash,
+      responseHash,
+      insideDecisionWindow,
+      proofValid
+    );
+    if ("ok" in completion) return completion;
+    const acceptance = createWakeSubscriptionAcceptance({
+      challenge: challengeHash,
+      encryptionKey: input.subscription.context.encryptionKey,
+      grant: input.subscription.context.grant,
+      response: responseHash,
+      service: input.subscription.context.service,
+      subscription: input.subscription.context.subscription
+    });
+    return Object.freeze({
+      acceptance,
+      acceptanceHash: await handshakeObjectHash(acceptance),
+      challengeHash,
+      disposition: completion.kind,
+      ok: true,
+      responseHash
+    });
+  } catch {
+    return completeFailure("challenge-store-unavailable");
+  }
+}
+
 // src/statementGraphWakeGrantAuthorizer.ts
 import {
   asWakeGrantObject,
   asWakeGrantRevocation,
   DeploymentIdZod,
-  HashZod,
-  NormalizedAddressZod,
-  WakeGrantObjectSchema as WakeGrantObjectSchema2,
-  WakeGrantRevocationSchema as WakeGrantRevocationSchema2
+  HashZod as HashZod4,
+  NormalizedAddressZod as NormalizedAddressZod4,
+  WakeGrantObjectSchema as WakeGrantObjectSchema3,
+  WakeGrantRevocationSchema as WakeGrantRevocationSchema3
 } from "@xyo-network/event-kit-schemas";
 function createStatementGraphWakeGrantAuthorizer(options) {
   const { viewer } = options;
@@ -466,8 +1444,11 @@ function createStatementGraphWakeGrantAuthorizer(options) {
       if (atBlock > request.expectedHead) {
         throw new Error(`Statement Graph head ${atBlock} is ahead of expected head ${request.expectedHead}`);
       }
-      const claims = await viewer.claims(request.controller, { declaredObjectSchemaPrefix: WakeGrantObjectSchema2 });
-      const revokedGrantHashes = await readRevocations(viewer, request.controller, atBlock);
+      const claims = await viewer.claims(request.controller, {
+        declaredObjectSchemaPrefix: WakeGrantObjectSchema3,
+        subject: request.publisher
+      });
+      const revokedGrantHashes = await readRevocations(viewer, request.controller, request.publisher, atBlock);
       let evidence;
       for (const claim of claims) {
         evidence = await resolveEvidence(viewer, claim, request, atBlock, revokedGrantHashes);
@@ -496,14 +1477,17 @@ function createStatementGraphWakeGrantAuthorizer(options) {
     }
   });
 }
-async function readRevocations(viewer, controller, atBlock) {
+async function readRevocations(viewer, controller, subject, atBlock) {
   const revoked = /* @__PURE__ */ new Set();
-  const claims = await viewer.claims(controller, { declaredObjectSchemaPrefix: WakeGrantRevocationSchema2 });
+  const claims = await viewer.claims(controller, {
+    declaredObjectSchemaPrefix: WakeGrantRevocationSchema3,
+    subject
+  });
   for (const claim of claims) {
-    if (!isLiveClaim(claim, controller, WakeGrantRevocationSchema2, atBlock)) continue;
+    if (!isLiveClaim(claim, controller, subject, WakeGrantRevocationSchema3, atBlock)) continue;
     const object = await viewer.object(claim.objectHash);
     if (object?.assurance !== "resolved") continue;
-    if (object.declaredSchema !== WakeGrantRevocationSchema2 || object.objectHash !== claim.objectHash) continue;
+    if (object.declaredSchema !== WakeGrantRevocationSchema3 || object.objectHash !== claim.objectHash) continue;
     if (!isRecord2(object.params) || Object.hasOwn(object.params, "schema")) continue;
     const revocation = asWakeGrantRevocation({ ...object.params, schema: object.declaredSchema });
     if (revocation !== void 0) revoked.add(revocation.grant);
@@ -511,7 +1495,7 @@ async function readRevocations(viewer, controller, atBlock) {
   return revoked;
 }
 async function resolveEvidence(viewer, claim, request, atBlock, revokedGrantHashes) {
-  if (!isLiveClaim(claim, request.controller, WakeGrantObjectSchema2, atBlock)) return void 0;
+  if (!isLiveClaim(claim, request.controller, request.publisher, WakeGrantObjectSchema3, atBlock)) return void 0;
   if (revokedGrantHashes.has(claim.objectHash)) return void 0;
   const object = await viewer.object(claim.objectHash);
   const grant = parseExactGrantObject(object, claim.objectHash);
@@ -529,17 +1513,18 @@ async function resolveEvidence(viewer, claim, request, atBlock, revokedGrantHash
     target: grant.publisher
   });
 }
-function isLiveClaim(claim, controller, declaredObjectSchema, atBlock) {
+function isLiveClaim(claim, controller, subject, declaredObjectSchema, atBlock) {
   if (claim.source !== controller) return false;
+  if (claim.subject !== subject) return false;
   if (claim.declaredObjectSchema !== declaredObjectSchema) return false;
-  if (!isNonnegativeSafeInteger2(claim.firstBlock) || claim.firstBlock > atBlock) return false;
-  if (!isNonnegativeSafeInteger2(claim.lastBlock) || claim.lastBlock < claim.firstBlock) return false;
-  if (!HashZod.safeParse(claim.firstEventHash).success) return false;
-  return HashZod.safeParse(claim.objectHash).success;
+  if (!isNonnegativeSafeInteger4(claim.firstBlock) || claim.firstBlock > atBlock) return false;
+  if (!isNonnegativeSafeInteger4(claim.lastBlock) || claim.lastBlock < claim.firstBlock) return false;
+  if (!HashZod4.safeParse(claim.firstEventHash).success) return false;
+  return HashZod4.safeParse(claim.objectHash).success;
 }
 function parseExactGrantObject(object, expectedObjectHash) {
   if (object?.assurance !== "resolved") return void 0;
-  if (object.declaredSchema !== WakeGrantObjectSchema2 || object.objectHash !== expectedObjectHash) return void 0;
+  if (object.declaredSchema !== WakeGrantObjectSchema3 || object.objectHash !== expectedObjectHash) return void 0;
   if (!isRecord2(object.params) || Object.hasOwn(object.params, "schema")) return void 0;
   return asWakeGrantObject({
     ...object.params,
@@ -547,10 +1532,10 @@ function parseExactGrantObject(object, expectedObjectHash) {
   });
 }
 function assertValidRequest(request) {
-  if (!NormalizedAddressZod.safeParse(request.controller).success) {
+  if (!NormalizedAddressZod4.safeParse(request.controller).success) {
     throw new TypeError("Grant controller must be a normalized address");
   }
-  if (!NormalizedAddressZod.safeParse(request.publisher).success) {
+  if (!NormalizedAddressZod4.safeParse(request.publisher).success) {
     throw new TypeError("Grant publisher must be a normalized address");
   }
   if (!DeploymentIdZod.safeParse(request.deploymentId).success) {
@@ -559,18 +1544,18 @@ function assertValidRequest(request) {
   if (request.queueId !== void 0 && (request.queueId.length === 0 || request.queueId.length > 255)) {
     throw new TypeError("Grant queueId must contain 1 to 255 characters when configured");
   }
-  if (!isNonnegativeSafeInteger2(request.expectedHead)) {
+  if (!isNonnegativeSafeInteger4(request.expectedHead)) {
     throw new RangeError("Grant expectedHead must be a nonnegative safe integer");
   }
 }
 async function readHead(viewer) {
   const head = await viewer.head();
-  if (!isNonnegativeSafeInteger2(head)) {
+  if (!isNonnegativeSafeInteger4(head)) {
     throw new RangeError("Statement Graph head must be a nonnegative safe integer");
   }
   return head;
 }
-function isNonnegativeSafeInteger2(value) {
+function isNonnegativeSafeInteger4(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
 function isRecord2(value) {
@@ -580,7 +1565,7 @@ function isRecord2(value) {
 // src/verifyWakeRequest.ts
 import {
   DeploymentIdZod as DeploymentIdZod2,
-  NormalizedAddressZod as NormalizedAddressZod2,
+  NormalizedAddressZod as NormalizedAddressZod5,
   WakeEnvelopeZod,
   WakeIdRegExp,
   WakeJwtAudienceZod,
@@ -588,7 +1573,7 @@ import {
   WakeJwtPayloadZod,
   WakeJwtSchema
 } from "@xyo-network/event-kit-schemas";
-import { Account, PayloadBuilder } from "@xyo-network/sdk";
+import { Account, PayloadBuilder as PayloadBuilder3 } from "@xyo-network/sdk";
 var EVENT_KIT_MAX_JWT_LIFETIME_SECONDS = 300;
 var EVENT_KIT_MAX_FUTURE_IAT_SECONDS = 60;
 async function verifyWakeRequest(input) {
@@ -622,7 +1607,7 @@ async function verifyWakeRequest(input) {
   if (!jwtResult.ok) return jwtResult;
   let eventHash;
   try {
-    eventHash = await PayloadBuilder.dataHash(event);
+    eventHash = await PayloadBuilder3.dataHash(event);
   } catch (error) {
     return reject2("event-hash-failed", [errorMessage2(error)]);
   }
@@ -656,16 +1641,16 @@ function validateConfiguration(route, nowSeconds) {
   if (route.queueId !== void 0 && (route.queueId.length === 0 || route.queueId.length > 255)) {
     return reject2("configuration-invalid", ["queueId must contain 1 to 255 characters when configured"]);
   }
-  if (!NormalizedAddressZod2.safeParse(route.controller).success) {
+  if (!NormalizedAddressZod5.safeParse(route.controller).success) {
     return reject2("configuration-invalid", ["controller must be a normalized 40-character lowercase-hex address"]);
   }
-  if (!isNonnegativeSafeInteger3(nowSeconds)) {
+  if (!isNonnegativeSafeInteger5(nowSeconds)) {
     return reject2("configuration-invalid", ["nowSeconds must be a nonnegative safe integer"]);
   }
   if (!Number.isSafeInteger(route.maxBlocksPerWake) || route.maxBlocksPerWake < 1) {
     return reject2("configuration-invalid", ["maxBlocksPerWake must be a positive safe integer"]);
   }
-  if (!isNonnegativeSafeInteger3(route.maxGrantLagBlocks)) {
+  if (!isNonnegativeSafeInteger5(route.maxGrantLagBlocks)) {
     return reject2("configuration-invalid", ["maxGrantLagBlocks must be a nonnegative safe integer"]);
   }
   return void 0;
@@ -700,14 +1685,14 @@ async function verifyJwtProfile(token, audience, nowSeconds) {
 function parseStrictJwtWire(header, payload, audience) {
   const headerResult = WakeJwtHeaderZod.safeParse(header);
   if (!headerResult.success) {
-    if (!NormalizedAddressZod2.safeParse(header.kid).success) return reject2("jwt-identity-invalid");
+    if (!NormalizedAddressZod5.safeParse(header.kid).success) return reject2("jwt-identity-invalid");
     return reject2("jwt-header-invalid", zodDetails(headerResult.error.issues));
   }
   if (Object.hasOwn(payload, "nbf")) return reject2("jwt-nbf-not-allowed");
-  if (!NormalizedAddressZod2.safeParse(payload.iss).success) return reject2("jwt-identity-invalid");
+  if (!NormalizedAddressZod5.safeParse(payload.iss).success) return reject2("jwt-identity-invalid");
   if (payload.schema !== WakeJwtSchema) return reject2("jwt-schema-mismatch");
   if (payload.aud !== audience) return reject2("jwt-audience-mismatch");
-  if (!isNonnegativeSafeInteger3(payload.iat) || !isNonnegativeSafeInteger3(payload.exp) || payload.exp <= payload.iat) {
+  if (!isNonnegativeSafeInteger5(payload.iat) || !isNonnegativeSafeInteger5(payload.exp) || payload.exp <= payload.iat) {
     return reject2("jwt-lifetime-invalid");
   }
   const payloadResult = WakeJwtPayloadZod.safeParse(payload);
@@ -730,14 +1715,14 @@ function classifySdkJwtFailure(reasons) {
   return "jwt-invalid";
 }
 function hasSafeEventNumbers(event) {
-  return isNonnegativeSafeInteger3(event.fromBlock) && isNonnegativeSafeInteger3(event.toBlock) && isNonnegativeSafeInteger3(event.issuedAt);
+  return isNonnegativeSafeInteger5(event.fromBlock) && isNonnegativeSafeInteger5(event.toBlock) && isNonnegativeSafeInteger5(event.issuedAt);
 }
 function hasInvertedSafeRange(value) {
   if (!isRecord3(value)) return false;
   const { fromBlock, toBlock } = value;
-  return typeof fromBlock === "number" && typeof toBlock === "number" && isNonnegativeSafeInteger3(fromBlock) && isNonnegativeSafeInteger3(toBlock) && fromBlock > toBlock;
+  return typeof fromBlock === "number" && typeof toBlock === "number" && isNonnegativeSafeInteger5(fromBlock) && isNonnegativeSafeInteger5(toBlock) && fromBlock > toBlock;
 }
-function isNonnegativeSafeInteger3(value) {
+function isNonnegativeSafeInteger5(value) {
   return Number.isSafeInteger(value) && value >= 0;
 }
 function isRecord3(value) {
@@ -791,12 +1776,47 @@ export {
   EVENT_KIT_MAX_FUTURE_IAT_SECONDS,
   EVENT_KIT_MAX_JWT_LIFETIME_SECONDS,
   EVENT_KIT_REPLAY_RETENTION_SKEW_SECONDS,
+  WakeSubscriptionDecryptionError,
   admitAndEnqueue,
+  beginPublisherEndpointChallengeAttempt,
+  canonicalJson,
+  canonicalJsonBytes,
+  completePublisherEndpointChallenge,
+  createEncryptedWakeSubscription,
+  createEndpointChallenge,
+  createEndpointChallengeResponse,
   createMemoryStatementGrantGraph,
   createMemoryWakeInbox,
   createMemoryWakeQueue,
+  createPublisherEncryptionKey,
+  createPublisherEncryptionKeyRevocation,
+  createPublisherService,
+  createPublisherServiceRevocation,
   createStatementGraphWakeGrantAuthorizer,
+  createWakeGrant,
+  createWakeGrantRevocation,
+  createWakeSubscriptionAcceptance,
+  createWakeSubscriptionAcceptanceRevocation,
+  createWakeSubscriptionPlaintext,
+  createWakeSubscriptionRevocation,
+  decryptWakeSubscription,
   drainQueue,
-  verifyWakeRequest
+  encryptWakeSubscription,
+  endpointChallengeHash,
+  endpointChallengeMatchesPublisherContext,
+  generatePublisherEncryptionKey,
+  generateWakeSubscriptionEncryptionKeyPair,
+  handshakeObjectHash,
+  issuePublisherEndpointChallenge,
+  resolvePreferredEncryptionKey,
+  selectPublisherService,
+  selectSubscriptionActivation,
+  validateAndDecryptPublisherSubscription,
+  verifyEndpointChallengeResponse,
+  verifyWakeRequest,
+  wakeSubscriptionAadBytes,
+  wakeSubscriptionPlaintextBytes,
+  wakeSubscriptionPlaintextFromBytes,
+  withHandshakeObjectHash
 };
 //# sourceMappingURL=index.mjs.map