Merge pull request #83 from torusresearch/fix/build

Merge fix/build

Author: himanshuchawla009

packages/tss-client/src/client.ts

@@ -8,6 +8,7 @@ import type { Socket } from "socket.io-client";
 
 import { DELIMITERS, WEB3_SESSION_HEADER_KEY } from "./constants";
 import { Msg } from "./interfaces";
+import { decodeMsgData, encodeMsgData } from "./msgEncoding";
 import { getEc } from "./utils";
 
 const MSG_READ_TIMEOUT = 10_000;
@@ -51,6 +52,8 @@ export class Client {
 
   public _sLessThanHalf: boolean;
 
+  public readonly _messageEncoding: "bytes" | "none";
+
   private _precomputeComplete: number[] = [];
 
   private _precomputeFailed: number[] = [];
@@ -78,7 +81,8 @@ export class Client {
     _share: string,
     _pubKey: string,
     _websocketOnly: boolean,
-    _tssLib: WasmLib
+    _tssLib: WasmLib,
+    _messageEncoding: "bytes" | "none" = "bytes"
   ) {
     if (_parties.length !== _sockets.length) {
       throw new Error("parties and sockets length must be equal, add null for client if necessary");
@@ -99,6 +103,7 @@ export class Client {
     this._consumed = false;
     this._sLessThanHalf = true;
     this.tssLib = _tssLib;
+    this._messageEncoding = _messageEncoding;
 
     _sockets.forEach((socket) => {
       if (socket) {
@@ -108,12 +113,18 @@ export class Client {
 
         // Add listener for incoming messages
         socket.on("send", async (data, cb) => {
-          const { session, sender, recipient, msg_type, msg_data } = data;
+          const { session, sender, recipient, msg_type, msg_data, msg_data_encoded } = data;
           if (session !== this.session) {
             this.log(`ignoring message for a different session... client session: ${this.session}, message session: ${session}`);
             return;
           }
-          this.pushMessage({ session, sender, recipient, msg_type, msg_data });
+          let msg_data_decoded = msg_data;
+          const messageEncoding = this._messageEncoding;
+          if (msg_data_encoded && messageEncoding === "bytes") {
+            const buf = Buffer.from(msg_data_encoded);
+            msg_data_decoded = decodeMsgData(msg_type, buf);
+          }
+          this.pushMessage({ session, sender, recipient, msg_type, msg_data: msg_data_decoded });
           if (cb) cb();
         });
         // Add listener for completion
@@ -219,6 +230,7 @@ export class Client {
                 pubkey: this.pubKey,
                 notifyWebsocketId: this.sockets[party].id,
                 sendWebsocket: this.sockets[party].id,
+                message_encoding: this._messageEncoding,
                 ...additionalParams,
               }),
             })
@@ -444,13 +456,21 @@ if (globalThis.js_send_msg === undefined) {
     }
 
     if (tss_client.websocketOnly) {
+      let msgData: string | undefined = msg_data;
+      let encodedMsgData: Buffer | undefined;
+      if (tss_client._messageEncoding === "bytes") {
+        msgData = undefined;
+        encodedMsgData = encodeMsgData(msg_type, msg_data);
+      }
+
       const socket = tss_client.sockets[party];
       socket.emit("send_msg", {
         session,
         sender: self_index,
         recipient: party,
         msg_type,
-        msg_data,
+        msg_data: msgData,
+        msg_data_encoded: encodedMsgData,
       });
     } else {
       const sid = session.split(DELIMITERS.Delimiter4)[1];

packages/tss-client/src/msgEncoding.ts

@@ -0,0 +1,50 @@
+const specialMessages = {
+  ga1_array: { chunkSize: 64 },
+  com_msg: { chunkSize: 32 },
+  chal_msg: { chunkSize: 32 },
+  msg_0_com: { chunkSize: 32 },
+  msg_1_com: { chunkSize: 32 },
+};
+
+function byteLenToBase64Len(byteLen: number): number {
+  return Math.ceil(byteLen / 3) * 4;
+}
+
+function encodeChunks(dataBase64: string, chunkSize: number): Buffer {
+  const chunks: Buffer[] = [];
+  for (let i = 0; i < dataBase64.length; i += chunkSize) {
+    const chunkBase64 = dataBase64.substring(i, i + chunkSize);
+    const chunk = Buffer.from(chunkBase64, "base64");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+export function encodeMsgData(msg_type: string, msg_data: string) {
+  for (const [key, value] of Object.entries(specialMessages)) {
+    if (msg_type.includes(key)) {
+      const base64Len = byteLenToBase64Len(value.chunkSize);
+      return encodeChunks(msg_data, base64Len);
+    }
+  }
+
+  return Buffer.from(msg_data, "base64");
+}
+
+function decodeChunks(data: Buffer, chunkSize: number): string {
+  let result = "";
+  for (let i = 0; i < data.length; i += chunkSize) {
+    const chunk = data.subarray(i, i + chunkSize);
+    result += chunk.toString("base64");
+  }
+  return result;
+}
+
+export function decodeMsgData(msg_type: string, encoded_msg_data: Buffer) {
+  for (const [key, value] of Object.entries(specialMessages)) {
+    if (msg_type.includes(key)) {
+      return decodeChunks(encoded_msg_data, value.chunkSize);
+    }
+  }
+  return encoded_msg_data.toString("base64");
+}

packages/web-example/src/interfaces.ts

@@ -18,4 +18,5 @@ export type TestConfigType = {
   userType: UserType;
   network: TORUS_SAPPHIRE_NETWORK_TYPE;
   verifier_id?: string;
+  messageEncoding?: "bytes" | "none";
 };

packages/web-example/src/prod.ts

@@ -145,7 +145,7 @@ const runTest = async (testConfig: TestConfigType) => {
   const tssProcessingStart = window.performance.now();
   const lib = await tssLib.load();
 
-  const client = new Client(session, clientIndex, partyIndexes, endpoints, sockets, share, pubKey, true, lib);
+  const client = new Client(session, clientIndex, partyIndexes, endpoints, sockets, share, pubKey, true, lib, testConfig.messageEncoding);
   client.log = (...args: unknown[]) => {
     log(testConfig.label, ...args);
   };
@@ -197,6 +197,7 @@ const runTest = async (testConfig: TestConfigType) => {
       label: "tss_signing_test",
       network: "sapphire_devnet",
       userType: "new",
+      // messageEncoding: "bytes",
     });
     console.log("test succeeded");
     document.title = "Test succeeded";