Don't use member functions from keyring

.github/workflows/node.js.yml

@@ -14,13 +14,13 @@ jobs:
     runs-on: ubuntu-latest 
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [12, 16, 18]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm ci
@@ -34,13 +34,13 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [16, 18]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm ci
@@ -50,13 +50,13 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        node-version: [10.x, 12.x, 14.x]
+        node-version: [16, 18]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm ci

.gitignore

@@ -44,6 +44,8 @@ build/Release
 node_modules/
 jspm_packages/
 
+pnpm-lock.yaml
+
 # TypeScript v1 declaration files
 typings/
 

README.md

@@ -174,9 +174,8 @@ _alias of `ssb.tribes.get`_
 ## API (Extras)
 
 These endpoints give you access to additional features, such as:
-- **registering groups or group-authors**:
+- **registering groups**:
     - `ssb.tribes.register(groupId, info, cb)`
-    - `ssb.tribes.registerAuthors(groupId, [authorId], cb)`
 - **linking your feed to a group**
     - `ssb.tribes.link.create({ group, name }, cb)`
 - **linking subGroups to a group**
@@ -207,19 +206,6 @@ where:
   - `scheme` *String* (optional) - a description of the key management scheme this key is part of
 - `cb`[ *Function* - a callback with signature `cb(err: Error, success: Boolean)`
 
-
-### `ssb.tribes.registerAuthors(groupId, [authorId], cb)`
-
-Makes an off-log note that some author(s) are part of a group.
-This is used to know which group keys to consider when you receive a private message from a particular author.
-
-_NOTE: mainly used internally_
-
-where:
-- `groupId` *String* - is a the id for the group you want to not these users are part of
-- `[authorId]` *Array* - is a connection of feedIds
-- `cb` *Function* - has signature `cb(err, success)`
-
 ### `ssb.tribes.poBox.create(opts, cb)`
 
 Creates a P.O. Box key-pair, which is like a one-way group messaging setup with a public and private curve25519 keypair.

envelope.js

@@ -74,7 +74,10 @@ module.exports = function Envelope (keystore, state) {
     }
 
     /* check my group keys */
-    const trial_group_keys = keystore.author.groupKeys(author)
+    const trial_group_keys = keystore.group.list().map(groupId => keystore.group.get(groupId)).flat()
+    // NOTE we naively try *every* group key. Several optimizations are possible to improve this (if needed)
+    // 1. keep "try all" approach, but bubble successful keys to the front (frequently active groups get quicker decrypts)
+    // 2. try only groups this message (given author) - cache group membership, and use this to inform keys tried
     readKey = unboxKey(envelope, feed_id, prev_msg_id, trial_group_keys, { maxAttempts: 1 })
     // NOTE the group recp is only allowed in the first slot,
     // so we only test group keys in that slot (maxAttempts: 1)

index.js

@@ -91,29 +91,58 @@ function init (ssb, config) {
 
   /* start listeners */
   const rebuildManager = new RebuildManager(ssb)
-  listen.addMember(ssb, m => {
-    const { root, groupKey } = m.value.content
-    ssb.get({ id: root, meta: true }, (err, groupInitMsg) => {
-      if (err) throw err
-
-      const groupId = buildGroupId({ groupInitMsg, groupKey })
-      const authors = unique([
-        groupInitMsg.value.author,
-        m.value.author,
-        ...m.value.content.recps.filter(isFeed)
-      ])
+  const processedNewAuthors = {}
+
+  function processAuthors (groupId, authors, adder, cb) {
+    if (processedNewAuthors[groupId] === undefined) processedNewAuthors[groupId] = new Set()
+
+    const newAuthors = authors.reduce((acc, author) => {
+      if (!processedNewAuthors[groupId].has(author)) acc.add(author)
+      return acc
+    }, new Set())
+    if (!newAuthors.size) return cb()
+
+    state.newAuthorListeners.forEach(fn => fn({ groupId, newAuthors: [...newAuthors] }))
+    // we don't rebuild if we're the person who added them
+    if (adder !== ssb.id) {
+      const reason = ['add-member', ...newAuthors].join('+')
+      rebuildManager.rebuild(reason)
+    }
+    newAuthors.forEach(author => processedNewAuthors[groupId].add(author))
+    cb()
+  }
 
-      keystore.processAddMember({ groupId, groupKey, root, authors }, (err, newAuthors) => {
+  pull(
+    listen.addMember(ssb),
+    pull.asyncMap((m, cb) => {
+      const { root, groupKey } = m.value.content
+      ssb.get({ id: root, meta: true }, (err, groupInitMsg) => {
         if (err) throw err
-        if (newAuthors.length) {
-          state.newAuthorListeners.forEach(fn => fn({ groupId, newAuthors }))
 
-          const reason = ['add-member', ...newAuthors].join()
-          rebuildManager.rebuild(reason)
+        const groupId = buildGroupId({ groupInitMsg, groupKey })
+        const authors = unique([
+          groupInitMsg.value.author,
+          m.value.author,
+          ...m.value.content.recps.filter(isFeed)
+        ])
+
+        const record = keystore.group.get(groupId)
+        // if we haven't been in the group since before, register the group
+        if (record == null) {
+          return keystore.group.register(groupId, { key: groupKey, root }, (err) => {
+            if (err) return cb(err)
+            processAuthors(groupId, authors, m.value.author, cb)
+          })
+        } else {
+          processAuthors(groupId, authors, m.value.author, cb)
         }
       })
+    }),
+    pull.drain(() => {}, (err) => {
+      if (err) console.error('Listening for new addMembers errored:', err)
     })
-  })
+  )
+
   listen.poBox(ssb, m => {
     const { poBoxId, key: poBoxKey } = m.value.content.keys.set
     keystore.processPOBox({ poBoxId, poBoxKey }, (err, isNew) => {
@@ -133,15 +162,25 @@ function init (ssb, config) {
           .forEach(id => ssb.replicate.request({ id, replicate: true }))
       })
 
-      state.loading.keystore.once((s) => {
-        const peers = new Set()
-        keystore.group.list()
-          .map(groupId => keystore.group.listAuthors(groupId))
-          .forEach(authors => authors.forEach(author => peers.add(author)))
-
-        peers.delete(ssb.id)
-        Array.from(peers)
-          .forEach(id => ssb.replicate.request({ id, replicate: true }))
+      state.loading.keystore.once(() => {
+        pull(
+          pull.values(keystore.group.list()),
+          paraMap(
+            (groupId, cb) => scuttle.group.listAuthors(groupId, (err, feedIds) => {
+              if (err) return cb(new Error('error listing authors to replicate on start'))
+              cb(null, feedIds)
+            }),
+            5
+          ),
+          pull.flatten(),
+          pull.unique(),
+          pull.drain(feedId => {
+            if (feedId === ssb.id) return
+            ssb.replicate.request({ id: feedId, replicate: true })
+          }, (err) => {
+            if (err) console.error('error on initializing replication of group members')
+          })
+        )
       })
     }
   })
@@ -198,8 +237,6 @@ function init (ssb, config) {
         const readKey = unboxer.key(initValue.content, initValue)
         if (!readKey) return cb(new Error('tribes.group.init failed, please try again while not publishing other messages'))
 
-        state.newAuthorListeners.forEach(fn => fn({ groupId: data.groupId, newAuthors: [ssb.id] }))
-
         // addMember the admin
         scuttle.group.addMember(data.groupId, [ssb.id], {}, (err) => {
           if (err) return cb(err)
@@ -259,24 +296,18 @@ function init (ssb, config) {
     register (groupId, info, cb) {
       keystore.group.register(groupId, info, cb)
     },
-    registerAuthors (groupId, authors, cb) {
-      keystore.group.registerAuthors(groupId, authors, (err) => err ? cb(err) : cb(null, true))
-    },
     create: tribeCreate,
     list: tribeList,
     get: tribeGet,
 
     invite (groupId, authorIds, opts = {}, cb) {
       scuttle.group.addMember(groupId, authorIds, opts, (err, data) => {
         if (err) return cb(err)
-        keystore.group.registerAuthors(groupId, authorIds, (err) => {
-          if (err) return cb(err)
-          cb(null, data)
-        })
+        cb(null, data)
       })
     },
     listAuthors (groupId, cb) {
-      onKeystoreReady(() => cb(null, keystore.group.listAuthors(groupId)))
+      scuttle.group.listAuthors(groupId, cb)
     },
 
     link: {

lib/get-group-tangle.js

@@ -18,6 +18,8 @@ module.exports = function GetGroupTangle (server, keystore) {
 
   pull(
     server.createLogStream({ live: true, old: false, private: true }),
+    // we need to have this here because rebuilds cause the stream to start again and updateCache isn't idempotent
+    pull.unique('key'),
     pull.drain(updateCache)
   )
   // server.post(m => server.get({ id: m.key, private: true, meta: true }, (err, msg) => {

listen.js

@@ -9,17 +9,16 @@ const mockSSB = { backlinks: true, query: true }
 const { isUpdate: isPOBox } = new CRUT(mockSSB, poBoxSpec).spec
 
 module.exports = {
-  addMember (ssb, emit) {
-    pull(
+  addMember (ssb) {
+    return pull(
       ssb.messagesByType({ type: 'group/add-member', private: true, live: true }),
       // NOTE this will run through all messages on each startup, which will help guarentee
       // all messages have been emitted AND processed
       // (same not true if we used a dummy flume-view)
       pull.filter(m => m.sync !== true),
-      pull.filter(isAddMember),
+      pull.filter(isAddMember)
       // NOTE we DO NOT filter our own messages out
       // this is important for rebuilding indexes and keystore state if we have to restore our feed
-      pull.drain(emit)
     )
   },
   poBox (ssb, emit) {

method/deprecated/application.js

@@ -7,6 +7,10 @@ const spec = require('../../spec/deprecated/application.js')
 
 let isWarned = false
 
+// WARNING 2023-09-04 (mix)
+// the test for this were causing problems so were deleted
+// this means changing this function is no longer safe
+
 module.exports = function Application (ssb) {
   const crut = new Crut(ssb, spec)
 

method/group.js

@@ -3,6 +3,7 @@ const { keySchemes } = require('private-group-spec')
 const { SecretKey } = require('ssb-private-group-keys')
 const bfe = require('ssb-bfe')
 const Crut = require('ssb-crut')
+const pull = require('pull-stream')
 
 const { groupId: buildGroupId, poBoxKeys } = require('../lib')
 const initSpec = require('../spec/group/init')
@@ -58,10 +59,7 @@ module.exports = function GroupMethods (ssb, keystore, state) {
 
           keystore.group.register(data.groupId, { key: data.groupKey, root: data.root }, (err) => {
             if (err) return cb(err)
-            keystore.group.registerAuthors(data.groupId, [ssb.id], (err) => {
-              if (err) return cb(err)
-              cb(null, data)
-            })
+            cb(null, data)
           })
         })
       })
@@ -93,6 +91,33 @@ module.exports = function GroupMethods (ssb, keystore, state) {
 
       ssb.publish(content, cb)
     },
+    listAuthors (groupId, cb) {
+      const query = [{
+        $filter: {
+          value: {
+            content: {
+              type: 'group/add-member'
+            }
+          }
+        }
+      }]
+
+      pull(
+        ssb.query.read({ query }),
+        pull.filter(addMemberSpec.isValid),
+        pull.filter(msg =>
+          groupId === msg.value.content.recps[0]
+        ),
+        pull.map(msg => msg.value.content.recps.slice(1)),
+        pull.flatten(),
+        pull.unique(),
+        pull.collect((err, members) => {
+          if (err) return cb(err)
+
+          return cb(null, members)
+        })
+      )
+    },
     addPOBox (groupId, cb) {
       const info = keystore.group.get(groupId)
       if (!info) return cb(new Error('unknown groupId: ' + groupId))

method/index.js

@@ -9,6 +9,7 @@ module.exports = function Method (ssb, keystore, state) {
     group: {
       init: patient(group.init),
       addMember: patient(group.addMember),
+      listAuthors: group.listAuthors,
       addPOBox: patient(group.addPOBox),
       getPOBox: group.getPOBox
     },