@tinyhumansai/tinyplace 0.1.0 → 0.1.1

package/src/signal/memory-store.ts

@@ -1,66 +0,0 @@
-import type { X25519KeyPair } from "./crypto.js";
-import type { SessionStore, SessionState, PreKeyPair, SignedPreKeyPair } from "./store.js";
-
-export class MemorySessionStore implements SessionStore {
-  private readonly identityKeyPair: X25519KeyPair;
-  private readonly signedPreKeys = new Map<string, SignedPreKeyPair>();
-  private readonly preKeys = new Map<string, PreKeyPair>();
-  private readonly sessions = new Map<string, SessionState>();
-  private activeSignedPreKeyId: string | null = null;
-
-  constructor(identityKeyPair: X25519KeyPair) {
-    this.identityKeyPair = identityKeyPair;
-  }
-
-  async getIdentityX25519KeyPair(): Promise<X25519KeyPair> {
-    return this.identityKeyPair;
-  }
-
-  async getSignedPreKey(keyId: string): Promise<SignedPreKeyPair | null> {
-    return this.signedPreKeys.get(keyId) ?? null;
-  }
-
-  async getActiveSignedPreKey(): Promise<SignedPreKeyPair> {
-    if (!this.activeSignedPreKeyId) {
-      throw new Error("No active signed pre-key");
-    }
-    const key = this.signedPreKeys.get(this.activeSignedPreKeyId);
-    if (!key) {
-      throw new Error("Active signed pre-key not found");
-    }
-    return key;
-  }
-
-  async storeSignedPreKey(preKey: SignedPreKeyPair): Promise<void> {
-    this.signedPreKeys.set(preKey.keyId, preKey);
-    this.activeSignedPreKeyId = preKey.keyId;
-  }
-
-  async getPreKey(keyId: string): Promise<PreKeyPair | null> {
-    return this.preKeys.get(keyId) ?? null;
-  }
-
-  async removePreKey(keyId: string): Promise<void> {
-    this.preKeys.delete(keyId);
-  }
-
-  async storePreKey(preKey: PreKeyPair): Promise<void> {
-    this.preKeys.set(preKey.keyId, preKey);
-  }
-
-  async getAllPreKeys(): Promise<Array<PreKeyPair>> {
-    return Array.from(this.preKeys.values());
-  }
-
-  async getSession(address: string): Promise<SessionState | null> {
-    return this.sessions.get(address) ?? null;
-  }
-
-  async storeSession(address: string, session: SessionState): Promise<void> {
-    this.sessions.set(address, session);
-  }
-
-  async removeSession(address: string): Promise<void> {
-    this.sessions.delete(address);
-  }
-}

package/src/signal/ratchet.ts

@@ -1,162 +0,0 @@
-import {
-  generateX25519KeyPair,
-  x25519SharedSecret,
-  kdfRootKey,
-  kdfChainKey,
-  encrypt,
-  decrypt,
-} from "./crypto.js";
-import { skippedKeyId } from "./store.js";
-import type { SessionState } from "./store.js";
-
-const MAX_SKIP = 1000;
-
-export interface RatchetHeader {
-  publicKey: Uint8Array;
-  previousChainLength: number;
-  messageNumber: number;
-}
-
-export interface RatchetMessage {
-  header: RatchetHeader;
-  ciphertext: Uint8Array;
-}
-
-export async function ratchetEncrypt(
-  state: SessionState,
-  plaintext: Uint8Array,
-  associatedData: Uint8Array,
-): Promise<RatchetMessage> {
-  if (!state.sendChainKey) {
-    dhRatchetStep(state);
-  }
-  const { chainKey, messageKey } = kdfChainKey(state.sendChainKey!);
-  state.sendChainKey = chainKey;
-
-  const header: RatchetHeader = {
-    publicKey: state.dhSendKeyPair.publicKey,
-    previousChainLength: state.previousChainLength,
-    messageNumber: state.sendMessageNumber,
-  };
-  state.sendMessageNumber++;
-
-  const headerBytes = encodeHeader(header);
-  const ad = concat(associatedData, headerBytes);
-  const ciphertext = await encrypt(messageKey, plaintext, ad);
-
-  return { header, ciphertext };
-}
-
-export async function ratchetDecrypt(
-  state: SessionState,
-  message: RatchetMessage,
-  associatedData: Uint8Array,
-): Promise<Uint8Array> {
-  const skId = skippedKeyId(message.header.publicKey, message.header.messageNumber);
-  const skippedMk = state.skippedKeys.get(skId);
-  if (skippedMk) {
-    state.skippedKeys.delete(skId);
-    const headerBytes = encodeHeader(message.header);
-    const ad = concat(associatedData, headerBytes);
-    return decrypt(skippedMk, message.ciphertext, ad);
-  }
-
-  const headerKeyChanged =
-    !state.dhRecvPublicKey ||
-    !uint8ArrayEqual(state.dhRecvPublicKey, message.header.publicKey);
-
-  if (headerKeyChanged) {
-    if (state.recvChainKey) {
-      skipMessageKeys(state, message.header.previousChainLength);
-    }
-    dhRatchetStepWithRecv(state, message.header.publicKey);
-  }
-
-  skipMessageKeys(state, message.header.messageNumber);
-
-  const { chainKey, messageKey } = kdfChainKey(state.recvChainKey!);
-  state.recvChainKey = chainKey;
-  state.recvMessageNumber++;
-
-  const headerBytes = encodeHeader(message.header);
-  const ad = concat(associatedData, headerBytes);
-  return decrypt(messageKey, message.ciphertext, ad);
-}
-
-function dhRatchetStep(state: SessionState): void {
-  if (!state.dhRecvPublicKey) {
-    throw new Error("Cannot perform DH ratchet without recipient public key");
-  }
-  const dhOutput = x25519SharedSecret(
-    state.dhSendKeyPair.privateKey,
-    state.dhRecvPublicKey,
-  );
-  const { rootKey, chainKey } = kdfRootKey(state.rootKey, dhOutput);
-  state.rootKey = rootKey;
-  state.sendChainKey = chainKey;
-}
-
-function dhRatchetStepWithRecv(
-  state: SessionState,
-  newRecvPublicKey: Uint8Array,
-): void {
-  state.previousChainLength = state.sendMessageNumber;
-  state.sendMessageNumber = 0;
-  state.recvMessageNumber = 0;
-  state.dhRecvPublicKey = newRecvPublicKey;
-
-  const dhRecv = x25519SharedSecret(
-    state.dhSendKeyPair.privateKey,
-    state.dhRecvPublicKey,
-  );
-  const recvResult = kdfRootKey(state.rootKey, dhRecv);
-  state.rootKey = recvResult.rootKey;
-  state.recvChainKey = recvResult.chainKey;
-
-  state.dhSendKeyPair = generateX25519KeyPair();
-  const dhSend = x25519SharedSecret(
-    state.dhSendKeyPair.privateKey,
-    state.dhRecvPublicKey,
-  );
-  const sendResult = kdfRootKey(state.rootKey, dhSend);
-  state.rootKey = sendResult.rootKey;
-  state.sendChainKey = sendResult.chainKey;
-}
-
-function skipMessageKeys(state: SessionState, until: number): void {
-  if (!state.recvChainKey) return;
-  if (until - state.recvMessageNumber > MAX_SKIP) {
-    throw new Error("Too many skipped messages");
-  }
-  while (state.recvMessageNumber < until) {
-    const { chainKey, messageKey } = kdfChainKey(state.recvChainKey);
-    state.recvChainKey = chainKey;
-    const skId = skippedKeyId(state.dhRecvPublicKey!, state.recvMessageNumber);
-    state.skippedKeys.set(skId, messageKey);
-    state.recvMessageNumber++;
-  }
-}
-
-function encodeHeader(header: RatchetHeader): Uint8Array {
-  const result = new Uint8Array(32 + 4 + 4);
-  result.set(header.publicKey);
-  const view = new DataView(result.buffer);
-  view.setUint32(32, header.previousChainLength, false);
-  view.setUint32(36, header.messageNumber, false);
-  return result;
-}
-
-function concat(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const result = new Uint8Array(a.length + b.length);
-  result.set(a);
-  result.set(b, a.length);
-  return result;
-}
-
-function uint8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}

package/src/signal/session.ts

@@ -1,189 +0,0 @@
-import { toBase64, fromBase64 } from "./crypto.js";
-import type { X25519KeyPair } from "./crypto.js";
-import { x3dhInitiate, x3dhRespond, buildAssociatedData } from "./x3dh.js";
-import type { X3DHBundle } from "./x3dh.js";
-import { ratchetEncrypt, ratchetDecrypt } from "./ratchet.js";
-import type { RatchetMessage, RatchetHeader } from "./ratchet.js";
-import type { SessionStore, SessionState } from "./store.js";
-import type { KeyBundle, MessageEnvelope, SignalMetadata } from "../types/index.js";
-
-export interface EncryptedMessage {
-  body: string;
-  type: "CIPHERTEXT" | "PREKEY_BUNDLE";
-  signal?: SignalMetadata;
-}
-
-export class SignalSession {
-  private readonly store: SessionStore;
-  private readonly ourIdentityPublicKey: Uint8Array;
-
-  constructor(store: SessionStore, ourIdentityPublicKey: Uint8Array) {
-    this.store = store;
-    this.ourIdentityPublicKey = ourIdentityPublicKey;
-  }
-
-  async encrypt(
-    recipientAddress: string,
-    recipientIdentityKey: Uint8Array,
-    plaintext: Uint8Array,
-    recipientBundle?: KeyBundle,
-  ): Promise<EncryptedMessage> {
-    let session = await this.store.getSession(recipientAddress);
-    let isPreKeyMessage = false;
-    let ephemeralPublicKey: Uint8Array | undefined;
-    let signedPreKeyId: string | undefined;
-    let oneTimePreKeyId: string | undefined;
-
-    if (!session && recipientBundle) {
-      const bundle = parseKeyBundle(recipientBundle, recipientIdentityKey);
-      const identityKeyPair = await this.store.getIdentityX25519KeyPair();
-      const result = x3dhInitiate(identityKeyPair, bundle);
-      session = result.session;
-      ephemeralPublicKey = result.ephemeralPublicKey;
-      signedPreKeyId = result.signedPreKeyId;
-      oneTimePreKeyId = result.oneTimePreKeyId;
-      isPreKeyMessage = true;
-    }
-
-    if (!session) {
-      throw new Error(
-        `No session for ${recipientAddress}. Provide a key bundle for initial message.`,
-      );
-    }
-
-    const associatedData = buildAssociatedData(
-      this.ourIdentityPublicKey,
-      recipientIdentityKey,
-    );
-    const message = await ratchetEncrypt(session, plaintext, associatedData);
-    await this.store.storeSession(recipientAddress, session);
-
-    const signal = buildSignalMetadata(message.header, ephemeralPublicKey, signedPreKeyId, oneTimePreKeyId);
-
-    return {
-      body: toBase64(message.ciphertext),
-      type: isPreKeyMessage ? "PREKEY_BUNDLE" : "CIPHERTEXT",
-      signal,
-    };
-  }
-
-  async decrypt(
-    senderAddress: string,
-    senderIdentityKey: Uint8Array,
-    envelope: MessageEnvelope,
-  ): Promise<Uint8Array> {
-    let session = await this.store.getSession(senderAddress);
-    const ciphertext = fromBase64(envelope.body);
-
-    if (envelope.type === "PREKEY_BUNDLE" && envelope.signal) {
-      session = await this.processPreKeyMessage(
-        senderIdentityKey,
-        envelope.signal,
-      );
-    }
-
-    if (!session) {
-      throw new Error(`No session for ${senderAddress}`);
-    }
-
-    const header = parseSignalHeader(envelope.signal);
-    const associatedData = buildAssociatedData(
-      senderIdentityKey,
-      this.ourIdentityPublicKey,
-    );
-    const ratchetMessage: RatchetMessage = { header, ciphertext };
-    const plaintext = await ratchetDecrypt(session, ratchetMessage, associatedData);
-    await this.store.storeSession(senderAddress, session);
-
-    return plaintext;
-  }
-
-  private async processPreKeyMessage(
-    senderIdentityKey: Uint8Array,
-    signal: SignalMetadata,
-  ): Promise<SessionState> {
-    const identityKeyPair = await this.store.getIdentityX25519KeyPair();
-    const signedPreKey = await this.store.getSignedPreKey(signal.signedPreKeyId!);
-    if (!signedPreKey) {
-      throw new Error(`Signed pre-key ${signal.signedPreKeyId} not found`);
-    }
-
-    let oneTimePreKeyPair: X25519KeyPair | undefined;
-    if (signal.oneTimePreKeyId) {
-      const oneTimePreKey = await this.store.getPreKey(signal.oneTimePreKeyId);
-      if (oneTimePreKey) {
-        oneTimePreKeyPair = oneTimePreKey.keyPair;
-        await this.store.removePreKey(signal.oneTimePreKeyId);
-      }
-    }
-
-    const ephemeralKey = fromBase64(signal.ephemeralKey!);
-
-    return x3dhRespond(
-      identityKeyPair,
-      signedPreKey.keyPair,
-      senderIdentityKey,
-      ephemeralKey,
-      oneTimePreKeyPair,
-    );
-  }
-
-  async hasSession(address: string): Promise<boolean> {
-    const session = await this.store.getSession(address);
-    return session !== null;
-  }
-
-  async removeSession(address: string): Promise<void> {
-    await this.store.removeSession(address);
-  }
-}
-
-function parseKeyBundle(
-  bundle: KeyBundle,
-  recipientX25519IdentityKey: Uint8Array,
-): X3DHBundle {
-  const result: X3DHBundle = {
-    identityKey: recipientX25519IdentityKey,
-    signedPreKeyId: bundle.signedPreKey.keyId,
-    signedPreKey: fromBase64(bundle.signedPreKey.publicKey),
-  };
-  if (bundle.oneTimePreKey) {
-    result.oneTimePreKeyId = bundle.oneTimePreKey.keyId;
-    result.oneTimePreKey = fromBase64(bundle.oneTimePreKey.publicKey);
-  }
-  return result;
-}
-
-function buildSignalMetadata(
-  header: RatchetHeader,
-  ephemeralPublicKey?: Uint8Array,
-  signedPreKeyId?: string,
-  oneTimePreKeyId?: string,
-): SignalMetadata {
-  const signal: SignalMetadata = {
-    ratchetKey: toBase64(header.publicKey),
-    messageNumber: header.messageNumber,
-    previousChainLength: header.previousChainLength,
-  };
-  if (ephemeralPublicKey) {
-    signal.ephemeralKey = toBase64(ephemeralPublicKey);
-  }
-  if (signedPreKeyId) {
-    signal.signedPreKeyId = signedPreKeyId;
-  }
-  if (oneTimePreKeyId) {
-    signal.oneTimePreKeyId = oneTimePreKeyId;
-  }
-  return signal;
-}
-
-function parseSignalHeader(signal?: SignalMetadata): RatchetHeader {
-  if (!signal?.ratchetKey) {
-    throw new Error("Missing ratchet key in signal metadata");
-  }
-  return {
-    publicKey: fromBase64(signal.ratchetKey),
-    previousChainLength: signal.previousChainLength ?? 0,
-    messageNumber: signal.messageNumber ?? 0,
-  };
-}

package/src/signal/store.ts

@@ -1,49 +0,0 @@
-import type { X25519KeyPair } from "./crypto.js";
-
-export interface SessionState {
-  dhSendKeyPair: X25519KeyPair;
-  dhRecvPublicKey: Uint8Array | null;
-  rootKey: Uint8Array;
-  sendChainKey: Uint8Array | null;
-  recvChainKey: Uint8Array | null;
-  sendMessageNumber: number;
-  recvMessageNumber: number;
-  previousChainLength: number;
-  skippedKeys: Map<string, Uint8Array>;
-}
-
-export interface PreKeyPair {
-  keyId: string;
-  keyPair: X25519KeyPair;
-  signature: Uint8Array;
-}
-
-export interface SignedPreKeyPair {
-  keyId: string;
-  keyPair: X25519KeyPair;
-  signature: Uint8Array;
-}
-
-export interface SessionStore {
-  getIdentityX25519KeyPair(): Promise<X25519KeyPair>;
-  getSignedPreKey(keyId: string): Promise<SignedPreKeyPair | null>;
-  getActiveSignedPreKey(): Promise<SignedPreKeyPair>;
-  storeSignedPreKey(preKey: SignedPreKeyPair): Promise<void>;
-  getPreKey(keyId: string): Promise<PreKeyPair | null>;
-  removePreKey(keyId: string): Promise<void>;
-  storePreKey(preKey: PreKeyPair): Promise<void>;
-  getAllPreKeys(): Promise<Array<PreKeyPair>>;
-  getSession(address: string): Promise<SessionState | null>;
-  storeSession(address: string, session: SessionState): Promise<void>;
-  removeSession(address: string): Promise<void>;
-}
-
-export function skippedKeyId(
-  ratchetPublicKey: Uint8Array,
-  messageNumber: number,
-): string {
-  const hex = Array.from(ratchetPublicKey)
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-  return `${hex}:${messageNumber}`;
-}

package/src/signal/x3dh.ts

@@ -1,130 +0,0 @@
-import { hkdf } from "@noble/hashes/hkdf.js";
-import { sha256 } from "@noble/hashes/sha2.js";
-import {
-  generateX25519KeyPair,
-  x25519SharedSecret,
-  toBase64,
-} from "./crypto.js";
-import type { X25519KeyPair } from "./crypto.js";
-import type { SessionState } from "./store.js";
-
-const X3DH_INFO = new TextEncoder().encode("WhisperText");
-const PADDING = new Uint8Array(32).fill(0xff);
-
-export interface X3DHBundle {
-  identityKey: Uint8Array;
-  signedPreKeyId: string;
-  signedPreKey: Uint8Array;
-  oneTimePreKeyId?: string;
-  oneTimePreKey?: Uint8Array;
-}
-
-export interface X3DHInitResult {
-  session: SessionState;
-  ephemeralPublicKey: Uint8Array;
-  signedPreKeyId: string;
-  oneTimePreKeyId?: string;
-}
-
-export function x3dhInitiate(
-  ourIdentityKeyPair: X25519KeyPair,
-  theirBundle: X3DHBundle,
-): X3DHInitResult {
-  const ephemeral = generateX25519KeyPair();
-
-  // DH1: our identity <-> their signed pre-key
-  const dh1 = x25519SharedSecret(ourIdentityKeyPair.privateKey, theirBundle.signedPreKey);
-  // DH2: our ephemeral <-> their identity
-  const dh2 = x25519SharedSecret(ephemeral.privateKey, theirBundle.identityKey);
-  // DH3: our ephemeral <-> their signed pre-key
-  const dh3 = x25519SharedSecret(ephemeral.privateKey, theirBundle.signedPreKey);
-
-  let dhConcat: Uint8Array;
-  if (theirBundle.oneTimePreKey) {
-    // DH4: our ephemeral <-> their one-time pre-key
-    const dh4 = x25519SharedSecret(ephemeral.privateKey, theirBundle.oneTimePreKey);
-    dhConcat = concat(PADDING, dh1, dh2, dh3, dh4);
-  } else {
-    dhConcat = concat(PADDING, dh1, dh2, dh3);
-  }
-
-  const sharedSecret = hkdf(sha256, dhConcat, new Uint8Array(32), X3DH_INFO, 32);
-
-  const sendKeyPair = generateX25519KeyPair();
-  const session: SessionState = {
-    dhSendKeyPair: sendKeyPair,
-    dhRecvPublicKey: theirBundle.signedPreKey,
-    rootKey: sharedSecret,
-    sendChainKey: null,
-    recvChainKey: null,
-    sendMessageNumber: 0,
-    recvMessageNumber: 0,
-    previousChainLength: 0,
-    skippedKeys: new Map(),
-  };
-
-  return {
-    session,
-    ephemeralPublicKey: ephemeral.publicKey,
-    signedPreKeyId: theirBundle.signedPreKeyId,
-    oneTimePreKeyId: theirBundle.oneTimePreKeyId,
-  };
-}
-
-export function x3dhRespond(
-  ourIdentityKeyPair: X25519KeyPair,
-  ourSignedPreKeyPair: X25519KeyPair,
-  theirIdentityKey: Uint8Array,
-  theirEphemeralKey: Uint8Array,
-  ourOneTimePreKeyPair?: X25519KeyPair,
-): SessionState {
-  // DH1: their identity <-> our signed pre-key
-  const dh1 = x25519SharedSecret(ourSignedPreKeyPair.privateKey, theirIdentityKey);
-  // DH2: their ephemeral <-> our identity
-  const dh2 = x25519SharedSecret(ourIdentityKeyPair.privateKey, theirEphemeralKey);
-  // DH3: their ephemeral <-> our signed pre-key
-  const dh3 = x25519SharedSecret(ourSignedPreKeyPair.privateKey, theirEphemeralKey);
-
-  let dhConcat: Uint8Array;
-  if (ourOneTimePreKeyPair) {
-    const dh4 = x25519SharedSecret(ourOneTimePreKeyPair.privateKey, theirEphemeralKey);
-    dhConcat = concat(PADDING, dh1, dh2, dh3, dh4);
-  } else {
-    dhConcat = concat(PADDING, dh1, dh2, dh3);
-  }
-
-  const sharedSecret = hkdf(sha256, dhConcat, new Uint8Array(32), X3DH_INFO, 32);
-
-  return {
-    dhSendKeyPair: ourSignedPreKeyPair,
-    dhRecvPublicKey: null,
-    rootKey: sharedSecret,
-    sendChainKey: null,
-    recvChainKey: null,
-    sendMessageNumber: 0,
-    recvMessageNumber: 0,
-    previousChainLength: 0,
-    skippedKeys: new Map(),
-  };
-}
-
-export function buildAssociatedData(
-  senderIdentityKey: Uint8Array,
-  recipientIdentityKey: Uint8Array,
-): Uint8Array {
-  return concat(senderIdentityKey, recipientIdentityKey);
-}
-
-function concat(...arrays: Array<Uint8Array>): Uint8Array {
-  let totalLength = 0;
-  for (const array of arrays) {
-    totalLength += array.length;
-  }
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const array of arrays) {
-    result.set(array, offset);
-    offset += array.length;
-  }
-  return result;
-}

package/src/signer.ts

@@ -1,21 +0,0 @@
-import type { SigningKey } from "./auth.js";
-import type { X25519KeyPair } from "./signal/crypto.js";
-
-/**
- * Abstract base for all signing strategies. Subclass this to plug in
- * remote wallets (e.g. OpenHuman), HSMs, or any API-based signer.
- */
-export abstract class Signer implements SigningKey {
-  abstract readonly agentId: string;
-  abstract readonly publicKeyBase64: string;
-
-  abstract sign(data: Uint8Array): Promise<Uint8Array> | Uint8Array;
-
-  // Derive X25519 key pair for Signal Protocol key agreement.
-  // Ed25519 identity keys are converted to X25519 for ECDH.
-  abstract getX25519KeyPair(): Promise<X25519KeyPair>;
-
-  toSigningKey(): SigningKey {
-    return this;
-  }
-}

package/src/types/broadcasts.ts

@@ -1,81 +0,0 @@
-export type BroadcastVisibility = "public" | "unlisted";
-export type BroadcastEncryption = "none" | "envelope";
-export type BroadcastPaymentType = "free" | "subscription" | "per-message";
-
-export interface BroadcastSubscriptionPrice {
-  amount: string;
-  asset: string;
-  network: string;
-  interval: string;
-}
-
-export interface BroadcastPaymentPolicy {
-  type: BroadcastPaymentType;
-  subscription?: BroadcastSubscriptionPrice;
-}
-
-export interface BroadcastChannel {
-  broadcastId: string;
-  name: string;
-  description?: string;
-  owner: string;
-  ownerCryptoId?: string;
-  publishers: Array<string>;
-  subscriberCount: number;
-  tags?: Array<string>;
-  visibility: BroadcastVisibility;
-  encryption: BroadcastEncryption;
-  paymentPolicy?: BroadcastPaymentPolicy;
-  keyVersion?: number;
-  keyRotatedAt?: string;
-  createdAt: string;
-  updatedAt: string;
-  lastActivityAt?: string;
-  closedAt?: string;
-}
-
-export interface BroadcastQueryParams {
-  q?: string;
-  tag?: string;
-  tags?: Array<string>;
-  owner?: string;
-  visibility?: BroadcastVisibility;
-  paymentType?: BroadcastPaymentType;
-  sort?: string;
-  limit?: number;
-}
-
-export interface BroadcastSubscriber {
-  broadcastId: string;
-  agentId: string;
-  subscribedAt: string;
-  status: string;
-  paymentScheme?: string;
-  paymentNetwork?: string;
-  paymentAsset?: string;
-  paymentAmount?: string;
-  paymentInterval?: string;
-  paymentExpiresAt?: string;
-  nextPaymentAt?: string;
-}
-
-export interface BroadcastMessage {
-  messageId: string;
-  broadcastId: string;
-  publisher: string;
-  timestamp: string;
-  contentType: string;
-  body: string;
-  sequence: number;
-  deletedAt?: string;
-}
-
-export interface BroadcastCreateRequest {
-  name: string;
-  description?: string;
-  tags?: Array<string>;
-  visibility?: BroadcastVisibility;
-  encryption?: BroadcastEncryption;
-  paymentPolicy?: BroadcastPaymentPolicy;
-  signature?: string;
-}