@parity/product-sdk-statement-store 0.1.0

package/dist/index.js

@@ -0,0 +1,1058 @@
+// src/client.ts
+import { createLogger as createLogger2 } from "@parity/product-sdk-logger";
+import { blake2b256 as blake2b2562 } from "@parity/product-sdk-utils";
+
+// src/types.ts
+var MAX_STATEMENT_SIZE = 512;
+var MAX_USER_TOTAL = 1024;
+var DEFAULT_TTL_SECONDS = 30;
+
+// src/errors.ts
+var StatementStoreError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StatementStoreError";
+  }
+};
+var StatementEncodingError = class extends StatementStoreError {
+  constructor(message, options) {
+    super(`Encoding error: ${message}`, options);
+    this.name = "StatementEncodingError";
+  }
+};
+var StatementSubmitError = class extends StatementStoreError {
+  /** The raw response from the RPC call. */
+  detail;
+  constructor(detail) {
+    super(`Statement submission rejected: ${JSON.stringify(detail)}`);
+    this.name = "StatementSubmitError";
+    this.detail = detail;
+  }
+};
+var StatementSubscriptionError = class extends StatementStoreError {
+  constructor(message, options) {
+    super(`Subscription error: ${message}`, options);
+    this.name = "StatementSubscriptionError";
+  }
+};
+var StatementConnectionError = class extends StatementStoreError {
+  constructor(message, options) {
+    super(`Connection error: ${message}`, options);
+    this.name = "StatementConnectionError";
+  }
+};
+var StatementDataTooLargeError = class extends StatementStoreError {
+  /** The actual size of the data in bytes. */
+  actualSize;
+  /** The maximum allowed size in bytes. */
+  maxSize;
+  constructor(actualSize, maxSize = MAX_STATEMENT_SIZE) {
+    super(`Statement data too large: ${actualSize} bytes exceeds maximum of ${maxSize} bytes`);
+    this.name = "StatementDataTooLargeError";
+    this.actualSize = actualSize;
+    this.maxSize = maxSize;
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("StatementStoreError hierarchy", () => {
+    test("StatementStoreError is instanceof Error", () => {
+      const err = new StatementStoreError("test");
+      expect(err).toBeInstanceOf(Error);
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err.name).toBe("StatementStoreError");
+      expect(err.message).toBe("test");
+    });
+    test("StatementEncodingError", () => {
+      const err = new StatementEncodingError("bad field tag");
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err).toBeInstanceOf(Error);
+      expect(err.name).toBe("StatementEncodingError");
+      expect(err.message).toContain("bad field tag");
+    });
+    test("StatementEncodingError preserves cause", () => {
+      const cause = new Error("original");
+      const err = new StatementEncodingError("wrap", { cause });
+      expect(err.cause).toBe(cause);
+    });
+    test("StatementSubmitError", () => {
+      const detail = { status: "rejected", reason: "bad proof" };
+      const err = new StatementSubmitError(detail);
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err.name).toBe("StatementSubmitError");
+      expect(err.detail).toBe(detail);
+      expect(err.message).toContain("rejected");
+    });
+    test("StatementSubscriptionError", () => {
+      const err = new StatementSubscriptionError("not supported");
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err.name).toBe("StatementSubscriptionError");
+      expect(err.message).toContain("not supported");
+    });
+    test("StatementConnectionError", () => {
+      const err = new StatementConnectionError("timeout");
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err.name).toBe("StatementConnectionError");
+      expect(err.message).toContain("timeout");
+    });
+    test("StatementDataTooLargeError", () => {
+      const err = new StatementDataTooLargeError(600);
+      expect(err).toBeInstanceOf(StatementStoreError);
+      expect(err.name).toBe("StatementDataTooLargeError");
+      expect(err.actualSize).toBe(600);
+      expect(err.maxSize).toBe(512);
+      expect(err.message).toContain("600");
+      expect(err.message).toContain("512");
+    });
+    test("StatementDataTooLargeError with custom max", () => {
+      const err = new StatementDataTooLargeError(2e3, 1024);
+      expect(err.actualSize).toBe(2e3);
+      expect(err.maxSize).toBe(1024);
+    });
+    test("all errors are catchable via base class", () => {
+      const errors = [
+        new StatementEncodingError("test"),
+        new StatementSubmitError("test"),
+        new StatementSubscriptionError("test"),
+        new StatementConnectionError("test"),
+        new StatementDataTooLargeError(600)
+      ];
+      for (const err of errors) {
+        expect(err).toBeInstanceOf(StatementStoreError);
+      }
+    });
+  });
+}
+
+// src/data.ts
+function fromHex(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function toHex(bytes) {
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function encodeData(value) {
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.length > MAX_STATEMENT_SIZE) {
+    throw new StatementDataTooLargeError(bytes.length);
+  }
+  return bytes;
+}
+function decodeData(bytes) {
+  try {
+    const json = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return JSON.parse(json);
+  } catch (error) {
+    throw new StatementEncodingError("Failed to decode JSON data", { cause: error });
+  }
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("encodeData / decodeData", () => {
+    test("round-trips JSON object", () => {
+      const original = { type: "presence", peerId: "abc123", timestamp: 1234 };
+      const encoded = encodeData(original);
+      const decoded = decodeData(encoded);
+      expect(decoded).toEqual(original);
+    });
+    test("round-trips string", () => {
+      const encoded = encodeData("hello");
+      expect(decodeData(encoded)).toBe("hello");
+    });
+    test("round-trips number", () => {
+      const encoded = encodeData(42);
+      expect(decodeData(encoded)).toBe(42);
+    });
+    test("throws StatementDataTooLargeError for oversized data", () => {
+      const large = { data: "x".repeat(600) };
+      expect(() => encodeData(large)).toThrow(StatementDataTooLargeError);
+    });
+    test("allows data at exactly MAX_STATEMENT_SIZE", () => {
+      const str = "a".repeat(510);
+      const encoded = encodeData(str);
+      expect(encoded.length).toBe(512);
+    });
+    test("throws StatementEncodingError for invalid JSON bytes", () => {
+      const invalid = new TextEncoder().encode("{not valid json");
+      expect(() => decodeData(invalid)).toThrow(StatementEncodingError);
+    });
+    test("throws StatementEncodingError for non-UTF-8 bytes", () => {
+      const invalid = new Uint8Array([255, 254, 253]);
+      expect(() => decodeData(invalid)).toThrow(StatementEncodingError);
+    });
+  });
+  describe("toHex / fromHex", () => {
+    test("round-trips bytes", () => {
+      const bytes = new Uint8Array([222, 173, 190, 239]);
+      const hex = toHex(bytes);
+      expect(hex).toBe("0xdeadbeef");
+      expect(fromHex(hex)).toEqual(bytes);
+    });
+    test("handles hex without 0x prefix", () => {
+      const bytes = fromHex("cafebabe");
+      expect(bytes).toEqual(new Uint8Array([202, 254, 186, 190]));
+    });
+    test("handles empty input", () => {
+      expect(toHex(new Uint8Array(0))).toBe("0x");
+      expect(fromHex("0x")).toEqual(new Uint8Array(0));
+    });
+  });
+}
+
+// src/topics.ts
+import { blake2b256 } from "@parity/product-sdk-utils";
+function createTopic(name) {
+  const bytes = new TextEncoder().encode(name);
+  return blake2b256(bytes);
+}
+function createChannel(name) {
+  const bytes = new TextEncoder().encode(name);
+  return blake2b256(bytes);
+}
+function topicToHex(hash) {
+  let hex = "0x";
+  for (let i = 0; i < hash.length; i++) {
+    hex += hash[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function topicsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function serializeTopicFilter(filter) {
+  if (filter === "any") return "any";
+  if ("matchAll" in filter) {
+    return { matchAll: filter.matchAll.map(topicToHex) };
+  }
+  return { matchAny: filter.matchAny.map(topicToHex) };
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("createTopic", () => {
+    test("produces a 32-byte hash", () => {
+      const topic = createTopic("test");
+      expect(topic).toBeInstanceOf(Uint8Array);
+      expect(topic.length).toBe(32);
+    });
+    test("is deterministic (same input = same hash)", () => {
+      const a = createTopic("ss-webrtc");
+      const b = createTopic("ss-webrtc");
+      expect(topicsEqual(a, b)).toBe(true);
+    });
+    test("different inputs produce different hashes", () => {
+      const a = createTopic("topic-a");
+      const b = createTopic("topic-b");
+      expect(topicsEqual(a, b)).toBe(false);
+    });
+    test("empty string produces a valid hash", () => {
+      const topic = createTopic("");
+      expect(topic.length).toBe(32);
+    });
+  });
+  describe("createChannel", () => {
+    test("produces a 32-byte hash", () => {
+      const channel = createChannel("presence/peer-abc");
+      expect(channel).toBeInstanceOf(Uint8Array);
+      expect(channel.length).toBe(32);
+    });
+    test("same input as createTopic produces same bytes", () => {
+      const topic = createTopic("test-name");
+      const channel = createChannel("test-name");
+      expect(topicsEqual(topic, channel)).toBe(true);
+    });
+  });
+  describe("topicToHex", () => {
+    test("converts to hex with 0x prefix", () => {
+      const hash = new Uint8Array(32);
+      hash[0] = 171;
+      hash[1] = 205;
+      const hex = topicToHex(hash);
+      expect(hex).toMatch(/^0x/);
+      expect(hex).toBe(`0xabcd${"00".repeat(30)}`);
+    });
+    test("round-trips through hex encoding", () => {
+      const topic = createTopic("round-trip-test");
+      const hex = topicToHex(topic);
+      expect(hex.length).toBe(2 + 64);
+    });
+    test("pads single-digit bytes with leading zero", () => {
+      const hash = new Uint8Array([10]);
+      expect(topicToHex(hash)).toBe("0x0a");
+    });
+  });
+  describe("topicsEqual", () => {
+    test("returns true for identical hashes", () => {
+      const a = createTopic("same");
+      const b = createTopic("same");
+      expect(topicsEqual(a, b)).toBe(true);
+    });
+    test("returns false for different hashes", () => {
+      const a = createTopic("alpha");
+      const b = createTopic("beta");
+      expect(topicsEqual(a, b)).toBe(false);
+    });
+    test("returns false for different lengths", () => {
+      const a = new Uint8Array(32);
+      const b = new Uint8Array(16);
+      expect(topicsEqual(a, b)).toBe(false);
+    });
+    test("returns true for empty arrays", () => {
+      expect(topicsEqual(new Uint8Array(0), new Uint8Array(0))).toBe(true);
+    });
+  });
+  describe("serializeTopicFilter", () => {
+    test("serializes 'any' as string", () => {
+      expect(serializeTopicFilter("any")).toBe("any");
+    });
+    test("serializes matchAll with hex topics", () => {
+      const topics = [createTopic("a"), createTopic("b")];
+      const result = serializeTopicFilter({ matchAll: topics });
+      expect(result.matchAll).toHaveLength(2);
+      expect(result.matchAll[0]).toMatch(/^0x[0-9a-f]{64}$/);
+      expect(result.matchAll[1]).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+    test("serializes matchAny with hex topics", () => {
+      const topics = [createTopic("x")];
+      const result = serializeTopicFilter({ matchAny: topics });
+      expect(result.matchAny).toHaveLength(1);
+      expect(result.matchAny[0]).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+    test("matchAll preserves order", () => {
+      const topicA = createTopic("first");
+      const topicB = createTopic("second");
+      const result = serializeTopicFilter({ matchAll: [topicA, topicB] });
+      expect(result.matchAll[0]).toBe(topicToHex(topicA));
+      expect(result.matchAll[1]).toBe(topicToHex(topicB));
+    });
+  });
+}
+
+// src/transport.ts
+import { createLogger } from "@parity/product-sdk-logger";
+var log = createLogger("statement-store:transport");
+var HostTransport = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  subscribe(filter, onStatements, onError) {
+    const topics = extractTopicBytes(filter);
+    try {
+      const sub = this.store.subscribe(topics, (statements) => {
+        const converted = statements.map(
+          hostSignedStatementToSdk
+        );
+        onStatements(converted);
+      });
+      log.info("Host subscription active");
+      return {
+        unsubscribe: () => sub.unsubscribe()
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      log.warn("Host subscription failed", { error: msg });
+      onError(new StatementSubscriptionError(msg));
+      return { unsubscribe: () => {
+      } };
+    }
+  }
+  async signAndSubmit(statement, credentials) {
+    if (credentials.mode !== "host") {
+      throw new StatementConnectionError(
+        "HostTransport requires host credentials. Use { mode: 'host', accountId } to connect."
+      );
+    }
+    const hostStatement = sdkStatementToHost(statement);
+    const proof = await this.store.createProof(credentials.accountId, hostStatement);
+    const signedStatement = {
+      ...hostStatement,
+      proof
+    };
+    await this.store.submit(signedStatement);
+    log.debug("Statement submitted via host");
+  }
+  destroy() {
+  }
+};
+async function createTransport() {
+  const { getStatementStore } = await import("@parity/product-sdk-host");
+  const store = await getStatementStore();
+  if (!store) {
+    throw new StatementConnectionError(
+      "Host statement store unavailable. Ensure you are running inside a host container (Polkadot Browser / Desktop)."
+    );
+  }
+  log.info("Using host API statement store transport");
+  return new HostTransport(store);
+}
+function hostSignedStatementToSdk(hostStmt) {
+  const result = {};
+  if (hostStmt.data) result.data = hostStmt.data;
+  if (hostStmt.expiry !== void 0) result.expiry = hostStmt.expiry;
+  if (hostStmt.topics) {
+    result.topics = hostStmt.topics.map(bytesToHex);
+  }
+  if (hostStmt.channel) {
+    result.channel = bytesToHex(hostStmt.channel);
+  }
+  if (hostStmt.decryptionKey) {
+    result.decryptionKey = bytesToHex(hostStmt.decryptionKey);
+  }
+  if (hostStmt.proof) {
+    const tag = hostStmt.proof.tag;
+    const value = hostStmt.proof.value;
+    const sdkType = tag.charAt(0).toLowerCase() + tag.slice(1);
+    if ("signature" in value && "signer" in value) {
+      result.proof = {
+        type: sdkType,
+        value: {
+          signature: bytesToHex(value.signature),
+          signer: bytesToHex(value.signer)
+        }
+      };
+    }
+  }
+  return result;
+}
+function sdkStatementToHost(stmt) {
+  const result = {};
+  if (stmt.data) result.data = stmt.data;
+  if (stmt.expiry !== void 0) result.expiry = stmt.expiry;
+  if (stmt.topics) {
+    result.topics = stmt.topics.map(hexToBytes);
+  }
+  if (stmt.channel) {
+    result.channel = hexToBytes(stmt.channel);
+  }
+  if (stmt.decryptionKey) {
+    result.decryptionKey = hexToBytes(stmt.decryptionKey);
+  }
+  return result;
+}
+function extractTopicBytes(filter) {
+  if (filter === "any") return [];
+  if ("matchAll" in filter) {
+    return filter.matchAll.map(hexToBytes);
+  }
+  if ("matchAny" in filter) {
+    return filter.matchAny.map(hexToBytes);
+  }
+  return [];
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/client.ts
+import { createExpiry } from "@novasamatech/sdk-statement";
+var log2 = createLogger2("statement-store");
+var StatementStoreClient = class {
+  config;
+  transport = null;
+  credentials = null;
+  subscription = null;
+  callbacks = [];
+  connected = false;
+  connectPromise = null;
+  /** Set by destroy() so doConnect() can abort cleanly if destroy races with an in-flight connect. */
+  destroyed = false;
+  /**
+   * Track seen statements by channel hex to avoid re-delivering the same statement.
+   * Maps channel hex (or data hash) to the expiry value.
+   */
+  seen = /* @__PURE__ */ new Map();
+  /** Monotonic counter to ensure unique sequence numbers even within the same millisecond. */
+  sequenceCounter = 0;
+  /** Cached hex topic string for the app name, used as the primary subscription topic. */
+  appTopicHex;
+  constructor(config) {
+    this.config = {
+      appName: config.appName,
+      defaultTtlSeconds: config.defaultTtlSeconds ?? DEFAULT_TTL_SECONDS,
+      transport: config.transport
+    };
+    this.appTopicHex = topicToHex(createTopic(config.appName));
+  }
+  async connect(arg) {
+    if (this.destroyed) {
+      throw new StatementConnectionError(
+        "Cannot connect: client has been destroyed. Create a new instance."
+      );
+    }
+    if (this.connected) {
+      log2.warn("Already connected, ignoring duplicate connect()");
+      return;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    const credentials = "mode" in arg ? arg : { mode: "local", signer: arg };
+    this.connectPromise = this.doConnect(credentials).finally(() => {
+      this.connectPromise = null;
+    });
+    return this.connectPromise;
+  }
+  /* @integration */
+  async doConnect(credentials) {
+    this.credentials = credentials;
+    const transport = this.config.transport ?? await createTransport();
+    if (this.destroyed) {
+      if (transport !== this.config.transport) {
+        transport.destroy();
+      }
+      return;
+    }
+    this.transport = transport;
+    try {
+      log2.info("Connected", { appName: this.config.appName });
+      this.startSubscription();
+      this.connected = true;
+    } catch (error) {
+      this.destroy();
+      throw error;
+    }
+  }
+  /**
+   * Publish typed data to the statement store.
+   *
+   * @typeParam T - The type of data being published.
+   * @param data - The value to publish (must be JSON-serializable, max 512 bytes).
+   * @param options - Optional channel, topic2, TTL, and decryption key overrides.
+   * @returns `true` if accepted, `false` if rejected or errored.
+   * @throws {StatementConnectionError} If not connected.
+   * @throws {StatementDataTooLargeError} If the encoded data exceeds 512 bytes.
+   */
+  async publish(data, options) {
+    if (!this.transport || !this.credentials) {
+      throw new StatementConnectionError("Not connected. Call connect() first.");
+    }
+    const dataBytes = encodeData(data);
+    const ttl = options?.ttlSeconds ?? this.config.defaultTtlSeconds;
+    const expirationTimestamp = Math.floor(Date.now() / 1e3) + ttl;
+    const sequenceNumber = (Date.now() + this.sequenceCounter++) % 4294967295;
+    const expiry = createExpiry(expirationTimestamp, sequenceNumber);
+    const topics = [this.appTopicHex];
+    if (options?.topic2) {
+      topics.push(topicToHex(createTopic(options.topic2)));
+    }
+    const statement = {
+      expiry,
+      topics,
+      channel: options?.channel ? topicToHex(createChannel(options.channel)) : void 0,
+      decryptionKey: options?.decryptionKey ? topicToHex(options.decryptionKey) : void 0,
+      data: dataBytes
+    };
+    try {
+      await this.transport.signAndSubmit(statement, this.credentials);
+      log2.debug("Published", { channel: options?.channel });
+      return true;
+    } catch (error) {
+      log2.error("Publish failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  /**
+   * Subscribe to incoming statements on this application's topic.
+   *
+   * @typeParam T - The expected data type (decoded from JSON).
+   * @param callback - Called for each new statement.
+   * @param options - Optional secondary topic filter.
+   * @returns A handle to unsubscribe.
+   */
+  subscribe(callback, options) {
+    const topic2Hex = options?.topic2 ? topicToHex(createTopic(options.topic2)) : void 0;
+    const wrappedCallback = (statement) => {
+      if (topic2Hex) {
+        if (!statement.topics[1] || statement.topics[1] !== topic2Hex) return;
+      }
+      callback(statement);
+    };
+    this.callbacks.push(wrappedCallback);
+    return {
+      unsubscribe: () => {
+        const index = this.callbacks.indexOf(wrappedCallback);
+        if (index >= 0) {
+          this.callbacks.splice(index, 1);
+        }
+      }
+    };
+  }
+  /** Whether the client is connected and ready to publish/subscribe. */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get the signer's public key as a hex string (with 0x prefix).
+   *
+   * @returns The hex-encoded public key, or empty string if not connected or in host mode.
+   */
+  getPublicKeyHex() {
+    if (this.credentials?.mode === "local") {
+      return topicToHex(this.credentials.signer.publicKey);
+    }
+    return "";
+  }
+  /**
+   * Destroy the client, unsubscribing and closing the transport.
+   *
+   * Safe to call multiple times. After destruction, the client cannot be reused.
+   */
+  destroy() {
+    this.destroyed = true;
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+    if (this.transport) {
+      this.transport.destroy();
+      this.transport = null;
+    }
+    this.credentials = null;
+    this.connected = false;
+    this.connectPromise = null;
+    this.callbacks = [];
+    this.seen.clear();
+    log2.info("Destroyed");
+  }
+  // ========================================================================
+  // Internal
+  // ========================================================================
+  /* @integration */
+  startSubscription() {
+    if (!this.transport) return;
+    const filter = this.buildFilter();
+    this.subscription = this.transport.subscribe(
+      filter,
+      (statements) => {
+        for (const stmt of statements) {
+          this.handleStatementReceived(stmt);
+        }
+      },
+      (error) => {
+        log2.warn("Subscription error", {
+          error: error.message
+        });
+      }
+    );
+  }
+  /** Remove entries from the seen map whose expiry timestamp is in the past. */
+  pruneSeenMap() {
+    const nowSeconds = BigInt(Math.floor(Date.now() / 1e3));
+    for (const [key, expiry] of this.seen) {
+      const expiryTimestamp = expiry >> 32n;
+      if (expiryTimestamp > 0n && expiryTimestamp < nowSeconds) {
+        this.seen.delete(key);
+      }
+    }
+  }
+  /**
+   * Process a received statement, dedup, parse, and deliver to callbacks.
+   * Returns true if the statement was new and delivered.
+   */
+  handleStatementReceived(stmt) {
+    this.pruneSeenMap();
+    const parsed = this.parseStatement(stmt);
+    if (!parsed) return false;
+    const dedupeKey = parsed.channelHex ?? (parsed.raw.data ? toHex(blake2b2562(parsed.raw.data)) : "");
+    const existingExpiry = this.seen.get(dedupeKey);
+    const newExpiry = parsed.expiry ?? 0n;
+    if (existingExpiry !== void 0 && newExpiry <= existingExpiry) {
+      return false;
+    }
+    this.seen.set(dedupeKey, newExpiry);
+    for (const callback of [...this.callbacks]) {
+      try {
+        callback(parsed);
+      } catch (error) {
+        log2.error("Callback error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return true;
+  }
+  parseStatement(stmt) {
+    try {
+      if (!stmt.data) return null;
+      const data = decodeData(stmt.data);
+      let signerHex;
+      if (stmt.proof) {
+        const proofValue = stmt.proof.value;
+        if ("signer" in proofValue && typeof proofValue.signer === "string") {
+          signerHex = proofValue.signer;
+        }
+      }
+      return {
+        data,
+        signerHex,
+        channelHex: stmt.channel,
+        topics: stmt.topics ?? [],
+        expiry: stmt.expiry,
+        raw: stmt
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Build an SdkTopicFilter for the app's primary topic. */
+  buildFilter(topic2Name) {
+    const topics = [createTopic(this.config.appName)];
+    if (topic2Name) topics.push(createTopic(topic2Name));
+    return serializeTopicFilter({ matchAll: topics });
+  }
+};
+
+// src/channels.ts
+import { createLogger as createLogger3 } from "@parity/product-sdk-logger";
+var log3 = createLogger3("statement-store:channels");
+var ChannelStore = class {
+  client;
+  topic2;
+  values = /* @__PURE__ */ new Map();
+  /** Maps human-readable channel names to their hex hash keys, for consistent lookup. */
+  nameToHash = /* @__PURE__ */ new Map();
+  changeCallbacks = [];
+  subscription = null;
+  /**
+   * @param client - The connected {@link StatementStoreClient} to use.
+   * @param options - Optional secondary topic for scoping channels.
+   */
+  constructor(client, options) {
+    this.client = client;
+    this.topic2 = options?.topic2;
+    this.subscription = this.client.subscribe(
+      (statement) => this.handleStatement(statement),
+      { topic2: this.topic2 }
+    );
+  }
+  /**
+   * Write a value to a named channel.
+   *
+   * If the value doesn't include a `timestamp`, one is added automatically
+   * using `Date.now()`. The value is published to the statement store
+   * with the channel name as the statement channel.
+   *
+   * @param channelName - The channel name (e.g., "presence/peer-abc").
+   * @param value - The value to write.
+   * @returns `true` if the statement was accepted by the network.
+   */
+  async write(channelName, value) {
+    const timestamped = value.timestamp != null ? value : { ...value, timestamp: Date.now() };
+    const options = {
+      channel: channelName,
+      topic2: this.topic2
+    };
+    const success = await this.client.publish(timestamped, options);
+    if (success) {
+      const hashKey = topicToHex(createChannel(channelName));
+      this.nameToHash.set(channelName, hashKey);
+      this.updateChannel(hashKey, timestamped);
+    }
+    return success;
+  }
+  /**
+   * Read the latest value for a channel by its human-readable name.
+   *
+   * Looks up the channel hash from the name, then retrieves the value.
+   * Also checks the hash directly for values received from the network
+   * before any local write established the name mapping.
+   *
+   * @param channelName - The channel name (e.g., "presence/peer-abc").
+   * @returns The latest value, or `undefined` if no value has been received.
+   */
+  read(channelName) {
+    const hashKey = this.nameToHash.get(channelName) ?? topicToHex(createChannel(channelName));
+    return this.values.get(hashKey);
+  }
+  /**
+   * Read all channel values as a read-only map.
+   *
+   * Keys are hex-encoded channel hashes. Use {@link read} for
+   * lookup by human-readable name.
+   *
+   * @returns A map of channel hash to latest value.
+   */
+  readAll() {
+    return this.values;
+  }
+  /**
+   * Get the number of channels currently tracked.
+   */
+  get size() {
+    return this.values.size;
+  }
+  /**
+   * Subscribe to channel value changes.
+   *
+   * The callback is invoked whenever a channel value is updated
+   * (either from the network or from a local write).
+   *
+   * @param callback - Called with the channel key (hex hash for network-received, hex hash for local writes), new value, and previous value.
+   * @returns A handle to unsubscribe.
+   */
+  onChange(callback) {
+    this.changeCallbacks.push(callback);
+    return {
+      unsubscribe: () => {
+        const index = this.changeCallbacks.indexOf(callback);
+        if (index >= 0) {
+          this.changeCallbacks.splice(index, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Destroy the channel store and clean up subscriptions.
+   *
+   * Does not destroy the underlying client.
+   */
+  destroy() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+    this.values.clear();
+    this.nameToHash.clear();
+    this.changeCallbacks.length = 0;
+    log3.debug("ChannelStore destroyed");
+  }
+  // ========================================================================
+  // Internal
+  // ========================================================================
+  handleStatement(statement) {
+    if (!statement.channelHex) return;
+    this.updateChannel(statement.channelHex, statement.data);
+  }
+  updateChannel(channelName, value) {
+    const existing = this.values.get(channelName);
+    if (existing) {
+      const existingTs = existing.timestamp ?? 0;
+      const newTs = value.timestamp ?? 0;
+      if (newTs <= existingTs) {
+        return;
+      }
+    }
+    const previous = existing;
+    this.values.set(channelName, value);
+    for (const callback of [...this.changeCallbacks]) {
+      try {
+        callback(channelName, value, previous);
+      } catch (error) {
+        log3.error("onChange callback error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+};
+if (void 0) {
+  let createMockClient = function() {
+    const subscribeCallbacks = [];
+    return {
+      subscribe: vi.fn(
+        (callback, _options) => {
+          subscribeCallbacks.push(callback);
+          return {
+            unsubscribe: () => {
+              const idx = subscribeCallbacks.indexOf(
+                callback
+              );
+              if (idx >= 0) subscribeCallbacks.splice(idx, 1);
+            }
+          };
+        }
+      ),
+      publish: vi.fn(async () => true),
+      // Helper to simulate incoming statement
+      _simulateStatement(stmt) {
+        for (const cb of subscribeCallbacks) {
+          cb(stmt);
+        }
+      }
+    };
+  };
+  createMockClient2 = createMockClient;
+  const { describe, test, expect, vi, beforeEach } = void 0;
+  const { configure } = await null;
+  beforeEach(() => {
+    configure({ handler: () => {
+    } });
+  });
+  describe("ChannelStore", () => {
+    test("write publishes and updates local state", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      await store.write("presence/abc", { type: "presence", timestamp: 1e3 });
+      expect(mockClient.publish).toHaveBeenCalledOnce();
+      expect(store.read("presence/abc")).toEqual({ type: "presence", timestamp: 1e3 });
+    });
+    test("write adds timestamp if missing", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      const before = Date.now();
+      await store.write("ch", { type: "test" });
+      const calls = mockClient.publish.mock.calls;
+      const published = calls[0][0];
+      expect(published.timestamp).toBeGreaterThanOrEqual(before);
+    });
+    test("write returns false on publish failure", async () => {
+      const mockClient = createMockClient();
+      mockClient.publish = vi.fn(async () => false);
+      const store = new ChannelStore(
+        mockClient
+      );
+      const result = await store.write("ch", { type: "test", timestamp: 1 });
+      expect(result).toBe(false);
+      expect(store.read("ch")).toBeUndefined();
+    });
+    test("read returns undefined for unknown channel", () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      expect(store.read("unknown")).toBeUndefined();
+    });
+    test("readAll returns all values keyed by hash", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      await store.write("a", { type: "a", timestamp: 1 });
+      await store.write("b", { type: "b", timestamp: 2 });
+      const all = store.readAll();
+      expect(all.size).toBe(2);
+    });
+    test("size returns channel count", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      expect(store.size).toBe(0);
+      await store.write("a", { type: "a", timestamp: 1 });
+      expect(store.size).toBe(1);
+      await store.write("b", { type: "b", timestamp: 2 });
+      expect(store.size).toBe(2);
+    });
+    test("last-write-wins: newer timestamp replaces older", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      await store.write("ch", { type: "old", timestamp: 100 });
+      await store.write("ch", { type: "new", timestamp: 200 });
+      expect(store.read("ch")?.type).toBe("new");
+    });
+    test("last-write-wins: older timestamp is ignored", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      await store.write("ch", { type: "new", timestamp: 200 });
+      await store.write("ch", { type: "old", timestamp: 100 });
+      expect(store.read("ch")?.type).toBe("new");
+    });
+    test("onChange fires on update with previous value", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      const onChange = vi.fn();
+      store.onChange(onChange);
+      await store.write("ch", { type: "first", timestamp: 1 });
+      expect(onChange).toHaveBeenCalledOnce();
+      expect(onChange.mock.calls[0][1]).toEqual({ type: "first", timestamp: 1 });
+      expect(onChange.mock.calls[0][2]).toBeUndefined();
+      await store.write("ch", { type: "second", timestamp: 2 });
+      expect(onChange).toHaveBeenCalledTimes(2);
+      expect(onChange.mock.calls[1][1]).toEqual({ type: "second", timestamp: 2 });
+      expect(onChange.mock.calls[1][2]).toEqual({ type: "first", timestamp: 1 });
+    });
+    test("onChange unsubscribe stops notifications", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      const onChange = vi.fn();
+      const sub = store.onChange(onChange);
+      await store.write("ch", { type: "first", timestamp: 1 });
+      expect(onChange).toHaveBeenCalledOnce();
+      sub.unsubscribe();
+      await store.write("ch", { type: "second", timestamp: 2 });
+      expect(onChange).toHaveBeenCalledOnce();
+    });
+    test("destroy cleans up", async () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      await store.write("ch", { type: "test", timestamp: 1 });
+      store.destroy();
+      expect(store.readAll().size).toBe(0);
+    });
+    test("destroy is safe when subscription is already null", () => {
+      const mockClient = createMockClient();
+      const store = new ChannelStore(
+        mockClient
+      );
+      store.destroy();
+      expect(() => store.destroy()).not.toThrow();
+    });
+  });
+}
+var createMockClient2;
+export {
+  ChannelStore,
+  DEFAULT_TTL_SECONDS,
+  MAX_STATEMENT_SIZE,
+  MAX_USER_TOTAL,
+  StatementConnectionError,
+  StatementDataTooLargeError,
+  StatementEncodingError,
+  StatementStoreClient,
+  StatementStoreError,
+  StatementSubmitError,
+  StatementSubscriptionError,
+  createChannel,
+  createTopic,
+  createTransport,
+  decodeData,
+  encodeData,
+  fromHex,
+  serializeTopicFilter,
+  toHex,
+  topicToHex,
+  topicsEqual
+};
+//# sourceMappingURL=index.js.map