@bcts/spqr 1.0.0-alpha.21

package/src/v1/chunked/serialize.ts

@@ -0,0 +1,278 @@
+/**
+ * Copyright © 2025 Signal Messenger, LLC
+ * Copyright © 2026 Parity Technologies
+ *
+ * Serialization bridge between runtime States and PbV1State protobuf.
+ *
+ * Converts the runtime discriminated-union States objects to/from their
+ * protobuf representations so that the top-level API can persist state
+ * as opaque bytes.
+ */
+
+import type { PbV1State, PbChunkedState } from "../../proto/pq-ratchet-types.js";
+import { Authenticator } from "../../authenticator.js";
+import { PolyEncoder, PolyDecoder } from "../../encoding/polynomial.js";
+
+// Unchunked state classes
+import * as ucSendEk from "../unchunked/send-ek.js";
+import * as ucSendCt from "../unchunked/send-ct.js";
+
+// Chunked state classes
+import * as sendEk from "./send-ek.js";
+import * as sendCt from "./send-ct.js";
+
+import type { States } from "./states.js";
+import type { Epoch } from "../../types.js";
+
+// ---------------------------------------------------------------------------
+// States -> PbV1State
+// ---------------------------------------------------------------------------
+
+/**
+ * Serialize a runtime States object into PbV1State for protobuf encoding.
+ * Stores the epoch as field 12 so it can be recovered on deserialization.
+ */
+export function statesToPb(s: States): PbV1State {
+  const epoch = s.state.epoch;
+  return { innerState: chunkedStateToPb(s), epoch };
+}
+
+function chunkedStateToPb(s: States): PbChunkedState {
+  switch (s.tag) {
+    case "keysUnsampled": {
+      const st = s.state;
+      return {
+        type: "keysUnsampled",
+        uc: { auth: st.uc.auth.toProto() },
+      };
+    }
+    case "keysSampled": {
+      const st = s.state;
+      return {
+        type: "keysSampled",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          ek: Uint8Array.from(st.uc.ek),
+          dk: Uint8Array.from(st.uc.dk),
+          hdr: new Uint8Array(0),
+          hdrMac: new Uint8Array(0),
+        },
+        sendingHdr: st.sendingHdr.toProto(),
+      };
+    }
+    case "headerSent": {
+      const st = s.state;
+      return {
+        type: "headerSent",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          ek: new Uint8Array(0),
+          dk: Uint8Array.from(st.uc.dk),
+        },
+        sendingEk: st.sendingEk.toProto(),
+        receivingCt1: st.receivingCt1.toProto(),
+      };
+    }
+    case "ct1Received": {
+      const st = s.state;
+      return {
+        type: "ct1Received",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          dk: Uint8Array.from(st.uc.dk),
+          ct1: Uint8Array.from(st.uc.ct1),
+        },
+        sendingEk: st.sendingEk.toProto(),
+      };
+    }
+    case "ekSentCt1Received": {
+      const st = s.state;
+      return {
+        type: "ekSentCt1Received",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          dk: Uint8Array.from(st.uc.dk),
+          ct1: Uint8Array.from(st.uc.ct1),
+        },
+        receivingCt2: st.receivingCt2.toProto(),
+      };
+    }
+    case "noHeaderReceived": {
+      const st = s.state;
+      return {
+        type: "noHeaderReceived",
+        uc: { auth: st.uc.auth.toProto() },
+        receivingHdr: st.receivingHdr.toProto(),
+      };
+    }
+    case "headerReceived": {
+      const st = s.state;
+      return {
+        type: "headerReceived",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          hdr: Uint8Array.from(st.uc.hdr),
+          es: new Uint8Array(0),
+          ct1: new Uint8Array(0),
+          ss: new Uint8Array(0),
+        },
+        receivingEk: st.receivingEk.toProto(),
+      };
+    }
+    case "ct1Sampled": {
+      const st = s.state;
+      return {
+        type: "ct1Sampled",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          hdr: Uint8Array.from(st.uc.hdr),
+          es: Uint8Array.from(st.uc.es),
+          ct1: Uint8Array.from(st.uc.ct1),
+        },
+        sendingCt1: st.sendingCt1.toProto(),
+        receivingEk: st.receivingEk.toProto(),
+      };
+    }
+    case "ekReceivedCt1Sampled": {
+      const st = s.state;
+      return {
+        type: "ekReceivedCt1Sampled",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          hdr: new Uint8Array(0),
+          es: Uint8Array.from(st.uc.es),
+          ek: Uint8Array.from(st.uc.ek),
+          ct1: Uint8Array.from(st.uc.ct1),
+        },
+        sendingCt1: st.sendingCt1.toProto(),
+      };
+    }
+    case "ct1Acknowledged": {
+      const st = s.state;
+      return {
+        type: "ct1Acknowledged",
+        uc: {
+          auth: st.uc.auth.toProto(),
+          hdr: Uint8Array.from(st.uc.hdr),
+          es: Uint8Array.from(st.uc.es),
+          ct1: Uint8Array.from(st.uc.ct1),
+        },
+        receivingEk: st.receivingEk.toProto(),
+      };
+    }
+    case "ct2Sampled": {
+      const st = s.state;
+      return {
+        type: "ct2Sampled",
+        uc: { auth: st.uc.auth.toProto() },
+        sendingCt2: st.sendingCt2.toProto(),
+      };
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// PbV1State -> States
+// ---------------------------------------------------------------------------
+
+/**
+ * Deserialize a PbV1State back into a runtime States object.
+ *
+ * @param pb - The protobuf V1 state
+ * @returns The reconstructed runtime States
+ */
+export function statesFromPb(pb: PbV1State): States {
+  if (pb.innerState === undefined) {
+    throw new Error("PbV1State has no innerState");
+  }
+  const epoch = pb.epoch ?? 1n;
+  return chunkedStateFromPb(pb.innerState, epoch);
+}
+
+function chunkedStateFromPb(cs: PbChunkedState, epoch: Epoch): States {
+  switch (cs.type) {
+    case "keysUnsampled": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendEk.KeysUnsampled(epoch, auth);
+      return { tag: "keysUnsampled", state: new sendEk.KeysUnsampled(ucState) };
+    }
+    case "keysSampled": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendEk.HeaderSent(epoch, auth, cs.uc.ek, cs.uc.dk);
+      const encoder = PolyEncoder.fromProto(cs.sendingHdr);
+      return { tag: "keysSampled", state: new sendEk.KeysSampled(ucState, encoder) };
+    }
+    case "headerSent": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendEk.EkSent(epoch, auth, cs.uc.dk);
+      const encoder = PolyEncoder.fromProto(cs.sendingEk);
+      const decoder = PolyDecoder.fromProto(cs.receivingCt1);
+      return { tag: "headerSent", state: new sendEk.HeaderSent(ucState, encoder, decoder) };
+    }
+    case "ct1Received": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendEk.EkSentCt1Received(epoch, auth, cs.uc.dk, cs.uc.ct1);
+      const encoder = PolyEncoder.fromProto(cs.sendingEk);
+      return { tag: "ct1Received", state: new sendEk.Ct1Received(ucState, encoder) };
+    }
+    case "ekSentCt1Received": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendEk.EkSentCt1Received(epoch, auth, cs.uc.dk, cs.uc.ct1);
+      const decoder = PolyDecoder.fromProto(cs.receivingCt2);
+      return { tag: "ekSentCt1Received", state: new sendEk.EkSentCt1Received(ucState, decoder) };
+    }
+    case "noHeaderReceived": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendCt.NoHeaderReceived(epoch, auth);
+      const decoder = PolyDecoder.fromProto(cs.receivingHdr);
+      return { tag: "noHeaderReceived", state: new sendCt.NoHeaderReceived(ucState, decoder) };
+    }
+    case "headerReceived": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendCt.HeaderReceived(epoch, auth, cs.uc.hdr);
+      const decoder = PolyDecoder.fromProto(cs.receivingEk);
+      return { tag: "headerReceived", state: new sendCt.HeaderReceived(ucState, decoder) };
+    }
+    case "ct1Sampled": {
+      const auth = authFromPb(cs.uc.auth);
+      // Ct1Sent stores (epoch, auth, hdr, es, ct1) -- ct1 needed for MAC in sendCt2
+      const ucState = new ucSendCt.Ct1Sent(epoch, auth, cs.uc.hdr, cs.uc.es, cs.uc.ct1);
+      const encoder = PolyEncoder.fromProto(cs.sendingCt1);
+      const decoder = PolyDecoder.fromProto(cs.receivingEk);
+      return { tag: "ct1Sampled", state: new sendCt.Ct1Sampled(ucState, encoder, decoder) };
+    }
+    case "ekReceivedCt1Sampled": {
+      const auth = authFromPb(cs.uc.auth);
+      // Ct1SentEkReceived stores (epoch, auth, es, ek, ct1) -- ct1 needed for MAC in sendCt2
+      const ucState = new ucSendCt.Ct1SentEkReceived(epoch, auth, cs.uc.es, cs.uc.ek, cs.uc.ct1);
+      const encoder = PolyEncoder.fromProto(cs.sendingCt1);
+      return {
+        tag: "ekReceivedCt1Sampled",
+        state: new sendCt.EkReceivedCt1Sampled(ucState, encoder),
+      };
+    }
+    case "ct1Acknowledged": {
+      const auth = authFromPb(cs.uc.auth);
+      // Ct1Sent stores (epoch, auth, hdr, es, ct1) -- ct1 needed for MAC in sendCt2
+      const ucState = new ucSendCt.Ct1Sent(epoch, auth, cs.uc.hdr, cs.uc.es, cs.uc.ct1);
+      const decoder = PolyDecoder.fromProto(cs.receivingEk);
+      return { tag: "ct1Acknowledged", state: new sendCt.Ct1Acknowledged(ucState, decoder) };
+    }
+    case "ct2Sampled": {
+      const auth = authFromPb(cs.uc.auth);
+      const ucState = new ucSendCt.Ct2Sent(epoch, auth);
+      const encoder = PolyEncoder.fromProto(cs.sendingCt2);
+      return { tag: "ct2Sampled", state: new sendCt.Ct2Sampled(ucState, encoder) };
+    }
+  }
+}
+
+function authFromPb(pb: { rootKey: Uint8Array; macKey: Uint8Array } | undefined): Authenticator {
+  if (pb === undefined) {
+    return Authenticator.fromProto({
+      rootKey: new Uint8Array(32),
+      macKey: new Uint8Array(32),
+    });
+  }
+  return Authenticator.fromProto(pb);
+}

package/src/v1/chunked/states.ts

@@ -0,0 +1,399 @@
+/**
+ * Copyright © 2025 Signal Messenger, LLC
+ * Copyright © 2026 Parity Technologies
+ *
+ * Chunked state machine dispatcher for SPQR V1.
+ *
+ * Provides the top-level send/recv interface that dispatches to the
+ * appropriate chunked send_ek or send_ct state, handling epoch
+ * validation and state transitions.
+ */
+
+import type { Chunk } from "../../encoding/polynomial.js";
+import type { Epoch, EpochSecret, RandomBytes } from "../../types.js";
+import { SpqrError, SpqrErrorCode } from "../../error.js";
+import { Authenticator } from "../../authenticator.js";
+import * as unchunked from "../unchunked/send-ek.js";
+import * as sendEk from "./send-ek.js";
+import * as sendCt from "./send-ct.js";
+
+// ---------------------------------------------------------------------------
+// Message types
+// ---------------------------------------------------------------------------
+
+export type MessagePayload =
+  | { type: "none" }
+  | { type: "hdr"; chunk: Chunk }
+  | { type: "ek"; chunk: Chunk }
+  | { type: "ekCt1Ack"; chunk: Chunk }
+  | { type: "ct1Ack" }
+  | { type: "ct1"; chunk: Chunk }
+  | { type: "ct2"; chunk: Chunk };
+
+export interface Message {
+  epoch: Epoch;
+  payload: MessagePayload;
+}
+
+export interface SendResult {
+  msg: Message;
+  key: EpochSecret | null;
+  state: States;
+}
+
+export interface RecvResult {
+  key: EpochSecret | null;
+  state: States;
+}
+
+// ---------------------------------------------------------------------------
+// States discriminated union
+// ---------------------------------------------------------------------------
+
+export type States =
+  | { tag: "keysUnsampled"; state: sendEk.KeysUnsampled }
+  | { tag: "keysSampled"; state: sendEk.KeysSampled }
+  | { tag: "headerSent"; state: sendEk.HeaderSent }
+  | { tag: "ct1Received"; state: sendEk.Ct1Received }
+  | { tag: "ekSentCt1Received"; state: sendEk.EkSentCt1Received }
+  | { tag: "noHeaderReceived"; state: sendCt.NoHeaderReceived }
+  | { tag: "headerReceived"; state: sendCt.HeaderReceived }
+  | { tag: "ct1Sampled"; state: sendCt.Ct1Sampled }
+  | { tag: "ekReceivedCt1Sampled"; state: sendCt.EkReceivedCt1Sampled }
+  | { tag: "ct1Acknowledged"; state: sendCt.Ct1Acknowledged }
+  | { tag: "ct2Sampled"; state: sendCt.Ct2Sampled };
+
+// ---------------------------------------------------------------------------
+// Epoch accessor
+// ---------------------------------------------------------------------------
+
+function getEpoch(s: States): Epoch {
+  return s.state.epoch;
+}
+
+// ---------------------------------------------------------------------------
+// Initialization
+// ---------------------------------------------------------------------------
+
+/**
+ * Initialize Alice (send_ek side) at epoch 1.
+ */
+export function initA(authKey: Uint8Array): States {
+  const auth = Authenticator.create(authKey, 1n);
+  const ucState = new unchunked.KeysUnsampled(1n, auth);
+  return {
+    tag: "keysUnsampled",
+    state: new sendEk.KeysUnsampled(ucState),
+  };
+}
+
+/**
+ * Initialize Bob (send_ct side) at epoch 1.
+ */
+export function initB(authKey: Uint8Array): States {
+  return {
+    tag: "noHeaderReceived",
+    state: sendCt.NoHeaderReceived.create(authKey),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Send
+// ---------------------------------------------------------------------------
+
+/**
+ * Produce the next outgoing message from the current state.
+ */
+export function send(current: States, rng: RandomBytes): SendResult {
+  const epoch = getEpoch(current);
+
+  switch (current.tag) {
+    case "keysUnsampled": {
+      const [next, chunk] = current.state.sendHdrChunk(rng);
+      return {
+        msg: { epoch, payload: { type: "hdr", chunk } },
+        key: null,
+        state: { tag: "keysSampled", state: next },
+      };
+    }
+
+    case "keysSampled": {
+      const [next, chunk] = current.state.sendHdrChunk();
+      return {
+        msg: { epoch, payload: { type: "hdr", chunk } },
+        key: null,
+        state: { tag: "keysSampled", state: next },
+      };
+    }
+
+    case "headerSent": {
+      const [next, chunk] = current.state.sendEkChunk();
+      return {
+        msg: { epoch, payload: { type: "ek", chunk } },
+        key: null,
+        state: { tag: "headerSent", state: next },
+      };
+    }
+
+    case "ct1Received": {
+      const [next, chunk] = current.state.sendEkChunk();
+      return {
+        msg: { epoch, payload: { type: "ekCt1Ack", chunk } },
+        key: null,
+        state: { tag: "ct1Received", state: next },
+      };
+    }
+
+    case "ekSentCt1Received": {
+      return {
+        msg: { epoch, payload: { type: "ct1Ack" } },
+        key: null,
+        state: current,
+      };
+    }
+
+    case "noHeaderReceived": {
+      return {
+        msg: { epoch, payload: { type: "none" } },
+        key: null,
+        state: current,
+      };
+    }
+
+    case "headerReceived": {
+      const [next, chunk, epochSecret] = current.state.sendCt1Chunk(rng);
+      return {
+        msg: { epoch, payload: { type: "ct1", chunk } },
+        key: epochSecret,
+        state: { tag: "ct1Sampled", state: next },
+      };
+    }
+
+    case "ct1Sampled": {
+      const [next, chunk] = current.state.sendCt1Chunk();
+      return {
+        msg: { epoch, payload: { type: "ct1", chunk } },
+        key: null,
+        state: { tag: "ct1Sampled", state: next },
+      };
+    }
+
+    case "ekReceivedCt1Sampled": {
+      const [next, chunk] = current.state.sendCt1Chunk();
+      return {
+        msg: { epoch, payload: { type: "ct1", chunk } },
+        key: null,
+        state: { tag: "ekReceivedCt1Sampled", state: next },
+      };
+    }
+
+    case "ct1Acknowledged": {
+      return {
+        msg: { epoch, payload: { type: "none" } },
+        key: null,
+        state: current,
+      };
+    }
+
+    case "ct2Sampled": {
+      const [next, chunk] = current.state.sendCt2Chunk();
+      return {
+        msg: { epoch, payload: { type: "ct2", chunk } },
+        key: null,
+        state: { tag: "ct2Sampled", state: next },
+      };
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Recv
+// ---------------------------------------------------------------------------
+
+/**
+ * Process an incoming message and transition the state.
+ */
+export function recv(current: States, msg: Message): RecvResult {
+  const stateEpoch = getEpoch(current);
+
+  // Handle epoch mismatch: messages from the past are ignored
+  if (msg.epoch < stateEpoch) {
+    return { key: null, state: current };
+  }
+
+  // Messages from the future are an error (except ct2Sampled epoch+1)
+  if (msg.epoch > stateEpoch) {
+    if (current.tag === "ct2Sampled" && msg.epoch === stateEpoch + 1n) {
+      // Next epoch -- transition to KeysUnsampled and return immediately.
+      // The incoming message payload is NOT processed in the new state
+      // (matches Rust: the peer will retransmit via erasure coding).
+      const next = current.state.recvNextEpoch(msg.epoch);
+      return { key: null, state: { tag: "keysUnsampled", state: next } };
+    }
+    throw new SpqrError(
+      `Epoch too far ahead: state=${stateEpoch}, msg=${msg.epoch}`,
+      SpqrErrorCode.EpochOutOfRange,
+    );
+  }
+
+  // msg.epoch === stateEpoch -- process the payload
+  const payload = msg.payload;
+
+  switch (current.tag) {
+    case "keysUnsampled": {
+      // Waiting to send -- nothing to receive
+      return { key: null, state: current };
+    }
+
+    case "keysSampled": {
+      if (payload.type === "ct1") {
+        const next = current.state.recvCt1Chunk(msg.epoch, payload.chunk);
+        return { key: null, state: { tag: "headerSent", state: next } };
+      }
+      return { key: null, state: current };
+    }
+
+    case "headerSent": {
+      if (payload.type === "ct1") {
+        const result = current.state.recvCt1Chunk(msg.epoch, payload.chunk);
+        if (result.done) {
+          return {
+            key: null,
+            state: { tag: "ct1Received", state: result.state },
+          };
+        }
+        return {
+          key: null,
+          state: { tag: "headerSent", state: result.state },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "ct1Received": {
+      if (payload.type === "ct2") {
+        const next = current.state.recvCt2Chunk(msg.epoch, payload.chunk);
+        return {
+          key: null,
+          state: { tag: "ekSentCt1Received", state: next },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "ekSentCt1Received": {
+      if (payload.type === "ct2") {
+        const result = current.state.recvCt2Chunk(msg.epoch, payload.chunk);
+        if (result.done) {
+          return {
+            key: result.epochSecret,
+            state: { tag: "noHeaderReceived", state: result.state },
+          };
+        }
+        return {
+          key: null,
+          state: { tag: "ekSentCt1Received", state: result.state },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "noHeaderReceived": {
+      if (payload.type === "hdr") {
+        const result = current.state.recvHdrChunk(msg.epoch, payload.chunk);
+        if (result.done) {
+          return {
+            key: null,
+            state: { tag: "headerReceived", state: result.state },
+          };
+        }
+        return {
+          key: null,
+          state: { tag: "noHeaderReceived", state: result.state },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "headerReceived": {
+      // Waiting to send ct1 -- nothing to receive in this state
+      return { key: null, state: current };
+    }
+
+    case "ct1Sampled": {
+      if (payload.type === "ek") {
+        const result = current.state.recvEkChunk(msg.epoch, payload.chunk, false);
+        return mapCt1SampledResult(result);
+      }
+      if (payload.type === "ekCt1Ack") {
+        const result = current.state.recvEkChunk(msg.epoch, payload.chunk, true);
+        return mapCt1SampledResult(result);
+      }
+      return { key: null, state: current };
+    }
+
+    case "ekReceivedCt1Sampled": {
+      if (payload.type === "ct1Ack" || payload.type === "ekCt1Ack") {
+        const next = current.state.recvCt1Ack(msg.epoch);
+        return {
+          key: null,
+          state: { tag: "ct2Sampled", state: next },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "ct1Acknowledged": {
+      if (payload.type === "ek" || payload.type === "ekCt1Ack") {
+        const chunk = payload.type === "ek" ? payload.chunk : payload.chunk;
+        const result = current.state.recvEkChunk(msg.epoch, chunk);
+        if (result.done) {
+          return {
+            key: result.epochSecret,
+            state: { tag: "ct2Sampled", state: result.state },
+          };
+        }
+        return {
+          key: null,
+          state: { tag: "ct1Acknowledged", state: result.state },
+        };
+      }
+      return { key: null, state: current };
+    }
+
+    case "ct2Sampled": {
+      // If we receive a message for the current epoch, nothing to do
+      // (next epoch handled above)
+      return { key: null, state: current };
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function mapCt1SampledResult(result: sendCt.Ct1SampledRecvChunk): RecvResult {
+  switch (result.tag) {
+    case "done":
+      return {
+        key: result.epochSecret,
+        state: { tag: "ct2Sampled", state: result.state },
+      };
+    case "stillSending":
+      return {
+        key: result.epochSecret,
+        state: { tag: "ekReceivedCt1Sampled", state: result.state },
+      };
+    case "stillReceiving":
+      return {
+        key: null,
+        state: { tag: "ct1Acknowledged", state: result.state },
+      };
+    case "stillReceivingStillSending":
+      return {
+        key: null,
+        state: { tag: "ct1Sampled", state: result.state },
+      };
+  }
+}

package/src/v1/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright © 2025 Signal Messenger, LLC
+ * Copyright © 2026 Parity Technologies
+ *
+ * SPQR V1 protocol layer.
+ */
+
+export * as chunked from "./chunked/index.js";
+export * as unchunked from "./unchunked/index.js";

package/src/v1/unchunked/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright © 2025 Signal Messenger, LLC
+ * Copyright © 2026 Parity Technologies
+ *
+ * Unchunked state machine for SPQR V1.
+ */
+
+// send_ek states
+export { KeysUnsampled, HeaderSent, EkSent, EkSentCt1Received } from "./send-ek.js";
+export type { RecvCt2Result } from "./send-ek.js";
+
+// send_ct states
+export {
+  NoHeaderReceived,
+  HeaderReceived,
+  Ct1Sent,
+  Ct1SentEkReceived,
+  Ct2Sent,
+} from "./send-ct.js";
+export type { SendCt2Result } from "./send-ct.js";