@zi2/relay-sdk 1.0.0

package/dist/adapters/prisma-adapter.d.ts

@@ -0,0 +1,57 @@
+import { D as DatabaseAdapter, P as PhoneRelayRecord, c as CreateRelayInput, d as PhoneRelayPairingRecord, e as CreatePairingInput, R as RelayMessageRecord, f as CreateMessageInput } from '../types-CPJUrmcy.js';
+import 'ws';
+
+/**
+ * Generic Prisma-like client type — avoids a hard dependency on @prisma/client.
+ * Any ORM / query-builder that exposes the same delegate shape will work.
+ */
+type PrismaDelegate = {
+    findUnique(args: any): Promise<any>;
+    findFirst(args: any): Promise<any>;
+    findMany(args: any): Promise<any>;
+    create(args: any): Promise<any>;
+    update(args: any): Promise<any>;
+    updateMany(args: any): Promise<any>;
+    delete(args: any): Promise<any>;
+    deleteMany(args: any): Promise<any>;
+    count(args?: any): Promise<number>;
+};
+type PrismaLike = {
+    phoneRelay: PrismaDelegate;
+    phoneRelayPairing: PrismaDelegate;
+    relayMessageQueue: PrismaDelegate;
+    $transaction?: (ops: Promise<any>[]) => Promise<any[]>;
+};
+declare class PrismaAdapter implements DatabaseAdapter {
+    private prisma;
+    constructor(prisma: PrismaLike);
+    findRelay(id: string, orgId?: string): Promise<PhoneRelayRecord | null>;
+    findRelayByTokenHash(id: string, tokenHash: string, statuses: string[]): Promise<PhoneRelayRecord | null>;
+    findRelays(orgId: string, excludeStatus?: string): Promise<PhoneRelayRecord[]>;
+    createRelay(data: CreateRelayInput): Promise<PhoneRelayRecord>;
+    updateRelay(id: string, data: Partial<PhoneRelayRecord>): Promise<void>;
+    updateRelayByOrg(id: string, orgId: string, data: Partial<PhoneRelayRecord>): Promise<void>;
+    deleteRelay(id: string): Promise<void>;
+    incrementRelayStat(id: string, field: 'totalSmsSent' | 'totalSmsFailed' | 'dailySmsSent', amount?: number): Promise<void>;
+    countRelays(orgId: string): Promise<number>;
+    markDegradedRelays(threshold: Date): Promise<number>;
+    resetDailyCounters(): Promise<number>;
+    findPairing(id: string): Promise<PhoneRelayPairingRecord | null>;
+    createPairing(data: CreatePairingInput): Promise<PhoneRelayPairingRecord>;
+    updatePairingStatus(id: string, status: string): Promise<void>;
+    deleteExpiredPairings(): Promise<number>;
+    findMessage(id: string): Promise<RelayMessageRecord | null>;
+    createMessage(data: CreateMessageInput): Promise<RelayMessageRecord>;
+    updateMessage(id: string, data: Partial<RelayMessageRecord>): Promise<void>;
+    findPendingMessages(relayId: string, limit: number): Promise<RelayMessageRecord[]>;
+    findMessages(relayId: string, limit: number, offset: number): Promise<{
+        messages: RelayMessageRecord[];
+        total: number;
+    }>;
+    deleteMessagesByRelay(relayId: string): Promise<number>;
+    expireStaleMessages(): Promise<number>;
+    createMessages(batch: CreateMessageInput[]): Promise<RelayMessageRecord[]>;
+    updateMessages(ids: string[], data: Partial<RelayMessageRecord>): Promise<number>;
+}
+
+export { PrismaAdapter, type PrismaLike };

package/dist/adapters/prisma-adapter.js

@@ -0,0 +1,181 @@
+// src/constants.ts
+var RELAY_STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  REVOKED: "revoked",
+  DEGRADED: "degraded"
+};
+var RELAY_LIMITS = {
+  AUTH_TIMEOUT_MS: 5e3,
+  HEARTBEAT_INTERVAL_MS: 3e4,
+  PAIRING_EXPIRY_MINUTES: 5,
+  MESSAGE_EXPIRY_HOURS: 24,
+  QUEUE_DRAIN_DELAY_MS: 3e3,
+  DEFAULT_SMS_TIMEOUT_MS: 3e4,
+  MAX_SMS_PER_MINUTE: 20,
+  MAX_SMS_PER_HOUR: 200,
+  MAX_SMS_PER_DAY: 1e3,
+  DEGRADED_THRESHOLD_MS: 5 * 60 * 1e3
+};
+
+// src/adapters/prisma-adapter.ts
+var PrismaAdapter = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  // ── PhoneRelay CRUD ─────────────────────────────────────────────────
+  async findRelay(id, orgId) {
+    if (orgId) {
+      return this.prisma.phoneRelay.findFirst({ where: { id, organizationId: orgId } });
+    }
+    return this.prisma.phoneRelay.findUnique({ where: { id } });
+  }
+  async findRelayByTokenHash(id, tokenHash, statuses) {
+    return this.prisma.phoneRelay.findFirst({
+      where: {
+        id,
+        authTokenHash: tokenHash,
+        status: { in: statuses }
+      }
+    });
+  }
+  async findRelays(orgId, excludeStatus) {
+    const where = { organizationId: orgId };
+    if (excludeStatus) {
+      where.status = { not: excludeStatus };
+    }
+    return this.prisma.phoneRelay.findMany({
+      where,
+      orderBy: { createdAt: "desc" }
+    });
+  }
+  async createRelay(data) {
+    return this.prisma.phoneRelay.create({ data });
+  }
+  async updateRelay(id, data) {
+    await this.prisma.phoneRelay.update({ where: { id }, data });
+  }
+  async updateRelayByOrg(id, orgId, data) {
+    await this.prisma.phoneRelay.updateMany({
+      where: { id, organizationId: orgId },
+      data
+    });
+  }
+  async deleteRelay(id) {
+    await this.prisma.phoneRelay.delete({ where: { id } });
+  }
+  async incrementRelayStat(id, field, amount = 1) {
+    await this.prisma.phoneRelay.update({
+      where: { id },
+      data: { [field]: { increment: amount } }
+    });
+  }
+  async countRelays(orgId) {
+    return this.prisma.phoneRelay.count({
+      where: { organizationId: orgId, status: { not: RELAY_STATUS.REVOKED } }
+    });
+  }
+  async markDegradedRelays(threshold) {
+    const result = await this.prisma.phoneRelay.updateMany({
+      where: {
+        status: RELAY_STATUS.ACTIVE,
+        lastSeenAt: { lt: threshold }
+      },
+      data: { status: RELAY_STATUS.DEGRADED }
+    });
+    return result.count;
+  }
+  async resetDailyCounters() {
+    const result = await this.prisma.phoneRelay.updateMany({
+      where: {
+        status: { in: [RELAY_STATUS.ACTIVE, RELAY_STATUS.DEGRADED] }
+      },
+      data: { dailySmsSent: 0, dailyResetAt: /* @__PURE__ */ new Date() }
+    });
+    return result.count;
+  }
+  // ── PhoneRelayPairing ───────────────────────────────────────────────
+  async findPairing(id) {
+    return this.prisma.phoneRelayPairing.findUnique({ where: { id } });
+  }
+  async createPairing(data) {
+    return this.prisma.phoneRelayPairing.create({ data });
+  }
+  async updatePairingStatus(id, status) {
+    await this.prisma.phoneRelayPairing.update({ where: { id }, data: { status } });
+  }
+  async deleteExpiredPairings() {
+    const result = await this.prisma.phoneRelayPairing.deleteMany({
+      where: { expiresAt: { lt: /* @__PURE__ */ new Date() }, status: "pending" }
+    });
+    return result.count;
+  }
+  // ── RelayMessageQueue ───────────────────────────────────────────────
+  async findMessage(id) {
+    return this.prisma.relayMessageQueue.findUnique({ where: { id } });
+  }
+  async createMessage(data) {
+    return this.prisma.relayMessageQueue.create({ data });
+  }
+  async updateMessage(id, data) {
+    await this.prisma.relayMessageQueue.update({ where: { id }, data });
+  }
+  async findPendingMessages(relayId, limit) {
+    return this.prisma.relayMessageQueue.findMany({
+      where: {
+        relayId,
+        status: "pending",
+        expiresAt: { gt: /* @__PURE__ */ new Date() }
+      },
+      orderBy: { createdAt: "asc" },
+      take: limit
+    });
+  }
+  async findMessages(relayId, limit, offset) {
+    const [messages, total] = await Promise.all([
+      this.prisma.relayMessageQueue.findMany({
+        where: { relayId },
+        orderBy: { createdAt: "desc" },
+        take: limit,
+        skip: offset
+      }),
+      this.prisma.relayMessageQueue.count({ where: { relayId } })
+    ]);
+    return { messages, total };
+  }
+  async deleteMessagesByRelay(relayId) {
+    const result = await this.prisma.relayMessageQueue.deleteMany({
+      where: { relayId }
+    });
+    return result.count;
+  }
+  async expireStaleMessages() {
+    const result = await this.prisma.relayMessageQueue.updateMany({
+      where: {
+        expiresAt: { lt: /* @__PURE__ */ new Date() },
+        status: { in: ["pending", "sent_to_device"] }
+      },
+      data: { status: "expired" }
+    });
+    return result.count;
+  }
+  // ── Batch operations ────────────────────────────────────────────────
+  async createMessages(batch) {
+    if (this.prisma.$transaction) {
+      return this.prisma.$transaction(
+        batch.map((data) => this.prisma.relayMessageQueue.create({ data }))
+      );
+    }
+    return Promise.all(batch.map((data) => this.prisma.relayMessageQueue.create({ data })));
+  }
+  async updateMessages(ids, data) {
+    const result = await this.prisma.relayMessageQueue.updateMany({
+      where: { id: { in: ids } },
+      data
+    });
+    return result.count;
+  }
+};
+export {
+  PrismaAdapter
+};

package/dist/client/index.d.ts

@@ -0,0 +1,63 @@
+type MessageHandler = (message: any) => void;
+declare class ReconnectingWebSocket {
+    private ws;
+    private url;
+    private relayId;
+    private authToken;
+    private onMessage;
+    private onStateChange;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private reconnectTimer;
+    private intentionallyClosed;
+    constructor(options: {
+        url: string;
+        relayId: string;
+        authToken: string;
+        onMessage: MessageHandler;
+        onStateChange: (state: 'connecting' | 'connected' | 'disconnected') => void;
+    });
+    connect(): void;
+    private scheduleReconnect;
+    send(data: any): void;
+    close(): void;
+}
+
+declare function generateX25519KeyPair(): Promise<{
+    publicKey: string;
+    privateKey: string;
+}>;
+declare function deriveSharedKey(privateKeyHex: string, serverPublicKeySpkiHex: string): Promise<string>;
+declare function decryptE2E(ciphertext: string, sharedKeyHex: string): Promise<string>;
+declare function encryptE2E(plaintext: string, sharedKeyHex: string): Promise<string>;
+
+interface QrPayload {
+    v: number;
+    pid: string;
+    spk: string;
+    pt: string;
+    url: string;
+}
+declare function parseQrPayload(data: string): QrPayload;
+declare function completePairing(qr: QrPayload, deviceName: string, platform: string, phoneNumber?: string): Promise<any>;
+
+declare function requestSmsPermission(): Promise<boolean>;
+declare function sendNativeSms(to: string, body: string): Promise<boolean>;
+
+declare function getStoredCredentials(): Promise<{
+    relayId: string;
+    authToken: string;
+    sharedKey: string;
+    serverUrl: string;
+} | null>;
+declare function storeCredentials(creds: {
+    relayId: string;
+    authToken: string;
+    sharedKey: string;
+    serverUrl: string;
+}): Promise<void>;
+declare function storeDevicePrivateKey(key: string): Promise<void>;
+declare function getDevicePrivateKey(): Promise<string | null>;
+declare function clearAllData(): Promise<void>;
+
+export { ReconnectingWebSocket, clearAllData, completePairing, decryptE2E, deriveSharedKey, encryptE2E, generateX25519KeyPair, getDevicePrivateKey, getStoredCredentials, parseQrPayload, requestSmsPermission, sendNativeSms, storeCredentials, storeDevicePrivateKey };

package/dist/client/index.js

@@ -0,0 +1,298 @@
+// src/constants.ts
+var RELAY_MESSAGE_TYPES = {
+  AUTH: "auth",
+  SEND_SMS: "send_sms",
+  SMS_ACK: "sms_ack",
+  DELIVERY_RECEIPT: "delivery_receipt",
+  PONG: "pong",
+  STATUS: "status",
+  REKEY: "rekey",
+  REKEY_ACK: "rekey_ack"
+};
+var RELAY_LIMITS = {
+  AUTH_TIMEOUT_MS: 5e3,
+  HEARTBEAT_INTERVAL_MS: 3e4,
+  PAIRING_EXPIRY_MINUTES: 5,
+  MESSAGE_EXPIRY_HOURS: 24,
+  QUEUE_DRAIN_DELAY_MS: 3e3,
+  DEFAULT_SMS_TIMEOUT_MS: 3e4,
+  MAX_SMS_PER_MINUTE: 20,
+  MAX_SMS_PER_HOUR: 200,
+  MAX_SMS_PER_DAY: 1e3,
+  DEGRADED_THRESHOLD_MS: 5 * 60 * 1e3
+};
+
+// src/client/websocket-client.ts
+var ReconnectingWebSocket = class {
+  ws = null;
+  url;
+  relayId;
+  authToken;
+  onMessage;
+  onStateChange;
+  reconnectDelay = 1e3;
+  maxReconnectDelay = 6e4;
+  reconnectTimer = null;
+  intentionallyClosed = false;
+  constructor(options) {
+    this.url = options.url;
+    this.relayId = options.relayId;
+    this.authToken = options.authToken;
+    this.onMessage = options.onMessage;
+    this.onStateChange = options.onStateChange;
+  }
+  connect() {
+    this.intentionallyClosed = false;
+    this.onStateChange("connecting");
+    try {
+      this.ws = new WebSocket(this.url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this.reconnectDelay = 1e3;
+      this.ws?.send(JSON.stringify({
+        type: RELAY_MESSAGE_TYPES.AUTH,
+        relayId: this.relayId,
+        token: this.authToken,
+        ts: Date.now()
+      }));
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message.type === "auth_ok") {
+          this.onStateChange("connected");
+        }
+        this.onMessage(message);
+      } catch {
+      }
+    };
+    this.ws.onclose = () => {
+      this.onStateChange("disconnected");
+      if (!this.intentionallyClosed) {
+        this.scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  scheduleReconnect() {
+    if (this.intentionallyClosed) return;
+    const jitter = this.reconnectDelay * (0.8 + Math.random() * 0.4);
+    this.reconnectTimer = setTimeout(() => this.connect(), jitter);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  close() {
+    this.intentionallyClosed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.ws?.close();
+  }
+};
+
+// src/client/e2e-crypto.ts
+var E2E_HKDF_INFO = "zi2-relay-e2e-v1";
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function generateX25519KeyPair() {
+  const keyPair = await crypto.subtle.generateKey({ name: "X25519" }, true, ["deriveBits"]);
+  const publicRaw = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+  const privateRaw = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+  return {
+    publicKey: bytesToHex(new Uint8Array(publicRaw)),
+    privateKey: bytesToHex(new Uint8Array(privateRaw))
+  };
+}
+async function deriveSharedKey(privateKeyHex, serverPublicKeySpkiHex) {
+  const privateKeyBytes = hexToBytes(privateKeyHex);
+  const privateKey = await crypto.subtle.importKey("pkcs8", privateKeyBytes.buffer, { name: "X25519" }, false, ["deriveBits"]);
+  const publicKeyBytes = hexToBytes(serverPublicKeySpkiHex);
+  const publicKey = await crypto.subtle.importKey("spki", publicKeyBytes.buffer, { name: "X25519" }, false, []);
+  const sharedSecret = await crypto.subtle.deriveBits({ name: "X25519", public: publicKey }, privateKey, 256);
+  const hkdfKey = await crypto.subtle.importKey("raw", sharedSecret, { name: "HKDF" }, false, ["deriveBits"]);
+  const infoBytes = new TextEncoder().encode(E2E_HKDF_INFO);
+  const derivedBits = await crypto.subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0).buffer, info: infoBytes.buffer },
+    hkdfKey,
+    256
+  );
+  return bytesToHex(new Uint8Array(derivedBits));
+}
+async function decryptE2E(ciphertext, sharedKeyHex) {
+  const [ivHex, authTagHex, encryptedHex] = ciphertext.split(":");
+  if (!ivHex || !authTagHex || !encryptedHex) throw new Error("Invalid ciphertext format");
+  const iv = hexToBytes(ivHex);
+  const authTag = hexToBytes(authTagHex);
+  const encrypted = hexToBytes(encryptedHex);
+  const combined = new Uint8Array(encrypted.length + authTag.length);
+  combined.set(encrypted);
+  combined.set(authTag, encrypted.length);
+  const keyBytes = hexToBytes(sharedKeyHex);
+  const key = await crypto.subtle.importKey("raw", keyBytes.buffer, { name: "AES-GCM" }, false, ["decrypt"]);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.buffer }, key, combined.buffer);
+  return new TextDecoder().decode(decrypted);
+}
+async function encryptE2E(plaintext, sharedKeyHex) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const keyBytes = hexToBytes(sharedKeyHex);
+  const key = await crypto.subtle.importKey("raw", keyBytes.buffer, { name: "AES-GCM" }, false, ["encrypt"]);
+  const plaintextBytes = new TextEncoder().encode(plaintext);
+  const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer, tagLength: 128 }, key, plaintextBytes.buffer);
+  const encryptedBytes = new Uint8Array(encrypted);
+  const cipherBytes = encryptedBytes.slice(0, encryptedBytes.length - 16);
+  const tagBytes = encryptedBytes.slice(encryptedBytes.length - 16);
+  return `${bytesToHex(iv)}:${bytesToHex(tagBytes)}:${bytesToHex(cipherBytes)}`;
+}
+
+// src/client/secure-storage.ts
+import { Preferences } from "@capacitor/preferences";
+var KEYS = {
+  RELAY_ID: "zi2_relay_id",
+  AUTH_TOKEN: "zi2_auth_token",
+  SHARED_KEY: "zi2_shared_key",
+  SERVER_URL: "zi2_server_url",
+  DEVICE_PRIVATE_KEY: "zi2_device_private_key"
+};
+async function getStoredCredentials() {
+  const [relayId, authToken, sharedKey, serverUrl] = await Promise.all([
+    Preferences.get({ key: KEYS.RELAY_ID }),
+    Preferences.get({ key: KEYS.AUTH_TOKEN }),
+    Preferences.get({ key: KEYS.SHARED_KEY }),
+    Preferences.get({ key: KEYS.SERVER_URL })
+  ]);
+  if (!relayId.value || !authToken.value || !sharedKey.value || !serverUrl.value) return null;
+  return {
+    relayId: relayId.value,
+    authToken: authToken.value,
+    sharedKey: sharedKey.value,
+    serverUrl: serverUrl.value
+  };
+}
+async function storeCredentials(creds) {
+  await Promise.all([
+    Preferences.set({ key: KEYS.RELAY_ID, value: creds.relayId }),
+    Preferences.set({ key: KEYS.AUTH_TOKEN, value: creds.authToken }),
+    Preferences.set({ key: KEYS.SHARED_KEY, value: creds.sharedKey }),
+    Preferences.set({ key: KEYS.SERVER_URL, value: creds.serverUrl })
+  ]);
+}
+async function storeDevicePrivateKey(key) {
+  await Preferences.set({ key: KEYS.DEVICE_PRIVATE_KEY, value: key });
+}
+async function getDevicePrivateKey() {
+  const result = await Preferences.get({ key: KEYS.DEVICE_PRIVATE_KEY });
+  return result.value;
+}
+async function clearAllData() {
+  await Preferences.clear();
+}
+
+// src/client/pairing.ts
+function parseQrPayload(data) {
+  const parsed = JSON.parse(data);
+  if (parsed.v !== 1) throw new Error("Unsupported QR version");
+  if (!parsed.pid || !parsed.spk || !parsed.pt || !parsed.url) throw new Error("Invalid QR data");
+  return parsed;
+}
+async function completePairing(qr, deviceName, platform, phoneNumber) {
+  console.log("[Pairing] Starting pairing...");
+  console.log("[Pairing] QR url:", qr.url);
+  const keyPair = await generateX25519KeyPair();
+  console.log("[Pairing] Generated keypair, publicKey length:", keyPair.publicKey.length);
+  await storeDevicePrivateKey(keyPair.privateKey);
+  console.log("[Pairing] Deriving shared key from server public key:", qr.spk.substring(0, 20) + "...");
+  const sharedKey = await deriveSharedKey(keyPair.privateKey, qr.spk);
+  console.log("[Pairing] Shared key derived, length:", sharedKey.length);
+  const wsUrl = new URL(qr.url);
+  const apiBase = `${wsUrl.protocol === "wss:" ? "https" : "http"}://${wsUrl.host}`;
+  const endpoint = `${apiBase}/api/v1/phone-relay/pair/complete`;
+  console.log("[Pairing] POST to:", endpoint);
+  const body = {
+    pairingId: qr.pid,
+    pairingToken: qr.pt,
+    devicePublicKey: keyPair.publicKey,
+    deviceName,
+    platform,
+    phoneNumber
+  };
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  console.log("[Pairing] Response status:", response.status);
+  if (!response.ok) {
+    const errorText = await response.text();
+    console.error("[Pairing] Error response:", errorText);
+    let errorMsg = "Pairing failed";
+    try {
+      const errorJson = JSON.parse(errorText);
+      errorMsg = errorJson?.error?.message || errorJson?.message || errorMsg;
+    } catch {
+    }
+    throw new Error(`${errorMsg} (HTTP ${response.status})`);
+  }
+  const result = await response.json();
+  console.log("[Pairing] Success, relayId:", result?.data?.relayId);
+  await storeCredentials({
+    relayId: result.data.relayId,
+    authToken: result.data.authToken,
+    sharedKey,
+    serverUrl: qr.url
+  });
+  return result.data;
+}
+
+// src/client/sms-sender.ts
+import { registerPlugin } from "@capacitor/core";
+var Sms = registerPlugin("Sms");
+async function requestSmsPermission() {
+  try {
+    const check = await Sms.checkPermissions();
+    if (check.sms === "granted") return true;
+    const result = await Sms.requestPermissions();
+    return result.sms === "granted";
+  } catch (err) {
+    console.error("SMS permission request failed:", err);
+    return false;
+  }
+}
+async function sendNativeSms(to, body) {
+  try {
+    const result = await Sms.send({ to, body });
+    return result.sent;
+  } catch (err) {
+    console.error("Native SMS send failed:", err);
+    return false;
+  }
+}
+export {
+  ReconnectingWebSocket,
+  clearAllData,
+  completePairing,
+  decryptE2E,
+  deriveSharedKey,
+  encryptE2E,
+  generateX25519KeyPair,
+  getDevicePrivateKey,
+  getStoredCredentials,
+  parseQrPayload,
+  requestSmsPermission,
+  sendNativeSms,
+  storeCredentials,
+  storeDevicePrivateKey
+};