Corrideat/task/#2341 anyone can join invite issue

Gruntfile.js

@@ -44,7 +44,8 @@ const {
   MAX_EVENTS_AFTER = '',
   NODE_ENV = 'development',
   EXPOSE_SBP = '',
-  ENABLE_UNSAFE_NULL_CRYPTO = 'false'
+  ENABLE_UNSAFE_NULL_CRYPTO = 'false',
+  UNSAFE_TRUST_ALL_MANIFEST_SIGNING_KEYS = 'false'
 } = process.env
 
 if (!['development', 'production'].includes(NODE_ENV)) {
@@ -223,7 +224,8 @@ module.exports = (grunt) => {
         'process.env.MAX_EVENTS_AFTER': `'${MAX_EVENTS_AFTER}'`,
         'process.env.NODE_ENV': `'${NODE_ENV}'`,
         'process.env.EXPOSE_SBP': `'${EXPOSE_SBP}'`,
-        'process.env.ENABLE_UNSAFE_NULL_CRYPTO': `'${ENABLE_UNSAFE_NULL_CRYPTO}'`
+        'process.env.ENABLE_UNSAFE_NULL_CRYPTO': `'${ENABLE_UNSAFE_NULL_CRYPTO}'`,
+        'process.env.UNSAFE_TRUST_ALL_MANIFEST_SIGNING_KEYS': UNSAFE_TRUST_ALL_MANIFEST_SIGNING_KEYS
       },
       external: ['crypto', '*.eot', '*.ttf', '*.woff', '*.woff2'],
       format: 'esm',

frontend/controller/actions/group.js

@@ -3,8 +3,9 @@
 import { GIErrorUIRuntimeError, L, LError, LTags } from '@common/common.js'
 import {
   CHATROOM_PRIVACY_LEVEL,
-  INVITE_EXPIRES_IN_DAYS,
   INVITE_INITIAL_CREATOR,
+  INVITE_EXPIRES_IN_DAYS,
+  MAX_GROUP_MEMBER_COUNT,
   MESSAGE_TYPES,
   PROFILE_STATUS,
   PROPOSAL_GENERIC,
@@ -19,6 +20,7 @@ import {
   STATUS_EXPIRED,
   STATUS_CANCELLED
 } from '@model/contracts/shared/constants.js'
+import { doesGroupAnyoneCanJoinNeedUpdating } from '@model/contracts/shared/functions.js'
 import { merge, omit, randomIntFromRange } from '@model/contracts/shared/giLodash.js'
 import { DAYS_MILLIS, addTimeToDate, dateToPeriodStamp } from '@model/contracts/shared/time.js'
 import proposals, { oneVoteToPass, oneVoteToFail } from '@model/contracts/shared/voting/proposals.js'
@@ -38,6 +40,7 @@ import { Secret } from '~/shared/domains/chelonia/Secret.js'
 import type { ChelKeyRequestParams } from '~/shared/domains/chelonia/chelonia.js'
 import { encryptedOutgoingData, encryptedOutgoingDataWithRawKey } from '~/shared/domains/chelonia/encryptedData.js'
 import { CONTRACT_HAS_RECEIVED_KEYS, EVENT_HANDLED } from '~/shared/domains/chelonia/events.js'
+import { findKeyIdByName } from '~/shared/domains/chelonia/utils.js'
 // Using relative path to crypto.js instead of ~-path to workaround some esbuild bug
 import type { Key } from '../../../shared/domains/chelonia/crypto.js'
 import { CURVE25519XSALSA20POLY1305, EDWARDS25519SHA512BATCH, keyId, keygen, serializeKey } from '../../../shared/domains/chelonia/crypto.js'
@@ -180,8 +183,11 @@ export default (sbp('sbp/selectors/register', {
             ringLevel: Number.MAX_SAFE_INTEGER,
             permissions: [GIMessage.OP_KEY_REQUEST],
             meta: {
-              quantity: 60,
-              expires: Date.now() + DAYS_MILLIS * INVITE_EXPIRES_IN_DAYS.ON_BOARDING,
+              quantity: MAX_GROUP_MEMBER_COUNT,
+              ...(INVITE_EXPIRES_IN_DAYS.ON_BOARDING && {
+                expires:
+                await sbp('chelonia/time') * 1000 + DAYS_MILLIS * INVITE_EXPIRES_IN_DAYS.ON_BOARDING
+              }),
               private: {
                 content: inviteKeyS
               }
@@ -907,6 +913,70 @@ export default (sbp('sbp/selectors/register', {
       sbp('okTurtles.events/emit', REPLACE_MODAL, 'IncomeDetails')
     }
   },
+  'gi.actions/group/fixAnyoneCanJoinLink': function ({ contractID }) {
+    // Queue ensures that the update happens as atomically as possible
+    return sbp('chelonia/queueInvocation', `${contractID}-FIX-ANYONE-CAN-JOIN`, async () => {
+      const now = await sbp('chelonia/time') * 1000
+      const state = await sbp('chelonia/contract/wait', contractID).then(() => sbp('chelonia/contract/state', contractID))
+
+      const quantity = doesGroupAnyoneCanJoinNeedUpdating(state)
+      if (!quantity) {
+        if (quantity === false) {
+          console.warn('[gi.actions/group/fixAnyoneCanJoinLink] Group has already been updated', contractID, MAX_GROUP_MEMBER_COUNT)
+        } else {
+          console.warn('[gi.actions/group/fixAnyoneCanJoinLink] Already used MAX_GROUP_MEMBER_COUNT invites for group', contractID, MAX_GROUP_MEMBER_COUNT)
+        }
+        return
+      }
+
+      const CEKid = findKeyIdByName(state, 'cek')
+      const CSKid = findKeyIdByName(state, 'csk')
+
+      if (!CEKid || !CSKid) {
+        throw new Error('Contract is missing a CEK or CSK')
+      }
+
+      const inviteKey = keygen(EDWARDS25519SHA512BATCH)
+      const inviteKeyId = keyId(inviteKey)
+      const inviteKeyP = serializeKey(inviteKey, false)
+      const inviteKeyS = encryptedOutgoingData(state, CEKid, serializeKey(inviteKey, true))
+
+      const ik = {
+        id: inviteKeyId,
+        name: '#inviteKey-' + inviteKeyId,
+        purpose: ['sig'],
+        ringLevel: Number.MAX_SAFE_INTEGER,
+        permissions: [GIMessage.OP_KEY_REQUEST],
+        meta: {
+          quantity,
+          ...(INVITE_EXPIRES_IN_DAYS.ON_BOARDING && {
+            expires:
+          now + DAYS_MILLIS * INVITE_EXPIRES_IN_DAYS.ON_BOARDING
+          }),
+          private: {
+            content: inviteKeyS
+          }
+        },
+        data: inviteKeyP
+      }
+
+      // Replace all existing anyone-can-join invite links with the new one
+      const activeInvites = Object.keys(state.invites)
+        .filter(invite => state.invites[invite].creatorID === INVITE_INITIAL_CREATOR && !(state._vm.invites[invite].expires >= now))
+
+      await sbp('chelonia/out/keyAdd', {
+        contractName: 'gi.contracts/group',
+        contractID,
+        data: [ik],
+        signingKeyId: CSKid
+      })
+
+      await sbp('gi.actions/group/invite', { contractID, data: { inviteKeyId, creatorID: INVITE_INITIAL_CREATOR } })
+
+      // Revoke at the end
+      await Promise.all(activeInvites.map(inviteKeyId => sbp('gi.actions/group/inviteRevoke', { contractID, data: { inviteKeyId } })))
+    })
+  },
   ...encryptedAction('gi.actions/group/leaveChatRoom', L('Failed to leave chat channel.'), async (sendMessage, params) => {
     const state = await sbp('chelonia/contract/state', params.contractID)
     const memberID = params.data.memberID || sbp('chelonia/rootState').loggedIn.identityContractID
@@ -1041,6 +1111,7 @@ export default (sbp('sbp/selectors/register', {
   ...encryptedAction('gi.actions/group/updateSettings', L('Failed to update group settings.')),
   ...encryptedAction('gi.actions/group/updateAllVotingRules', (params, e) => L('Failed to update voting rules. {codeError}', { codeError: e.message })),
   ...encryptedAction('gi.actions/group/updateDistributionDate', L('Failed to update group distribution date.')),
+  ...encryptedAction('gi.actions/group/updateGroupInviteExpiry', L('Failed to update group invite expiry.')),
   ...encryptedAction('gi.actions/group/upgradeFrom1.0.7', L('Failed to upgrade from version 1.0.7')),
   ...((process.env.NODE_ENV === 'development' || process.env.CI) && {
     ...encryptedAction('gi.actions/group/forceDistributionDate', L('Failed to force distribution date.'))

frontend/model/contracts/shared/constants.js

@@ -93,7 +93,7 @@ export const MESSAGE_TYPES = {
 }
 
 export const INVITE_EXPIRES_IN_DAYS = {
-  ON_BOARDING: 30,
+  ON_BOARDING: null, // No expiration
   PROPOSAL: 7
 }
 

frontend/model/contracts/shared/functions.js

@@ -3,6 +3,8 @@
 import sbp from '@sbp/sbp'
 import { L } from '@common/common.js'
 import {
+  INVITE_INITIAL_CREATOR,
+  MAX_GROUP_MEMBER_COUNT,
   MESSAGE_TYPES,
   POLL_STATUS,
   PROPOSAL_GROUP_SETTING_CHANGE,
@@ -311,3 +313,38 @@ export const referenceTally = (selector: string): Object => {
     }
   }
 }
+
+export const doesGroupAnyoneCanJoinNeedUpdating = (state: Object): number | false => {
+  const hasBeenUpdated = Object.keys(state.invites).some(inviteId => {
+    return (
+      // See if there's an 'anyone can join' link
+      state.invites[inviteId].creatorID === INVITE_INITIAL_CREATOR &&
+      // that doesn't expire
+      state._vm.invites[inviteId].expires == null
+    )
+  })
+  // If non-expiring 'anyone can join' links are found, the contract
+  // doesn't need to be updated
+  if (hasBeenUpdated) return false
+
+  // Add up all all used 'anyone can join' invite links
+  // Then, we take the difference and, if the number is less than
+  // MAX_GROUP_MEMBER_COUNT, we need to create a new invite.
+  const usedInvites = Object.keys(state.invites)
+    // First, we only want 'anyone can join invites'
+    .filter(invite => state.invites[invite].creatorID === INVITE_INITIAL_CREATOR)
+    // The reduce function adds the number of 'used' invites in an invite
+    // link across all existing (expired or not) invites
+    .reduce((acc, cv) => acc +
+      (
+        // For this, we take the difference between the `initialQuantity`
+        // and the 'available' invites (`quantity`, which represents how
+        // many invites are available, if the invite was still valid)
+        (state._vm.invites[cv].initialQuantity - state._vm.invites[cv].quantity) || 0
+      ), 0
+    )
+
+  const quantity = Math.max(MAX_GROUP_MEMBER_COUNT - usedInvites, 0)
+
+  return quantity
+}

frontend/model/contracts/shared/time.js

@@ -6,6 +6,7 @@ export const MINS_MILLIS = 60000
 export const HOURS_MILLIS = 60 * MINS_MILLIS
 export const DAYS_MILLIS = 24 * HOURS_MILLIS
 export const MONTHS_MILLIS = 30 * DAYS_MILLIS
+export const YEARS_MILLIS = 365 * DAYS_MILLIS
 
 export const plusOnePeriodLength = (timestamp: string, periodLength: number): string => (
   dateToPeriodStamp(addTimeToDate(timestamp, periodLength))
@@ -184,7 +185,12 @@ export function humanDate (
     : ((navigator.languages: any): string[]) ?? navigator.language ?? fallback
   // NOTE: `.toLocaleDateString()` automatically takes local timezone differences into account.
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
-  return new Date(date).toLocaleDateString(locale, options)
+  const dateObj = new Date(date)
+
+  // Avoid returning 'Invalid Date'
+  if (!isNaN(dateObj.valueOf())) return dateObj.toLocaleDateString(locale, options)
+
+  return ''
 }
 
 export function isPeriodStamp (arg: string): boolean {

frontend/model/state.js

@@ -6,6 +6,8 @@
 import sbp from '@sbp/sbp'
 import { L } from '@common/common.js'
 import { EVENT_HANDLED, CONTRACT_REGISTERED } from '~/shared/domains/chelonia/events.js'
+import { doesGroupAnyoneCanJoinNeedUpdating } from '@model/contracts/shared/functions.js'
+import { INVITE_STATUS } from '~/shared/domains/chelonia/constants.js'
 import { LOGOUT } from '~/frontend/utils/events.js'
 import Vue from 'vue'
 import Vuex from 'vuex'
@@ -22,6 +24,57 @@ import identityGetters from './contracts/shared/getters/identity.js'
 import notificationModule from '~/frontend/model/notifications/vuexModule.js'
 import settingsModule from '~/frontend/model/settings/vuexModule.js'
 import chatroomModule from '~/frontend/model/chatroom/vuexModule.js'
+import { CHELONIA_RESET, CONTRACTS_MODIFIED } from '../../shared/domains/chelonia/events.js'
+
+// Wrapper function for performing contract upgrades and migrations
+// TODO: Consider moving this function into a different file
+const contractUpdate = (initialState: Object, updateFn: (state: Object, contractIDHints: ?string[]) => any, contractType: ?string) => {
+  // Wrapper for the update function. This performs a common check, namely that
+  // the contract is of a certain type, which helps return early
+  const wrappedUpdateFn = contractType
+  // The following disable is because eslint gets confused with 'Object'
+  // eslint-disable-next-line no-use-before-define
+    ? (state: Object, contractIDHints: ?string[]) => {
+        if (Array.isArray(contractIDHints)) {
+          if (!contractIDHints.reduce((acc, contractID) => {
+            return (acc || state.contracts[contractID]?.type === contractType)
+          }, false)) return
+        }
+        updateFn(state, contractIDHints)
+      }
+    : updateFn
+
+  const resetHandler = () => {
+    sbp('okTurtles.events/off', CONTRACTS_MODIFIED, modifiedHandler)
+  }
+  // This function is called when the set of subscribed contracts is modified
+  const modifiedHandler = (_, { added }) => {
+    // Wait for the added contracts to be ready, then call the update function
+    sbp('chelonia/contract/wait', added).then(() => {
+      const state = sbp('state/vuex/state')
+      wrappedUpdateFn(state, added)
+    })
+  }
+
+  // Add event listeners for `CONTRACTS_MODIFIED` and `CHELONIA_RESET` events
+  // `CONTRACTS_MODIFIED` is the important event. This is what allows updating
+  // contracts that are newly synced (for example, when logging in for the
+  // first time or joining an existing group or chatroom)
+  sbp('okTurtles.events/on', CONTRACTS_MODIFIED, modifiedHandler)
+  // Receiving `CHELONIA_RESET` means that a new session has started. To prevent
+  // memory leaks and duplicate handlers, this event will remove the
+  // `CONTRACTS_MODIFIED` handler.
+  sbp('okTurtles.events/once', CHELONIA_RESET, resetHandler)
+
+  // Call the update function in the next tick
+  // We want this (in addition to `CONTRACTS_MODIFIED`) because this way we
+  // can update contracts that already exist, e.g., upon login with a saved
+  // state
+  const existingContracts = Object.keys(initialState.contracts)
+  setTimeout(() => {
+    wrappedUpdateFn(initialState, existingContracts)
+  }, 0)
+}
 
 Vue.use(Vuex)
 
@@ -51,6 +104,21 @@ const checkedUsername = (state: Object, username: string, userID: string) => {
   }
 }
 
+// Find the 'anyone can join' invite ID. Since there could be multiple, and some
+// of those could have exipred, we need a for loop
+const anyoneCanJoinInviteId = (invites: Object, getters: Object): ?string =>
+  Object.keys(invites).find(invite =>
+    // First, we want 'anyone can join' invites
+    invites[invite].creatorID === INVITE_INITIAL_CREATOR &&
+    // and that haven't been revoked
+    getters.currentGroupState._vm.invites[invite].status === INVITE_STATUS.VALID &&
+    // and that haven't expired (using negative logic because expires could be
+    // undefined for non expiring-invites)
+    !(getters.currentGroupState._vm.invites[invite].expires >= Date.now()) &&
+    // and that that haven't been entirely used up
+    !(getters.currentGroupState._vm.invites[invite].quantity <= 0)
+  )
+
 const reactiveDate = Vue.observable({ date: new Date() })
 setInterval(function () {
   // We want the getters to recalculate all of the payments within 1 minute of us entering a new period.
@@ -90,7 +158,7 @@ sbp('sbp/selectors/register', {
       // $FlowFixMe[incompatible-call]
       Vue.set(state, 'reverseNamespaceLookups', Object.fromEntries(Object.entries(state.namespaceLookups).map(([k, v]: [string, string]) => [v, k])))
     }
-    (() => {
+    contractUpdate(state, (state: Object, contractIDHints: ?string[]) => {
       // Upgrade from version 1.0.7 to a newer version
       // The new group contract introduces a breaking change: the
       // `state[groupID].chatRooms[chatRoomID].members[memberID].joinedHeight`
@@ -101,6 +169,7 @@ sbp('sbp/selectors/register', {
       if (!ourIdentityContractId || !state[ourIdentityContractId]?.groups) return
       Object.entries(state[ourIdentityContractId].groups).map(([groupID, { hasLeft }]: [string, Object]) => {
         if (hasLeft || !state[groupID]?.chatRooms) return undefined
+        if (Array.isArray(contractIDHints) && !contractIDHints.includes(groupID)) return undefined
         // $FlowFixMe[incompatible-use]
         return Object.values((state[groupID].chatRooms: { [string]: Object })).flatMap(({ members }) => {
           return Object.values(members)
@@ -117,13 +186,16 @@ sbp('sbp/selectors/register', {
           console.error('[state/vuex/postUpgradeVerification] Error during gi.actions/group/upgradeFrom1.0.7', contractID, e)
         })
       })
-    })();
-    (() => {
+    }, 'gi.contracts/group')
+    contractUpdate(state, (contractIDHints: ?string[]) => {
       // Upgrade from version 1.0.8 to a newer version
       // The new chatroom contracts have an admin IDs list
       // This code checks if the attribute is missing, and if so, issues the
       // corresponing upgrade action.
-      const needsUpgrade = (chatroomID) => !Array.isArray(state[chatroomID]?.attributes?.adminIDs)
+      const needsUpgrade = (chatroomID) => {
+        if (Array.isArray(contractIDHints) && !contractIDHints.includes(chatroomID)) return false
+        return !Array.isArray(state[chatroomID]?.attributes?.adminIDs)
+      }
 
       const upgradeAction = async (contractID: string, data?: Object) => {
         try {
@@ -157,7 +229,23 @@ sbp('sbp/selectors/register', {
           upgradeAction(contractID)
         })
       }
-    })()
+    }, 'gi.contracts/chatroom')
+    contractUpdate(state, (contractIDHints: ?string[]) => {
+      // Update expired invites
+      // If fewer than MAX_GROUP_MEMBER_COUNT 'anyone can join' have been used,
+      // create a new 'anyone can join' link up to MAX_GROUP_MEMBER_COUNT invites
+      const ourIdentityContractId = state.loggedIn?.identityContractID
+      if (!ourIdentityContractId || !state[ourIdentityContractId]?.groups) return
+      Object.entries(state[ourIdentityContractId].groups).map(([groupID, { hasLeft }]: [string, Object]) => {
+        const groupState = state[groupID]
+        if (hasLeft || !groupState?.invites) return undefined
+        if (Array.isArray(contractIDHints) && !contractIDHints.includes(groupID)) return undefined
+        const needsUpdate = !!doesGroupAnyoneCanJoinNeedUpdating(groupState)
+        return needsUpdate ? groupID : undefined
+      }).filter(Boolean).forEach((contractID) => {
+        sbp('gi.actions/group/fixAnyoneCanJoinLink', { contractID }).catch(e => console.error(`[state/vuex/postUpgradeVerification] Error during gi.actions/group/fixAnyoneCanJoinLink for ${contractID}:`, e))
+      })
+    }, 'gi.contracts/group')
   },
   'state/vuex/save': (encrypted: ?boolean, state: ?Object) => {
     return sbp('okTurtles.eventQueue/queueEvent', 'state/vuex/save', async function () {
@@ -499,8 +587,8 @@ const getters = {
   },
   currentWelcomeInvite (state, getters) {
     const invites = getters.currentGroupState.invites
-    const inviteId = Object.keys(invites).find(invite => invites[invite].creatorID === INVITE_INITIAL_CREATOR)
-    const expires = getters.currentGroupState._vm.authorizedKeys[inviteId].meta.expires
+    const inviteId = anyoneCanJoinInviteId(invites, getters)
+    const expires = getters.currentGroupState._vm.invites[inviteId].expires
     return { inviteId, expires }
   },
   // list of group names and contractIDs
@@ -552,7 +640,7 @@ const getters = {
     // $FlowFixMe[method-unbinding]
     return [groupMembersPending, getters.groupProfiles].flatMap(Object.keys)
       .filter(memberID => getters.groupProfiles[memberID] ||
-         getters.groupMembersPending[memberID].expires >= Date.now())
+         !(getters.groupMembersPending[memberID].expires < Date.now()))
       .map(memberID => {
         const { contractID, displayName, username } = getters.globalProfile(memberID) || groupMembersPending[memberID] || (getters.groupProfiles[memberID] ? { contractID: memberID } : {})
         return {