throw only for breaking stuff on ApiV2 calls

ts/data/opengroups.ts

@@ -51,7 +51,6 @@ export async function getV2OpenGroupRoom(
 export async function getV2OpenGroupRoomByRoomId(
   roomInfos: OpenGroupRequestCommonType
 ): Promise<OpenGroupV2Room | undefined> {
-  console.warn('getting roomInfo', roomInfos);
   const room = await channels.getV2OpenGroupRoomByRoomId(
     roomInfos.serverUrl,
     roomInfos.roomId

ts/opengroup/opengroupV2/ApiUtil.ts

@@ -88,8 +88,15 @@ export const setCachedModerators = (
 };
 
 export const parseMessages = async (
-  rawMessages: Array<Record<string, any>>
+  onionResult: any
 ): Promise<Array<OpenGroupMessageV2>> => {
+  const rawMessages = onionResult?.result?.messages as Array<
+    Record<string, any>
+  >;
+  if (!rawMessages) {
+    window.log.info('no new messages');
+    return [];
+  }
   const messages = await Promise.all(
     rawMessages.map(async r => {
       try {

ts/opengroup/opengroupV2/OpenGroupAPIV2.ts

@@ -4,16 +4,9 @@ import {
   saveV2OpenGroupRoom,
 } from '../../data/opengroups';
 import { ConversationController } from '../../session/conversations';
-import { getSodium } from '../../session/crypto';
 import { sendViaOnion } from '../../session/onions/onionSend';
-import { PubKey } from '../../session/types';
 import { allowOnlyOneAtATime } from '../../session/utils/Promise';
-import {
-  fromBase64ToArray,
-  fromBase64ToArrayBuffer,
-  fromHexToArray,
-  toHex,
-} from '../../session/utils/String';
+import { fromBase64ToArrayBuffer, toHex } from '../../session/utils/String';
 import {
   getIdentityKeyPair,
   getOurPubKeyStrFromCache,
@@ -28,12 +21,18 @@ import {
   parseMessages,
   setCachedModerators,
 } from './ApiUtil';
+import {
+  parseMemberCount,
+  parseModerators,
+  parseRooms,
+  parseStatusCodeFromOnionRequest,
+} from './OpenGroupAPIV2Parser';
 import { OpenGroupMessageV2 } from './OpenGroupMessageV2';
 
 // This function might throw
 async function sendOpenGroupV2Request(
   request: OpenGroupV2Request
-): Promise<Object> {
+): Promise<Object | null> {
   const builtUrl = buildUrl(request);
 
   if (!builtUrl) {
@@ -68,7 +67,8 @@ async function sendOpenGroupV2Request(
         serverUrl: request.server,
       });
       if (!token) {
-        throw new Error('Failed to get token for open group v2');
+        window.log.error('Failed to get token for open group v2');
+        return null;
       }
       headers.Authorization = token;
       const res = await sendViaOnion(roomDetails.serverPublicKey, builtUrl, {
@@ -77,13 +77,13 @@ async function sendOpenGroupV2Request(
         body,
       });
 
-      const statusCode = res?.result?.status_code;
+      const statusCode = parseStatusCodeFromOnionRequest(res);
       if (!statusCode) {
         window.log.warn(
           'sendOpenGroupV2Request Got unknown status code; res:',
           res
         );
-        return res;
+        return res as object;
       }
       // A 401 means that we didn't provide a (valid) auth token for a route that required one. We use this as an
       // indication that the token we're using has expired.
@@ -94,7 +94,7 @@ async function sendOpenGroupV2Request(
         // we might need to retry doing the request here, but how to make sure we don't retry indefinetely?
         await saveV2OpenGroupRoom(roomDetails);
       }
-      return res;
+      return res as object;
     } else {
       // no need for auth, just do the onion request
       const res = await sendViaOnion(roomDetails.serverPublicKey, builtUrl, {
@@ -102,10 +102,8 @@ async function sendOpenGroupV2Request(
         headers,
         body,
       });
-      return res;
+      return res as object;
     }
-
-    return {};
   } else {
     throw new Error(
       "It's currently not allowed to send non onion routed requests."
@@ -117,7 +115,7 @@ async function sendOpenGroupV2Request(
 export async function requestNewAuthToken({
   serverUrl,
   roomId,
-}: OpenGroupRequestCommonType): Promise<string> {
+}: OpenGroupRequestCommonType): Promise<string | null> {
   const userKeyPair = await getIdentityKeyPair();
   if (!userKeyPair) {
     throw new Error('Failed to fetch user keypair');
@@ -137,7 +135,8 @@ export async function requestNewAuthToken({
   const json = (await sendOpenGroupV2Request(request)) as any;
   // parse the json
   if (!json || !json?.result?.challenge) {
-    throw new Error('Parsing failed');
+    window.log.warn('Parsing failed');
+    return null;
   }
   const {
     ciphertext: base64EncodedCiphertext,
@@ -145,7 +144,8 @@ export async function requestNewAuthToken({
   } = json?.result?.challenge;
 
   if (!base64EncodedCiphertext || !base64EncodedEphemeralPublicKey) {
-    throw new Error('Parsing failed');
+    window.log.warn('Parsing failed');
+    return null;
   }
   const ciphertext = fromBase64ToArrayBuffer(base64EncodedCiphertext);
   const ephemeralPublicKey = fromBase64ToArrayBuffer(
@@ -168,12 +168,11 @@ export async function requestNewAuthToken({
     return token;
   } catch (e) {
     window.log.error('Failed to decrypt token open group v2');
-    throw e;
+    return null;
   }
 }
 
 /**
- * This function might throw
  *
  */
 export async function openGroupV2GetRoomInfo({
@@ -182,7 +181,7 @@ export async function openGroupV2GetRoomInfo({
 }: {
   roomId: string;
   serverUrl: string;
-}): Promise<OpenGroupV2Info> {
+}): Promise<OpenGroupV2Info | null> {
   const request: OpenGroupV2Request = {
     method: 'GET',
     server: serverUrl,
@@ -195,7 +194,8 @@ export async function openGroupV2GetRoomInfo({
     const { id, name, image_id: imageId } = result?.result?.room;
 
     if (!id || !name) {
-      throw new Error('Parsing failed');
+      window.log.warn('getRoominfo Parsing failed');
+      return null;
     }
     const info: OpenGroupV2Info = {
       id,
@@ -205,14 +205,15 @@ export async function openGroupV2GetRoomInfo({
 
     return info;
   }
-  throw new Error('getInfo failed');
+  window.log.warn('getInfo failed');
+  return null;
 }
 
 async function claimAuthToken(
   authToken: string,
   serverUrl: string,
   roomId: string
-): Promise<string> {
+): Promise<string | null> {
   // Set explicitly here because is isn't in the database yet at this point
   const headers = { Authorization: authToken };
   const request: OpenGroupV2Request = {
@@ -224,11 +225,11 @@ async function claimAuthToken(
     isAuthRequired: false,
     endpoint: 'claim_auth_token',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
-    throw new Error(
-      `Could not claim token, status code: ${result?.result?.status_code}`
-    );
+  const result = await sendOpenGroupV2Request(request);
+  const statusCode = parseStatusCodeFromOnionRequest(result);
+  if (statusCode !== 200) {
+    window.log.warn(`Could not claim token, status code: ${statusCode}`);
+    return null;
   }
   return authToken;
 }
@@ -236,11 +237,12 @@ async function claimAuthToken(
 export async function getAuthToken({
   serverUrl,
   roomId,
-}: OpenGroupRequestCommonType): Promise<string> {
+}: OpenGroupRequestCommonType): Promise<string | null> {
   // first try to fetch from db a saved token.
   const roomDetails = await getV2OpenGroupRoomByRoomId({ serverUrl, roomId });
   if (!roomDetails) {
-    throw new Error('getAuthToken Room does not exist.');
+    window.log.warn('getAuthToken Room does not exist.');
+    return null;
   }
   if (roomDetails?.token) {
     return roomDetails?.token;
@@ -251,9 +253,16 @@ export async function getAuthToken({
     async () => {
       try {
         const token = await requestNewAuthToken({ serverUrl, roomId });
-        // claimAuthToken throws if the status code is not valid
+        if (!token) {
+          window.log.warn('invalid new auth token', token);
+          return;
+        }
         const claimedToken = await claimAuthToken(token, serverUrl, roomId);
-        roomDetails.token = token;
+        if (!claimedToken) {
+          window.log.warn('invalid claimed token', claimedToken);
+        }
+        // still save it to the db. just to mark it as to be refreshed later
+        roomDetails.token = claimedToken || '';
         await saveV2OpenGroupRoom(roomDetails);
       } catch (e) {
         window.log.error('Failed to getAuthToken', e);
@@ -262,7 +271,18 @@ export async function getAuthToken({
     }
   );
 
-  return 'token';
+  const refreshedRoomDetails = await getV2OpenGroupRoomByRoomId({
+    serverUrl,
+    roomId,
+  });
+  if (!refreshedRoomDetails) {
+    window.log.warn('getAuthToken Room does not exist.');
+    return null;
+  }
+  if (refreshedRoomDetails?.token) {
+    return refreshedRoomDetails?.token;
+  }
+  return null;
 }
 
 export const deleteAuthToken = async ({
@@ -276,21 +296,21 @@ export const deleteAuthToken = async ({
     isAuthRequired: false,
     endpoint: 'auth_token',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
-    throw new Error(
-      `Could not deleteAuthToken, status code: ${result?.result?.status_code}`
-    );
+  const result = await sendOpenGroupV2Request(request);
+  const statusCode = parseStatusCodeFromOnionRequest(result);
+  if (statusCode !== 200) {
+    window.log.warn(`Could not deleteAuthToken, status code: ${statusCode}`);
   }
 };
 
 export const getMessages = async ({
   serverUrl,
   roomId,
-}: OpenGroupRequestCommonType): Promise<Array<OpenGroupMessageV2>> => {
+}: OpenGroupRequestCommonType): Promise<Array<OpenGroupMessageV2> | null> => {
   const roomInfos = await getV2OpenGroupRoomByRoomId({ serverUrl, roomId });
   if (!roomInfos) {
-    throw new Error('Could not find this room getMessages');
+    window.log.warn('Could not find this room getMessages');
+    return [];
   }
   const { lastMessageFetchedServerID } = roomInfos;
 
@@ -306,20 +326,14 @@ export const getMessages = async ({
     isAuthRequired: true,
     endpoint: 'messages',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
-    throw new Error(
-      `Could not getMessages, status code: ${result?.result?.status_code}`
-    );
+  const result = await sendOpenGroupV2Request(request);
+  const statusCode = parseStatusCodeFromOnionRequest(result);
+  if (statusCode !== 200) {
+    return [];
   }
 
   // we have a 200
-  const rawMessages = result?.result?.messages as Array<Record<string, any>>;
-  if (!rawMessages) {
-    window.log.info('no new messages');
-    return [];
-  }
-  const validMessages = await parseMessages(rawMessages);
+  const validMessages = await parseMessages(result);
   console.warn('validMessages', validMessages);
   return validMessages;
 };
@@ -341,21 +355,23 @@ export const postMessage = async (
       isAuthRequired: true,
       endpoint: 'messages',
     };
-    const result = (await sendOpenGroupV2Request(request)) as any;
-    if (result?.result?.status_code !== 200) {
-      throw new Error(
-        `Could not postMessage, status code: ${result?.result?.status_code}`
-      );
+    const result = await sendOpenGroupV2Request(request);
+    const statusCode = parseStatusCodeFromOnionRequest(result);
+
+    if (statusCode !== 200) {
+      window.log.warn(`Could not postMessage, status code: ${statusCode}`);
+      return null;
     }
-    const rawMessage = result?.result?.message;
+    const rawMessage = (result as any)?.result?.message;
     if (!rawMessage) {
-      throw new Error('postMessage parsing failed');
+      window.log.warn('postMessage parsing failed');
+      return null;
     }
     // this will throw if the json is not valid
     return OpenGroupMessageV2.fromJson(rawMessage);
   } catch (e) {
     window.log.error('Failed to post message to open group v2', e);
-    throw e;
+    return null;
   }
 };
 
@@ -371,20 +387,23 @@ export const getModerators = async ({
     isAuthRequired: true,
     endpoint: 'moderators',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
-    throw new Error(
-      `Could not getModerators, status code: ${result?.result?.status_code}`
-    );
+  const result = await sendOpenGroupV2Request(request);
+  const statusCode = parseStatusCodeFromOnionRequest(result);
+
+  if (statusCode !== 200) {
+    window.log.error(`Could not getModerators, status code: ${statusCode}`);
+    return [];
   }
-  const moderatorsGot = result?.result?.moderators;
-  if (moderatorsGot === undefined) {
-    throw new Error(
+  const moderators = parseModerators(result);
+  if (moderators === undefined) {
+    // if moderators is undefined, do not update the cached moderator list
+    window.log.warn(
       'Could not getModerators, got no moderatorsGot at all in json.'
     );
+    return [];
   }
-  setCachedModerators(serverUrl, roomId, moderatorsGot || []);
-  return moderatorsGot || [];
+  setCachedModerators(serverUrl, roomId, moderators || []);
+  return moderators || [];
 };
 
 export const isUserModerator = (
@@ -440,29 +459,15 @@ export const getAllRoomInfos = async (
     isAuthRequired: false,
     endpoint: 'rooms',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
+  const result = await sendOpenGroupV2Request(request);
+  const statusCode = parseStatusCodeFromOnionRequest(result);
+
+  if (statusCode !== 200) {
     window.log.warn('getAllRoomInfos failed invalid status code');
     return;
   }
 
-  const rooms = result?.result?.rooms as Array<any>;
-  if (!rooms || !rooms.length) {
-    window.log.warn('getAllRoomInfos failed invalid infos');
-    return;
-  }
-  return _.compact(
-    rooms.map(room => {
-      // check that the room is correctly filled
-      const { id, name, image_id: imageId } = room;
-      if (!id || !name) {
-        window.log.info('getAllRoomInfos: Got invalid room details, skipping');
-        return null;
-      }
-
-      return { id, name, imageId } as OpenGroupV2Info;
-    })
-  );
+  return parseRooms(result);
 };
 
 export const getMemberCount = async (
@@ -475,12 +480,12 @@ export const getMemberCount = async (
     isAuthRequired: true,
     endpoint: 'member_count',
   };
-  const result = (await sendOpenGroupV2Request(request)) as any;
-  if (result?.result?.status_code !== 200) {
+  const result = await sendOpenGroupV2Request(request);
+  if (parseStatusCodeFromOnionRequest(result) !== 200) {
     window.log.warn('getMemberCount failed invalid status code');
     return;
   }
-  const count = result?.result?.member_count as number;
+  const count = parseMemberCount(result);
   if (count === undefined) {
     window.log.warn('getMemberCount failed invalid count');
     return;
@@ -504,3 +509,22 @@ export const getMemberCount = async (
     await convo.commit();
   }
 };
+
+/**
+ * File upload and download
+ */
+
+export const downloadFile = async (
+  fileId: number,
+  roomInfos: OpenGroupRequestCommonType
+): Promise<void> => {
+  const request: OpenGroupV2Request = {
+    method: 'GET',
+    room: roomInfos.roomId,
+    server: roomInfos.serverUrl,
+    isAuthRequired: true,
+    endpoint: `files${fileId}`,
+  };
+
+  const result = await sendOpenGroupV2Request(request);
+};

ts/opengroup/opengroupV2/OpenGroupAPIV2Parser.ts

@@ -0,0 +1,67 @@
+import { OpenGroupV2Info } from './ApiUtil';
+import _ from 'lodash';
+
+/**
+ * An onion request to the open group api returns something like
+ * {result: {status_code:number; whatever: somerandomtype}; }
+ *
+ * This utility function just extract the status code and returns it.
+ * If the status code is not found, this function returns undefined;
+ */
+export const parseStatusCodeFromOnionRequest = (
+  onionResult: any
+): number | undefined => {
+  if (!onionResult) {
+    return undefined;
+  }
+  const statusCode = onionResult?.result?.status_code;
+  if (statusCode) {
+    return statusCode;
+  }
+  return undefined;
+};
+
+export const parseMemberCount = (onionResult: any): number | undefined => {
+  if (!onionResult) {
+    return undefined;
+  }
+  const memberCount = onionResult?.result?.member_count;
+  if (memberCount) {
+    return memberCount;
+  }
+  return undefined;
+};
+
+export const parseRooms = (
+  onionResult: any
+): undefined | Array<OpenGroupV2Info> => {
+  if (!onionResult) {
+    return undefined;
+  }
+  const rooms = onionResult?.result?.rooms as Array<any>;
+  if (!rooms || !rooms.length) {
+    window.log.warn('getAllRoomInfos failed invalid infos');
+    return [];
+  }
+  return _.compact(
+    rooms.map(room => {
+      // check that the room is correctly filled
+      const { id, name, image_id: imageId } = room;
+      if (!id || !name) {
+        window.log.info('getAllRoomInfos: Got invalid room details, skipping');
+        return null;
+      }
+
+      return { id, name, imageId } as OpenGroupV2Info;
+    })
+  );
+};
+
+export const parseModerators = (
+  onionResult: any
+): Array<string> | undefined => {
+  const moderatorsGot = onionResult?.result?.moderators as
+    | Array<string>
+    | undefined;
+  return moderatorsGot;
+};

ts/opengroup/opengroupV2/OpenGroupManagerV2.ts

@@ -60,6 +60,9 @@ async function attemptConnectionV2(
     // will need it and access it from the db
     await saveV2OpenGroupRoom(room);
     const roomInfos = await openGroupV2GetRoomInfo({ roomId, serverUrl });
+    if (!roomInfos) {
+      throw new Error('Invalid open group roomInfo result');
+    }
     const conversation = await ConversationController.getInstance().getOrCreateAndWait(
       conversationId,
       ConversationType.OPEN_GROUP

ts/opengroup/utils/OpenGroupUtils.ts

@@ -59,7 +59,7 @@ export const validOpenGroupServer = async (serverUrl: string) => {
         { method: 'GET' },
         { noJson: true }
       );
-      if (res.result && res.result.status === 200) {
+      if (res && res.result && res.result.status === 200) {
         window.log.info(
           `loki_public_chat::validOpenGroupServer - onion routing enabled on ${url.toString()}`
         );

ts/session/onions/onionSend.ts

@@ -31,30 +31,45 @@ type OnionFetchOptions = {
 type OnionFetchBasicOptions = {
   retry?: number;
   requestNumber?: number;
-  // tslint:disable-next-line: max-func-body-length
   noJson?: boolean;
   counter?: number;
 };
 
-export const sendViaOnion = async (
+const handleSendViaOnionRetry = async (
+  result: number,
+  options: OnionFetchBasicOptions,
   srvPubKey: string,
   url: URL,
-  fetchOptions: OnionFetchOptions,
-  options: OnionFetchBasicOptions = {}
-): Promise<any> => {
-  if (!srvPubKey) {
-    window.log.error('sendViaOnion - called without a server public key');
-    return {};
-  }
+  fetchOptions: OnionFetchOptions
+) => {
+  window.log.error(
+    'sendOnionRequestLsrpcDest() returned a number indicating an error: ',
+    result === RequestError.BAD_PATH ? 'BAD_PATH' : 'OTHER'
+  );
 
-  if (options.retry === undefined) {
-    // set retry count
-    options.retry = 0;
-  }
-  if (options.requestNumber === undefined) {
-    options.requestNumber = OnionPaths.getInstance().assignOnionRequestNumber();
+  if (options.retry && options.retry >= MAX_SEND_ONION_RETRIES) {
+    window.log.error(
+      `sendViaOnion too many retries: ${options.retry}. Stopping retries.`
+    );
+    return null;
+  } else {
+    // handle error/retries, this is a RequestError
+    window.log.error(
+      `sendViaOnion #${options.requestNumber} - Retry #${options.retry} Couldnt handle onion request, retrying`
+    );
   }
+  // retry the same request, and increment the counter
+  return sendViaOnion(srvPubKey, url, fetchOptions, {
+    ...options,
+    retry: (options.retry as number) + 1,
+    counter: options.requestNumber,
+  });
+};
 
+const buildSendViaOnionPayload = (
+  url: URL,
+  fetchOptions: OnionFetchOptions
+) => {
   let tempHeaders = fetchOptions.headers || {};
   const payloadObj = {
     method: fetchOptions.method || 'GET',
@@ -83,21 +98,64 @@ export const sendViaOnion = async (
       fileUpload: fData.toString('base64'),
     };
   }
+  payloadObj.headers = tempHeaders;
+  return payloadObj;
+};
 
+export const getOnionPathForSending = async (requestNumber: number) => {
   let pathNodes: Array<Snode> = [];
   try {
     pathNodes = await OnionPaths.getInstance().getOnionPath();
   } catch (e) {
     window.log.error(
-      `sendViaOnion #${options.requestNumber} - getOnionPath Error ${e.code} ${e.message}`
+      `sendViaOnion #${requestNumber} - getOnionPath Error ${e.code} ${e.message}`
     );
   }
   if (!pathNodes || !pathNodes.length) {
     window.log.warn(
-      `sendViaOnion #${options.requestNumber} - failing, no path available`
+      `sendViaOnion #${requestNumber} - failing, no path available`
     );
     // should we retry?
-    return {};
+    return null;
+  }
+  return pathNodes;
+};
+
+const initOptionsWithDefaults = (options: OnionFetchBasicOptions) => {
+  const defaultFetchBasicOptions = {
+    retry: 0,
+    requestNumber: OnionPaths.getInstance().assignOnionRequestNumber(),
+  };
+  return _.defaults(options, defaultFetchBasicOptions);
+};
+
+/**
+ * FIXME the type for this is not correct for open group api v2 returned values
+ * result is status_code and whatever the body should be
+ */
+export const sendViaOnion = async (
+  srvPubKey: string,
+  url: URL,
+  fetchOptions: OnionFetchOptions,
+  options: OnionFetchBasicOptions = {}
+): Promise<{
+  result: SnodeResponse;
+  txtResponse: string;
+  response: string;
+} | null> => {
+  if (!srvPubKey) {
+    window.log.error('sendViaOnion - called without a server public key');
+    return null;
+  }
+
+  const defaultedOptions = initOptionsWithDefaults(options);
+
+  const payloadObj = buildSendViaOnionPayload(url, fetchOptions);
+  const pathNodes = await getOnionPathForSending(
+    defaultedOptions.requestNumber
+  );
+  if (!pathNodes) {
+    return null;
   }
 
   // do the request
@@ -109,7 +167,7 @@ export const sendViaOnion = async (
       // protocol: url.protocol,
       // port: url.port,
     };
-    payloadObj.headers = tempHeaders;
+
     console.warn('sendViaOnion payloadObj ==> ', payloadObj);
 
     result = await sendOnionRequestLsrpcDest(
@@ -118,39 +176,28 @@ export const sendViaOnion = async (
       srvPubKey,
       finalRelayOptions,
       payloadObj,
-      options.requestNumber
+      defaultedOptions.requestNumber
     );
   } catch (e) {
     window.log.error('sendViaOnion - lokiRpcUtils error', e.code, e.message);
-    return {};
+    return null;
   }
 
   // RequestError return type is seen as number (as it is an enum)
   if (typeof result === 'number') {
-    window.log.error(
-      'sendOnionRequestLsrpcDest() returned a number indicating an error: ',
-      result === RequestError.BAD_PATH ? 'BAD_PATH' : 'OTHER'
-    );
-    // handle error/retries, this is a RequestError
-    window.log.error(
-      `sendViaOnion #${options.requestNumber} - Retry #${options.retry} Couldnt handle onion request, retrying`,
-      payloadObj
+    const retriedResult = await handleSendViaOnionRetry(
+      result,
+      defaultedOptions,
+      srvPubKey,
+      url,
+      fetchOptions
     );
-    if (options.retry && options.retry >= MAX_SEND_ONION_RETRIES) {
-      window.log.error(
-        `sendViaOnion too many retries: ${options.retry}. Stopping retries.`
-      );
-      return {};
-    }
-    return sendViaOnion(srvPubKey, url, fetchOptions, {
-      ...options,
-      retry: options.retry + 1,
-      counter: options.requestNumber,
-    });
+    // keep the await separate so we can log it easily
+    return retriedResult;
   }
 
   // If we expect something which is not json, just return the body we got.
-  if (options.noJson) {
+  if (defaultedOptions.noJson) {
     return {
       result,
       txtResponse: result.body,
@@ -170,7 +217,7 @@ export const sendViaOnion = async (
       body = JSON.parse(result.body);
     } catch (e) {
       window.log.error(
-        `sendViaOnion #${options.requestNumber} - Can't decode JSON body`,
+        `sendViaOnion #${defaultedOptions.requestNumber} - Can't decode JSON body`,
         typeof result.body,
         result.body
       );
@@ -269,12 +316,15 @@ export const serverRequest = async (
           'useFileOnionRequests=true but we do not have a server pubkey set.'
         );
       }
-      ({ response, txtResponse, result } = await sendViaOnion(
+      const onionResponse = await sendViaOnion(
         srvPubKey,
         url,
         fetchOptions,
         options
-      ));
+      );
+      if (onionResponse) {
+        ({ response, txtResponse, result } = onionResponse);
+      }
     } else if (window.lokiFeatureFlags.useFileOnionRequests) {
       if (!srvPubKey) {
         throw new Error(
@@ -282,12 +332,15 @@ export const serverRequest = async (
         );
       }
       mode = 'sendViaOnionOG';
-      ({ response, txtResponse, result } = await sendViaOnion(
+      const onionResponse = await sendViaOnion(
         srvPubKey,
         url,
         fetchOptions,
         options
-      ));
+      );
+      if (onionResponse) {
+        ({ response, txtResponse, result } = onionResponse);
+      }
     } else {
       // we end up here only if window.lokiFeatureFlags.useFileOnionRequests is false
       window.log.info(`insecureNodeFetch => plaintext for ${url}`);

ts/session/snode_api/onions.ts

@@ -357,10 +357,6 @@ const processOnionResponse = async (
 
   try {
     const jsonRes: SnodeResponse = JSON.parse(plaintext);
-    // todo check if this is really useful.
-    // if (!jsonRes.body || !jsonRes.status) {
-    //   throw new Error('Got JSON but with empty fields');
-    // }
     return jsonRes;
   } catch (e) {
     log.error(