Simplify sql and data files

app/sql.js

@@ -74,12 +74,8 @@ module.exports = {
   removeAllContactSignedPreKeys,
 
   createOrUpdatePairingAuthorisation,
-  removePairingAuthorisationForSecondaryPubKey,
+  getPairingAuthorisationsFor,
-  getAuthorisationForSecondaryPubKey,
+  removePairingAuthorisationsFor,
-  getGrantAuthorisationsForPrimaryPubKey,
-  getSecondaryDevicesFor,
-  getPrimaryDeviceFor,
-  getPairedDevicesFor,
 
   createOrUpdateItem,
   getItemById,
@@ -1506,42 +1502,19 @@ async function removeAllSignedPreKeys() {
 
 const PAIRING_AUTHORISATIONS_TABLE = 'pairingAuthorisations';
 
-const GUARD_NODE_TABLE = 'guardNodes';
+async function getPairingAuthorisationsFor(pubKey) {
-
-async function getAuthorisationForSecondaryPubKey(pubKey, options) {
-  const granted = options && options.granted;
-  let filter = '';
-  if (granted) {
-    filter = 'AND isGranted = 1';
-  }
-  const row = await db.get(
-    `SELECT json FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE secondaryDevicePubKey = $secondaryDevicePubKey ${filter};`,
-    {
-      $secondaryDevicePubKey: pubKey,
-    }
-  );
-
-  if (!row) {
-    return null;
-  }
-
-  return jsonToObject(row.json);
-}
-
-async function getGrantAuthorisationsForPrimaryPubKey(primaryDevicePubKey) {
   const rows = await db.all(
-    `SELECT json FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE primaryDevicePubKey = $primaryDevicePubKey AND isGranted = 1 ORDER BY secondaryDevicePubKey ASC;`,
+    `SELECT json FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE primaryDevicePubKey = $pubKey OR secondaryDevicePubKey = $pubKey;`,
-    {
+    { $pubKey: pubKey }
-      $primaryDevicePubKey: primaryDevicePubKey,
-    }
   );
-  return map(rows, row => jsonToObject(row.json));
+
+  return rows.map(row => jsonToObject(row.json));
 }
 
 async function createOrUpdatePairingAuthorisation(data) {
   const { primaryDevicePubKey, secondaryDevicePubKey, grantSignature } = data;
   // remove any existing authorisation for this pubkey (we allow only one secondary device for now)
-  await removePairingAuthorisationForPrimaryPubKey(primaryDevicePubKey);
+  await removePairingAuthorisationsFor(primaryDevicePubKey);
 
   await db.run(
     `INSERT OR REPLACE INTO ${PAIRING_AUTHORISATIONS_TABLE} (
@@ -1564,30 +1537,16 @@ async function createOrUpdatePairingAuthorisation(data) {
   );
 }
 
-async function removePairingAuthorisationForPrimaryPubKey(pubKey) {
+async function removePairingAuthorisationsFor(pubKey) {
-  await db.run(
-    `DELETE FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE primaryDevicePubKey = $primaryDevicePubKey;`,
-    {
-      $primaryDevicePubKey: pubKey,
-    }
-  );
-}
-
-async function removePairingAuthorisationForSecondaryPubKey(pubKey) {
   await db.run(
-    `DELETE FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE secondaryDevicePubKey = $secondaryDevicePubKey;`,
+    `DELETE FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE primaryDevicePubKey = $pubKey OR secondaryDevicePubKey = $pubKey;`,
     {
-      $secondaryDevicePubKey: pubKey,
+      $pubKey: pubKey,
     }
   );
 }
 
-async function getSecondaryDevicesFor(primaryDevicePubKey) {
+const GUARD_NODE_TABLE = 'guardNodes';
-  const authorisations = await getGrantAuthorisationsForPrimaryPubKey(
-    primaryDevicePubKey
-  );
-  return map(authorisations, row => row.secondaryDevicePubKey);
-}
 
 async function getGuardNodes() {
   const nodes = await db.all(`SELECT ed25519PubKey FROM ${GUARD_NODE_TABLE};`);
@@ -1620,42 +1579,8 @@ async function updateGuardNodes(nodes) {
   await db.run('END TRANSACTION;');
 }
 
-async function getPrimaryDeviceFor(secondaryDevicePubKey) {
-  const row = await db.get(
-    `SELECT primaryDevicePubKey FROM ${PAIRING_AUTHORISATIONS_TABLE} WHERE secondaryDevicePubKey = $secondaryDevicePubKey AND isGranted = 1;`,
-    {
-      $secondaryDevicePubKey: secondaryDevicePubKey,
-    }
-  );
-
-  if (!row) {
-    return null;
-  }
-
-  return row.primaryDevicePubKey;
-}
-
 // Return all the paired pubkeys for a specific pubkey (excluded),
 // irrespective of their Primary or Secondary status.
-async function getPairedDevicesFor(pubKey) {
-  let results = [];
-
-  // get primary pubkey (only works if the pubkey is a secondary pubkey)
-  const primaryPubKey = await getPrimaryDeviceFor(pubKey);
-  if (primaryPubKey) {
-    results.push(primaryPubKey);
-  }
-  // get secondary pubkeys (only works if the pubkey is a primary pubkey)
-  const secondaryPubKeys = await getSecondaryDevicesFor(
-    primaryPubKey || pubKey
-  );
-  results = results.concat(secondaryPubKeys);
-
-  // ensure the input pubkey is not in the results
-  results = results.filter(x => x !== pubKey);
-
-  return results;
-}
 
 const ITEMS_TABLE = 'items';
 async function createOrUpdateItem(data) {

js/background.js

@@ -9,6 +9,7 @@
   textsecure,
   Whisper,
   libloki,
+  libsession,
   libsignal,
   StringView,
   BlockedNumberController,
@@ -1425,8 +1426,10 @@
 
     Whisper.events.on('devicePairingRequestRejected', async pubKey => {
       await libloki.storage.removeContactPreKeyBundle(pubKey);
-      await libloki.storage.removePairingAuthorisationForSecondaryPubKey(
+
-        pubKey
+      const pubKeyObject = new libsession.Types.PubKey(pubKey);
+      await libsession.Protocols.MultiDeviceProtocol.removePairingAuthorisations(
+        pubKeyObject
       );
     });
 
@@ -1435,9 +1438,9 @@
       if (isSecondaryDevice) {
         return;
       }
-
+      const pubKeyObject = new libsession.Types.PubKey(pubKey);
-      await libloki.storage.removePairingAuthorisationForSecondaryPubKey(
+      await libsession.Protocols.MultiDeviceProtocol.removePairingAuthorisations(
-        pubKey
+        pubKeyObject
       );
       await window.lokiFileServerAPI.updateOurDeviceMapping();
       // TODO: we should ensure the message was sent and retry automatically if not
@@ -1752,16 +1755,13 @@
       return;
     }
 
-    let primaryDevice = null;
+    const user = libsession.Types.PubKey.from(sender);
-    const authorisation = await libloki.storage.getGrantAuthorisationForSecondaryPubKey(
+    const primaryDevice = user
-      sender
+      ? await libsession.Protocols.MultiDeviceProtocol.getPrimaryDevice(user)
-    );
+      : null;
-    if (authorisation) {
-      primaryDevice = authorisation.primaryDevicePubKey;
-    }
 
     const conversation = ConversationController.get(
-      groupId || primaryDevice || sender
+      groupId || (primaryDevice && primaryDevice.key) || sender
     );
 
     if (conversation) {

js/models/conversations.js

@@ -876,15 +876,12 @@
         // This is already the primary conversation
         return this;
       }
-      const authorisation = await window.libloki.storage.getAuthorisationForSecondaryPubKey(
+
-        this.id
+      const device = window.libsession.Type.PubKey.from(this.id);
-      );
+      if (device) {
-      if (authorisation) {
+        return ConversationController.getOrCreateAndWait(device.key, 'private');
-        return ConversationController.getOrCreateAndWait(
-          authorisation.primaryDevicePubKey,
-          'private'
-        );
       }
+
       // Something funky has happened
       return this;
     },

js/modules/data.d.ts

@@ -46,7 +46,7 @@ type PairingAuthorisation = {
   primaryDevicePubKey: string;
   secondaryDevicePubKey: string;
   requestSignature: ArrayBuffer;
-  grantSignature: ArrayBuffer | null;
+  grantSignature?: ArrayBuffer;
 };
 
 type GuardNode = {
@@ -153,25 +153,10 @@ export function removeAllContactSignedPreKeys(): Promise<void>;
 export function createOrUpdatePairingAuthorisation(
   data: PairingAuthorisation
 ): Promise<void>;
-export function removePairingAuthorisationForSecondaryPubKey(
+export function getPairingAuthorisationsFor(
-  pubKey: string
-): Promise<void>;
-export function getGrantAuthorisationsForPrimaryPubKey(
   pubKey: string
 ): Promise<Array<PairingAuthorisation>>;
-export function getGrantAuthorisationForSecondaryPubKey(
+export function removePairingAuthorisationsFor(pubKey: string): Promise<void>;
-  pubKey: string
-): Promise<PairingAuthorisation | null>;
-export function getAuthorisationForSecondaryPubKey(
-  pubKey: string
-): Promise<PairingAuthorisation | null>;
-export function getSecondaryDevicesFor(
-  primaryDevicePubKey: string
-): Promise<Array<string>>;
-export function getPrimaryDeviceFor(
-  secondaryDevicePubKey: string
-): Promise<string | null>;
-export function getPairedDevicesFor(pubKey: string): Promise<Array<string>>;
 
 // Guard Nodes
 export function getGuardNodes(): Promise<GuardNode>;

js/modules/data.js

@@ -89,13 +89,8 @@ module.exports = {
   removeAllContactSignedPreKeys,
 
   createOrUpdatePairingAuthorisation,
-  removePairingAuthorisationForSecondaryPubKey,
+  getPairingAuthorisationsFor,
-  getGrantAuthorisationForSecondaryPubKey,
+  removePairingAuthorisationsFor,
-  getAuthorisationForSecondaryPubKey,
-  getGrantAuthorisationsForPrimaryPubKey,
-  getSecondaryDevicesFor,
-  getPrimaryDeviceFor,
-  getPairedDevicesFor,
 
   getGuardNodes,
   updateGuardNodes,
@@ -631,21 +626,20 @@ async function createOrUpdatePairingAuthorisation(data) {
   });
 }
 
-async function removePairingAuthorisationForSecondaryPubKey(pubKey) {
+async function getPairingAuthorisationsFor(pubKey) {
-  if (!pubKey) {
+  const authorisations = channels.getPairingAuthorisationsFor(pubKey);
-    return;
-  }
-  await channels.removePairingAuthorisationForSecondaryPubKey(pubKey);
-}
 
-async function getGrantAuthorisationForSecondaryPubKey(pubKey) {
+  return authorisations.map(authorisation => ({
-  return channels.getAuthorisationForSecondaryPubKey(pubKey, {
+    ...authorisation,
-    granted: true,
+    requestSignature: base64ToArrayBuffer(authorisation.requestSignature),
-  });
+    grantSignature: authorisation.grantSignature
+      ? base64ToArrayBuffer(authorisation.grantSignature)
+      : undefined,
+  }));
 }
 
-async function getGrantAuthorisationsForPrimaryPubKey(pubKey) {
+async function removePairingAuthorisationsFor(pubKey) {
-  return channels.getGrantAuthorisationsForPrimaryPubKey(pubKey);
+  await channels.removePairingAuthorisationsFor(pubKey);
 }
 
 function getAuthorisationForSecondaryPubKey(pubKey) {

js/modules/loki_file_server_api.js

@@ -1,6 +1,5 @@
 /* global log, libloki, window */
 /* global storage: false */
-/* global Signal: false */
 /* global log: false */
 
 const LokiAppDotNetAPI = require('./loki_app_dot_net_api');
@@ -220,16 +219,11 @@ class LokiHomeServerInstance extends LokiFileServerInstance {
 
   async updateOurDeviceMapping() {
     const isPrimary = !storage.get('isSecondaryDevice');
-    let authorisations;
+    const ourKey = new window.libsession.Types.PubKey(this.ourKey);
-    if (isPrimary) {
+    const authorisations = await window.libsession.Protocols.MultiDeviceProtocol.getPairingAuthorisations(
-      authorisations = await Signal.Data.getGrantAuthorisationsForPrimaryPubKey(
+      ourKey
-        this.ourKey
+    );
-      );
+
-    } else {
-      authorisations = [
-        await Signal.Data.getGrantAuthorisationForSecondaryPubKey(this.ourKey),
-      ];
-    }
     return this._setOurDeviceMapping(authorisations, isPrimary);
   }
 

libloki/storage.js

@@ -186,12 +186,6 @@
     await window.Signal.Data.createOrUpdatePairingAuthorisation(authorisation);
   }
 
-  function removePairingAuthorisationForSecondaryPubKey(pubKey) {
-    return window.Signal.Data.removePairingAuthorisationForSecondaryPubKey(
-      pubKey
-    );
-  }
-
   // Transforms signatures from base64 to ArrayBuffer!
   async function getGrantAuthorisationForSecondaryPubKey(secondaryPubKey) {
     const conversation = ConversationController.get(secondaryPubKey);
@@ -264,15 +258,6 @@
     saveContactPreKeyBundle,
     removeContactPreKeyBundle,
     verifyFriendRequestAcceptPreKey,
-    savePairingAuthorisation,
-    saveAllPairingAuthorisationsFor,
-    removePairingAuthorisationForSecondaryPubKey,
-    getGrantAuthorisationForSecondaryPubKey,
-    getAuthorisationForSecondaryPubKey,
-    getPairedDevicesFor,
-    getAllDevicePubKeysForPrimaryPubKey,
-    getSecondaryDevicesFor,
-    getPrimaryDeviceMapping,
     getGuardNodes,
     updateGuardNodes,
   };

libtextsecure/account_manager.js

@@ -3,6 +3,7 @@
   textsecure,
   libsignal,
   libloki,
+  libsession,
   lokiFileServerAPI,
   mnemonic,
   btoa,
@@ -604,8 +605,9 @@
           e && e.stack ? e.stack : e
         );
         // File server upload failed or message sending failed, we should rollback changes
-        await libloki.storage.removePairingAuthorisationForSecondaryPubKey(
+        const pubKey = new libsession.Types.PubKey(secondaryDevicePubKey);
-          secondaryDevicePubKey
+        await libsession.Protocols.MultiDeviceProtocol.removePairingAuthorisations(
+          pubKey
         );
         await lokiFileServerAPI.updateOurDeviceMapping();
         throw e;

ts/session/index.ts

@@ -1,5 +1,6 @@
 import * as Messages from './messages';
 import * as Protocols from './protocols';
+import * as Types from './types';
 
 // TODO: Do we export class instances here?
 // E.g

ts/session/protocols/MultiDeviceProtocol.ts

@@ -1,6 +1,91 @@
-// TODO: Populate this with multi device specific code, e.g getting linked devices for a user etc...
+import _ from 'lodash';
-// We need to deprecate the multi device code we have in js and slowly transition to this file
+import {
+  createOrUpdatePairingAuthorisation,
+  getPairingAuthorisationsFor,
+  PairingAuthorisation,
+  removePairingAuthorisationsFor,
+} from '../../../js/modules/data';
+import { PrimaryPubKey, PubKey, SecondaryPubKey } from '../types';
 
-export function implementStuffHere() {
+/**
-  throw new Error("Don't call me :(");
+ * Save pairing authorisation to the database.
+ * @param authorisation The pairing authorisation.
+ */
+export async function savePairingAuthorisation(
+  authorisation: PairingAuthorisation
+): Promise<void> {
+  return createOrUpdatePairingAuthorisation(authorisation);
+}
+
+/**
+ * Get pairing authorisations for a given device.
+ * @param device The device to get pairing authorisations for.
+ */
+export async function getPairingAuthorisations(
+  device: PubKey
+): Promise<Array<PairingAuthorisation>> {
+  return getPairingAuthorisationsFor(device.key);
+}
+
+/**
+ * Remove all pairing authorisations for a given device.
+ * @param device The device to remove authorisation for.
+ */
+export async function removePairingAuthorisations(
+  device: PubKey
+): Promise<void> {
+  return removePairingAuthorisationsFor(device.key);
+}
+
+/**
+ * Get all devices linked to a user.
+ *
+ * @param user The user to get all the devices from.
+ */
+export async function getAllDevices(user: PubKey): Promise<Array<PubKey>> {
+  const authorisations = await getPairingAuthorisations(user);
+  const devices = _.flatMap(
+    authorisations,
+    ({ primaryDevicePubKey, secondaryDevicePubKey }) => [
+      primaryDevicePubKey,
+      secondaryDevicePubKey,
+    ]
+  );
+
+  return [...new Set(devices)].map(p => new PubKey(p));
+}
+
+/**
+ * Get the primary device linked to a user.
+ *
+ * @param user The user to get primary device for.
+ */
+export async function getPrimaryDevice(user: PubKey): Promise<PrimaryPubKey> {
+  const authorisations = await getPairingAuthorisations(user);
+  if (authorisations.length === 0) {
+    return user;
+  }
+
+  const pubKey = PrimaryPubKey.from(authorisations[0].primaryDevicePubKey);
+  if (!pubKey) {
+    throw new Error(`Primary user public key is invalid for ${user.key}.`);
+  }
+
+  return pubKey;
+}
+
+/**
+ * Get all the secondary devices linked to a user.
+ *
+ * @param user The user to get the devices from.
+ */
+export async function getSecondaryDevices(
+  user: PubKey
+): Promise<Array<SecondaryPubKey>> {
+  const primary = await getPrimaryDevice(user);
+  const authorisations = await getPairingAuthorisations(primary);
+
+  return authorisations
+    .map(a => a.secondaryDevicePubKey)
+    .map(pubKey => new SecondaryPubKey(pubKey));
 }

ts/session/types/PubKey.ts

@@ -26,3 +26,6 @@ export class PubKey {
     return false;
   }
 }
+
+export class PrimaryPubKey extends PubKey {}
+export class SecondaryPubKey extends PubKey {}