feat: SeedClient implemented

src/sdk/crypto/string-to-base64.ts → src/crypto/base-64.ts

@@ -1,7 +1,7 @@
 export function arrayBufferToBase64(buffer: ArrayBuffer) {
-  let binary = '';
-  let bytes = new Uint8Array(buffer);
-  let len = bytes.byteLength;
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  const len = bytes.byteLength;
   for (let i = 0; i < len; i++) {
     binary += String.fromCharCode(bytes[i]);
   }

src/sdk-v2/seed-client.test.ts

@@ -3,6 +3,23 @@ import { createSeedClient, SeedClient } from "./seed-client";
 import { randomAESKey } from "@/sdk/crypto/subtle-crypto";
 import { encryptContent } from "@/sdk/crypto/encrypt-content";
 
+test("seed-reconnect", async () => {
+  const client = connectClient();
+  await new Promise(resolve => setTimeout(resolve, 4_000));
+});
+
+test("seed-subscribe", async () => {
+  const client = connectClient();
+  client.subscribe(
+    "wss://meetacy.app/seed-go",
+    {
+      queueId: await randomAESKey(),
+      nonce: 0,
+    },
+  );
+  await new Promise(resolve => setTimeout(resolve, 4_000));
+});
+
 test("seed-client-send", async () => {
   const client = connectClient();
 
@@ -13,7 +30,11 @@ test("seed-client-send", async () => {
     key: await randomAESKey(),
   });
 
-  const result = await client.send(
+  await new Promise(resolve => setTimeout(resolve, 2_000));
+
+  console.log("After timeout");
+
+  const goResult = await client.send(
     "wss://meetacy.app/seed-go",
     {
       nonce: 0,
@@ -24,7 +45,53 @@ test("seed-client-send", async () => {
     },
   );
 
-  expect(result, "Message is not sent").toBe(true);
+  const ktResult = await client.send(
+    "wss://meetacy.app/seed-kt",
+    {
+      nonce: 0,
+      signature,
+      content,
+      contentIV,
+      queueId: chatId,
+    },
+  );
+
+  expect(goResult, "Message is not sent").toBe(true);
+  expect(ktResult, "Message is not sent").toBe(true);
+});
+
+test("subscribe-send-combination", async () => {
+  const client = connectClient();
+
+  const chatId = await randomAESKey();
+
+  const { content, contentIV, signature } = await encryptContent({
+    content: "Random Stuff in Here",
+    key: await randomAESKey(),
+  });
+
+
+  client.subscribe("wss://meetacy.app/seed-kt", {
+    queueId: chatId, nonce: 0,
+  });
+
+  const promise = new Promise<void>(resolve => {
+    const cancel = client.events.subscribe(event => {
+      if (event.type !== "new") return;
+      resolve();
+      cancel();
+    });
+  });
+
+  await client.send("wss://meetacy.app/seed-kt", {
+    nonce: 0,
+    signature,
+    content,
+    contentIV,
+    queueId: chatId,
+  });
+
+  await promise;
 });
 
 function connectClient(): SeedClient {

src/sdk-v2/seed-client.ts

@@ -8,7 +8,11 @@ export type SeedClientEvent = {
 } | {
   type: "new";
   url: string;
-  payload: SeedClientMessage;
+  message: SeedClientMessage;
+} | {
+  type: "wait";
+  url: string;
+  queueId: string;
 }
 
 export type SeedClientMessage = {
@@ -27,6 +31,11 @@ export type SeedClientSendOptions = {
   queueId: string;
 }
 
+export type SeedClientSubscribeOptions = {
+  queueId: string;
+  nonce: number;
+}
+
 /**
  * SeedClient hides all network errors and makes it seem 
  * to the consumer like if the connection was just slow. So no retries
@@ -38,8 +47,10 @@ export interface SeedClient {
   events: Observable<SeedClientEvent>;
 
   getConnected(): boolean;
+
   send(url: string, options: SeedClientSendOptions): Promise<boolean>;
-  subscribe(): Promise<void>;
+
+  subscribe(url: string, options: SeedClientSubscribeOptions): void;
 
   /**
    * SeedClient automatically manages connections
@@ -63,6 +74,14 @@ export interface CreateSeedClientOptions {
   };
 }
 
+type ServerEvent = {
+  type: "new";
+  message: SeedClientMessage;
+} | {
+  type: "wait";
+  queueId: string;
+}
+
 type SendRequest = {
   type: "send";
   message: SeedClientSendOptions;
@@ -72,13 +91,37 @@ type SendResponse = {
   status: boolean
 }
 
+type SubscribeRequest = {
+  type: "subscribe";
+  queueId: string;
+  nonce: number;
+}
+
 export function createSeedClient(
   { engine: engineOptions }: CreateSeedClientOptions,
 ): SeedClient {
   // TODO: proxy events
   const events: Observable<SeedClientEvent> = createObservable();
 
   const engine = createSeedEngine(engineOptions.mainUrl);
+  const subscribeChatIds: Set<string> = new Set();
+
+  engine.events.subscribe(event => {
+    switch (event.type) {
+      case "connected":
+        events.emit(event);
+        break;
+      case "server":
+        if (!typia.is<ServerEvent>(event.payload)) break;
+        events.emit({
+          url: event.url,
+          ...event.payload,
+        });
+        break;
+      default:
+        event.type satisfies "ready";
+    }
+  });
 
   function getConnected() {
     return engine.getReady();
@@ -99,6 +142,25 @@ export function createSeedClient(
     return response.status;
   }
 
+  function subscribe(url: string, { queueId, nonce }: SeedClientSubscribeOptions) {
+    if (subscribeChatIds.has(url)) {
+      throw new Error(`Already subscribed to this chat id ${queueId}`);
+    }
+    subscribeChatIds.add(url);
+    const request: SubscribeRequest = {
+      type: "subscribe",
+      queueId, nonce,
+    };
+    if (engine.getConnected(url)) {
+      void engine.executeOrThrow(url, request);
+    }
+    engine.events.subscribe(event => {
+      if (event.type !== "connected") return;
+      if (event.url !== url) return;
+      void engine.executeOrThrow(url, request);
+    });
+  }
+
   const servers: Set<string> = new Set();
 
   function addServer(url: string) {
@@ -112,7 +174,6 @@ export function createSeedClient(
       if (event.connected) {
         // TODO: Do initial subscribes, etc.
       } else {
-        console.log("CONNECT SAFELY", event);
         connectUrlSafely(engine, url);
       }
     });
@@ -143,6 +204,7 @@ export function createSeedClient(
     events,
     getConnected,
     send,
+    subscribe,
     addServer,
     setForeground,
   };

src/sdk-v2/seed-crypto.ts

@@ -0,0 +1,79 @@
+import { decryptAes256, encryptAes256, hmacSha256, verifyHmacSha256 } from "./crypto/subtle-crypto";
+
+export interface DecryptContentOptions {
+  content: string;
+  contentIV: string;
+  signature: string;
+  key: string;
+}
+
+export async function decryptContent({ content, contentIV, signature, key }: DecryptContentOptions): Promise<unknown> {
+  // Decrypt content
+  const decryptedJSON = await decryptAes256({
+    encrypted: content,
+    iv: contentIV,
+    key: key,
+  });
+
+  if (!decryptedJSON) {
+    return;
+  }
+
+  // Check that message-content is signed
+  const verify = await verifyHmacSha256({
+    data: "SIGNATURE:" + decryptedJSON.string,
+    key: key,
+    signature: signature,
+  });
+
+  if (!verify) {
+    return;
+  }
+
+  return JSON.parse(decryptedJSON.string);
+}
+
+export interface DeriveNextKeyOptions {
+  key: string;
+}
+
+export function deriveNextKey({ key }: DeriveNextKeyOptions): Promise<string> {
+  return hmacSha256({
+    data: "NEXT-KEY",
+    key: key,
+  });
+}
+
+export interface EncryptContentOptions {
+  content: unknown;
+  key: string;
+}
+
+export interface EncryptContentResult {
+  contentIV: string;
+  content: string;
+  signature: string;
+}
+
+export async function encryptContent(
+  { content, key }: EncryptContentOptions,
+): Promise<EncryptContentResult> {
+  const contentString = JSON.stringify(content);
+
+  const signature = await hmacSha256({
+    data: "SIGNATURE:" + contentString,
+    key: key,
+  });
+
+  const encryptedContent = await encryptAes256({
+    data: contentString,
+    key: key,
+  });
+
+  return {
+    contentIV: encryptedContent.iv,
+    content: encryptedContent.encrypted,
+    signature: signature,
+  };
+}
+

src/sdk-v2/seed-engine.ts

@@ -32,6 +32,11 @@ type ConnectRequest = {
   url: string;
 }
 
+type DisconnectedEvent = {
+  type: "disconnected";
+  url: string;
+}
+
 type SeedEngineReceivedMessage =
   SeedEngineForwardReceivedMessage |
   SeedEngineRawReceivedMessage
@@ -218,7 +223,6 @@ export function createSeedEngine(mainUrl: string): SeedEngine {
     };
 
     ws.onmessage = (message) => {
-      console.log("<<< debug", message.data);
       const data = JSON.parse(message.data as string) as SeedEngineReceivedMessage;
       if (!typia.is<SeedEngineReceivedMessage>(data)) {
         return;
@@ -242,13 +246,16 @@ export function createSeedEngine(mainUrl: string): SeedEngine {
         }
         const { resolve } = requests[index];
         requests.splice(index, 1);
-        console.log("FORWARD", forward);
         if (forward.forward.response) {
           resolve(forward.forward.response);
         } else {
           resolve(forward.forward);
         }
       } else {
+        if (typia.is<DisconnectedEvent>(forward.forward.event)) {
+          setConnectedUrl(forward.forward.event.url, false);
+          return;
+        }
         events.emit({
           type: "server",
           url: forward.url,

src/sdk/client/seed-client.ts

@@ -57,7 +57,7 @@ export function createSeedClient(
       return response.status;
     },
 
-    async subscribe({ queueId, nonce }): Promise<void> {
+    subscribe({ queueId, nonce }): Promise<void> {
       const request: SubscribeRequest = {
         type: "subscribe",
         chatId: queueId,