@dxos/credentials 0.5.1-next.638da00 → 0.5.1-next.65aaa36

package/src/state-machine/member-state-machine.ts

@@ -5,23 +5,16 @@
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type Credential, SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { ComplexMap } from '@dxos/util';
+import { type Credential, type SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type AsyncCallback, Callback, ComplexMap } from '@dxos/util';
 
 import { getCredentialAssertion } from '../credentials';
-import {
-  type ChainVertex,
-  CredentialGraph,
-  type CredentialGraphStateHandler,
-  type PathState,
-  type StateScope,
-} from '../graph/credential-graph';
 
 export interface MemberInfo {
   key: PublicKey;
-  role: SpaceMember.Role;
   credential: Credential;
   assertion: SpaceMember;
+  removed: boolean;
   profile?: ProfileDocument;
 }
 
@@ -29,29 +22,28 @@ export interface MemberInfo {
  * Tracks the list of members (with roles) for the space.
  * Provides a list of admitted feeds.
  */
-export class MemberStateMachine implements CredentialGraphStateHandler<SpaceMember, MemberInfo> {
-  private _ownerKey: PublicKey | undefined;
-  private _memberProfiles = new ComplexMap<PublicKey, ProfileDocument | undefined>(PublicKey.hash);
-  private _hashgraph = new CredentialGraph<SpaceMember, MemberInfo>(this);
+export class MemberStateMachine {
+  private _creator: MemberInfo | undefined;
 
-  readonly onMemberRoleChanged = this._hashgraph.onSubjectStateChanged;
+  /**
+   * Member IDENTITY key => info
+   */
+  private _members = new ComplexMap<PublicKey, MemberInfo>(PublicKey.hash);
+
+  readonly onMemberAdmitted = new Callback<AsyncCallback<MemberInfo>>();
 
   constructor(private readonly _spaceKey: PublicKey) {}
 
   get creator(): MemberInfo | undefined {
-    return this._ownerKey && this._hashgraph.getSubjectState(this._ownerKey);
+    return this._creator;
   }
 
   get members(): ReadonlyMap<PublicKey, MemberInfo> {
-    return this._hashgraph.getState();
-  }
-
-  get membershipChainHeads(): PublicKey[] {
-    return this._hashgraph.getLeafIds();
+    return this._members;
   }
 
-  getRole(member: PublicKey): SpaceMember.Role {
-    return this._getRole(this._hashgraph.getGlobalStateScope(), member);
+  getRole(member: PublicKey): SpaceMember.Role | undefined {
+    return this._members.get(member)?.assertion.role;
   }
 
   /**
@@ -64,109 +56,59 @@ export class MemberStateMachine implements CredentialGraphStateHandler<SpaceMemb
     switch (assertion['@type']) {
       case 'dxos.halo.credentials.SpaceMember': {
         invariant(assertion.spaceKey.equals(this._spaceKey));
-        if (this._ownerKey == null && credential.issuer === this._spaceKey) {
-          this._ownerKey = credential.subject.id;
+
+        // Ignore duplicate admissions.
+        if (this._members.has(credential.subject.id)) {
+          return;
         }
-        if (assertion.profile != null) {
-          this._memberProfiles.set(credential.subject.id, assertion.profile);
+
+        const info: MemberInfo = {
+          key: credential.subject.id,
+          credential,
+          assertion,
+          removed: false,
+          profile: assertion.profile,
+        };
+
+        // NOTE: Assumes the first member processed is the creator.
+        if (!this._creator) {
+          this._creator = info;
         }
-        await this._hashgraph.addVertex(credential, assertion);
+
+        this._members.set(credential.subject.id, info);
+        log('member added', {
+          member: credential.subject.id,
+          space: this._spaceKey,
+          role: assertion.role,
+          profile: assertion.profile,
+        });
+
+        await this.onMemberAdmitted.callIfSet(info);
         break;
       }
+
       case 'dxos.halo.credentials.MemberProfile': {
-        const member = this._hashgraph.getSubjectState(credential.subject.id);
-        if (member) {
-          member.profile = assertion.profile;
-        } else {
+        const member = this._members.get(credential.subject.id);
+        if (!member) {
           log.warn('Member not found', { id: credential.subject.id });
+        } else {
+          member.profile = assertion.profile;
         }
-        this._memberProfiles.set(credential.subject.id, assertion.profile);
         break;
       }
+
       default:
         throw new Error('Invalid assertion type');
     }
   }
 
-  public createState(credential: Credential, assertion: SpaceMember): MemberInfo {
-    const memberKey = credential.subject.id;
-    return {
-      key: memberKey,
-      role: assertion.role,
-      credential,
-      assertion,
-      profile: this._memberProfiles.get(memberKey),
-    };
-  }
-
-  public isUpdateAllowed(scope: StateScope<SpaceMember>, credential: Credential, assertion: SpaceMember) {
-    if (assertion.role === SpaceMember.Role.OWNER) {
-      return credential!.issuer.equals(this._spaceKey);
-    }
-    const issuer = credential.issuer;
-    const isChangingOwnRole = issuer.equals(credential.subject.id);
-    if (isChangingOwnRole) {
-      return false;
-    }
-    if (issuer.equals(assertion.spaceKey)) {
-      return true;
-    }
-    const issuerRole = this._getRole(scope, issuer);
-    return issuerRole === SpaceMember.Role.ADMIN || issuerRole === SpaceMember.Role.OWNER;
-  }
-
-  public getConflictingPaths(
-    paths: PathState<SpaceMember>[],
-    update: ChainVertex<SpaceMember>,
-  ): PathState<SpaceMember>[] {
-    // a member can't be an issuer in a concurrent branch if we decided to remove or revoke admin permissions during merge
-    if (update.assertion.role !== SpaceMember.Role.REMOVED && update.assertion.role !== SpaceMember.Role.EDITOR) {
-      return [];
-    }
-    const memberId = update.credential!.subject.id!;
-    return paths.filter((p) => p.forkIssuers.has(memberId));
-  }
-
-  public tryPickWinningUpdate(
-    scope1: StateScope<SpaceMember>,
-    update1: Credential,
-    scope2: StateScope<SpaceMember>,
-    update2: Credential,
-  ): Credential | null {
-    const path1IssuerRole = this._getRole(scope1, update1.issuer);
-    const path2IssuerRole = this._getRole(scope2, update2.issuer);
-    if ((path2IssuerRole === SpaceMember.Role.OWNER) !== (path1IssuerRole === SpaceMember.Role.OWNER)) {
-      log('owner decision used to break the tie');
-      return path1IssuerRole === SpaceMember.Role.OWNER ? update1 : update2;
-    }
-    return null;
-  }
-
-  public toLogString(assertion: SpaceMember | undefined): string {
-    const role = assertion?.role ?? SpaceMember.Role.REMOVED;
-    return Object.entries(SpaceMember.Role).find(([_, value]) => value === role)![0];
-  }
-
-  public hasStateChanged(s1?: MemberInfo, s2?: MemberInfo): boolean {
-    return s1?.role !== s2?.role;
-  }
-
-  private _getRole(scope: StateScope<SpaceMember>, memberId: PublicKey): SpaceMember.Role {
-    if (this._ownerKey?.equals(memberId)) {
-      return SpaceMember.Role.OWNER;
-    }
-    const realRole = scope.state.get(memberId)?.assertion?.role ?? SpaceMember.Role.REMOVED;
-    if (scope.stateOverrides != null) {
-      const override = scope.stateOverrides.get(memberId);
-      if (override != null) {
-        log('member role overridden in path', () => ({
-          headId: scope.head?.id,
-          roleOverride: this.toLogString(override.assertion),
-          realRole: this.toLogString(scope.state.get(memberId)?.assertion),
-        }));
-        return override.assertion.role;
+  async onRevoked(revoked: Credential, revocation: Credential) {
+    invariant(revoked.id);
+    for (const member of this._members.values()) {
+      if (member.credential.id?.equals(revoked.id)) {
+        member.removed = true;
+        break;
       }
     }
-    return realRole;
   }
 }

package/src/state-machine/space-state-machine.test.ts

@@ -5,7 +5,6 @@
 import expect from 'expect';
 
 import { Keyring } from '@dxos/keyring';
-import { type PublicKey } from '@dxos/keys';
 import { AdmittedFeed, type Chain, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { describe, test } from '@dxos/test';
 
@@ -137,7 +136,7 @@ describe('SpaceStateMachine', () => {
       ),
     ).toEqual(true);
 
-    // // Create the space member credential.
+    // Create the space member credential.
     expect(
       await spaceState.process(
         await createCredential({
@@ -176,7 +175,7 @@ describe('SpaceStateMachine', () => {
           assertion: {
             '@type': 'dxos.halo.credentials.SpaceMember',
             spaceKey: space,
-            role: SpaceMember.Role.EDITOR,
+            role: SpaceMember.Role.MEMBER,
             genesisFeedKey: feed,
           },
           signer: keyring,
@@ -188,25 +187,22 @@ describe('SpaceStateMachine', () => {
     ).toEqual(true);
 
     expect(spaceState.genesisCredential).toBeDefined();
-    const comparator = (m1: { key: PublicKey }, m2: { key: PublicKey }) => m1.key.toHex().localeCompare(m2.key.toHex());
-    expect(Array.from(spaceState.members.values()).sort(comparator)).toMatchObject(
-      [
-        {
-          key: identity,
-          assertion: {
-            spaceKey: space,
-            role: SpaceMember.Role.ADMIN,
-          },
+    expect(Array.from(spaceState.members.values())).toMatchObject([
+      {
+        key: identity,
+        assertion: {
+          spaceKey: space,
+          role: SpaceMember.Role.ADMIN,
         },
-        {
-          key: identity2,
-          assertion: {
-            spaceKey: space,
-            role: SpaceMember.Role.EDITOR,
-          },
+      },
+      {
+        key: identity2,
+        assertion: {
+          spaceKey: space,
+          role: SpaceMember.Role.MEMBER,
         },
-      ].sort(comparator),
-    );
+      },
+    ]);
     expect(Array.from(spaceState.feeds.values())).toMatchObject([]);
     expect(spaceState.credentials).toHaveLength(3);
   });

package/src/state-machine/space-state-machine.ts

@@ -19,7 +19,6 @@ import { type CredentialProcessor } from '../processor/credential-processor';
 
 export interface SpaceState {
   readonly members: ReadonlyMap<PublicKey, MemberInfo>;
-  readonly membershipChainHeads: PublicKey[];
   readonly feeds: ReadonlyMap<PublicKey, FeedInfo>;
   readonly credentials: Credential[];
   readonly genesisCredential: Credential | undefined;
@@ -43,6 +42,8 @@ export type CredentialEntry = {
   revoked: boolean;
 };
 
+const REVOCABLE_CREDENTIALS = ['dxos.halo.credentials.SpaceMember'];
+
 /**
  * Validates and processes credentials for a single space.
  * Keeps a list of members and feeds.
@@ -60,7 +61,7 @@ export class SpaceStateMachine implements SpaceState {
   private _credentialProcessors: CredentialConsumer<any>[] = [];
 
   readonly onCredentialProcessed = new Callback<AsyncCallback<Credential>>();
-  readonly onMemberRoleChanged = this._members.onMemberRoleChanged;
+  readonly onMemberAdmitted = this._members.onMemberAdmitted;
   readonly onFeedAdmitted = this._feeds.onFeedAdmitted;
   readonly onDelegatedInvitation = this._invitations.onDelegatedInvitation;
   readonly onDelegatedInvitationRemoved = this._invitations.onDelegatedInvitationRemoved;
@@ -75,10 +76,6 @@ export class SpaceStateMachine implements SpaceState {
     return this._members.members;
   }
 
-  get membershipChainHeads(): PublicKey[] {
-    return this._members.membershipChainHeads;
-  }
-
   get feeds(): ReadonlyMap<PublicKey, FeedInfo> {
     return this._feeds.feeds;
   }
@@ -156,6 +153,24 @@ export class SpaceStateMachine implements SpaceState {
 
     const assertion = getCredentialAssertion(credential);
     switch (assertion['@type']) {
+      case 'dxos.halo.credentials.Revocation': {
+        if (!this._canRevokeCredentials(credential.issuer)) {
+          log.warn(`Space member is not authorized to invite new members: ${credential.issuer}`);
+          return false;
+        }
+        const toBeRevoked = this._credentialsById.get(credential.subject.id);
+        if (!toBeRevoked) {
+          log.warn(`Credential to revoke not found: ${credential.subject.id}`);
+          return false;
+        }
+        if (!this._credentialCanBeRevoked(toBeRevoked)) {
+          log.warn(`Credential cannot be revoked: ${credential.subject.id}`);
+        }
+
+        toBeRevoked.revoked = true;
+        await this._members.onRevoked(toBeRevoked.credential, credential);
+        break;
+      }
       case 'dxos.halo.credentials.SpaceGenesis': {
         if (this._genesisCredential) {
           log.warn('Space already has a genesis credential.');
@@ -169,6 +184,7 @@ export class SpaceStateMachine implements SpaceState {
           log.warn('Space genesis credential must be issued to space.');
           return false;
         }
+
         this._genesisCredential = credential;
         break;
       }
@@ -246,16 +262,21 @@ export class SpaceStateMachine implements SpaceState {
   }
 
   private _canInviteNewMembers(key: PublicKey): boolean {
-    return (
-      key.equals(this._spaceKey) ||
-      this._members.getRole(key) === SpaceMember.Role.ADMIN ||
-      this._members.getRole(key) === SpaceMember.Role.OWNER
-    );
+    return key.equals(this._spaceKey) || this._members.getRole(key) === SpaceMember.Role.ADMIN;
   }
 
   private _canAdmitFeeds(key: PublicKey): boolean {
     const role = this._members.getRole(key);
-    return role === SpaceMember.Role.EDITOR || role === SpaceMember.Role.ADMIN || role === SpaceMember.Role.OWNER;
+    return role === SpaceMember.Role.MEMBER || role === SpaceMember.Role.ADMIN;
+  }
+
+  private _canRevokeCredentials(key: PublicKey): boolean {
+    return key.equals(this._spaceKey) || this._members.getRole(key) === SpaceMember.Role.ADMIN;
+  }
+
+  private _credentialCanBeRevoked(entry: CredentialEntry) {
+    // TODO(dmaretskyi): Prohibit from removing space's creator member credential.
+    return REVOCABLE_CREDENTIALS.includes(entry.credential.subject.assertion['@type']);
   }
 }
 

package/dist/types/src/graph/credential-graph.d.ts

@@ -1,152 +0,0 @@
-import { PublicKey } from '@dxos/keys';
-import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { type AsyncCallback, Callback, ComplexMap, ComplexSet } from '@dxos/util';
-export declare class CredentialGraph<A, State> {
-    private readonly _stateHandler;
-    /**
-     * Local ids are used during traversals.
-     */
-    private _vertexIdGenerator;
-    /**
-     * All credentials without parent references are connected to the root.
-     */
-    private _root;
-    /**
-     * A credential which is not a parent of any other credential has the sentinel as a child.
-     * Sentinel is a virtual merge-point of all credentials.
-     */
-    private _sentinel;
-    /**
-     * Vertex references are used for fast credential inserts into the graph.
-     */
-    private _vertexByCredentialId;
-    /**
-     * The current state of the graph.
-     */
-    private _subjectToVertex;
-    private _subjectToState;
-    onSubjectStateChanged: Callback<AsyncCallback<State[]>>;
-    constructor(_stateHandler: CredentialGraphStateHandler<A, State>);
-    getSubjectState(subjectId: PublicKey): State | undefined;
-    getState(): ReadonlyMap<PublicKey, State>;
-    getLeafIds(): PublicKey[];
-    getGlobalStateScope(): StateScope<A>;
-    addVertex(credential: Credential, assertion: A): Promise<void>;
-    private _removeSentinelConnection;
-    private _onVertexInserted;
-    /**
-     * DFS the graph from root to sentinel pausing on merge points (nodes with multiple parents).
-     * Continue after all paths leading to a merge point converge by merging their states.
-     * In case of a concurrent update paths are replayed taking into account the state set
-     * by the winning branch.
-     */
-    private _recomputeState;
-    private _replayFailedPaths;
-    private _handleMergePoint;
-    private _updatePathState;
-    private _forkTraversal;
-    /**
-     * Updates the current graph state.
-     * @returns changed states.
-     */
-    private _setCurrentState;
-    private _leastCommonAncestor;
-    /**
-     * We might be merging paths where some of them had fork points after the initial forking.
-     * We need all the paths to point to the least common fork point and contain all the changes
-     * that happened after it.
-     */
-    private _moveUpToForkPoint;
-    private _mergePaths;
-    /**
-     * A candidate credential is preferred over the existing credential if:
-     *  1. It is the merge-point, because it's the last credential that was issued in awareness of all
-     *  the previously existing ones.
-     *  2. A path where candidate was set contains existing credential in it, which means that the candidate
-     *  was issued after the existing credential by a legitimate issuer.
-     *  3. A state-specific logic (_stateHandler) is able to justify using the candidate credential.
-     *  4. The path where candidate was set has more issuers than the existing path (longer branch).
-     *  5. The issuance time of the candidate is after the issuance time of the existing credential (LWW).
-     */
-    private _shouldOverrideCredential;
-    private _createRootPath;
-}
-export interface StateScope<A> {
-    head?: {
-        id: number;
-    };
-    state: ReadonlyMap<PublicKey, ChainVertex<A>>;
-    stateOverrides?: ReadonlyMap<PublicKey, ChainVertex<A>>;
-}
-export interface CredentialGraphStateHandler<Assertion, State> {
-    hasStateChanged(s1?: State, s2?: State): boolean;
-    createState(credential: Credential, assertion: Assertion): State;
-    isUpdateAllowed: (scope: StateScope<Assertion>, update: Credential, assertion: Assertion) => boolean;
-    getConflictingPaths(paths: PathState<Assertion>[], update: ChainVertex<Assertion>): PathState<Assertion>[];
-    tryPickWinningUpdate(scope1: StateScope<Assertion>, update1: Credential, scope2: StateScope<Assertion>, update2: Credential): Credential | null;
-    toLogString(assertion: Assertion): string;
-}
-export interface PathState<A> {
-    /**
-     * The current vertex position in path, always advances.
-     */
-    head: ChainVertex<A>;
-    /**
-     * Subject info local to the current path.
-     */
-    state: ComplexMap<PublicKey, ChainVertex<A>>;
-    /**
-     * Used during path replay to throw away cascading concurrent modifications.
-     * Overrides pathState.
-     */
-    stateOverrides?: ComplexMap<PublicKey, ChainVertex<A>>;
-    /**
-     * Used to faster search of conflicting branches. Is different from pathState.keys()
-     * because pathState is not reset on forks.
-     */
-    forkChangedSubjects: ComplexSet<PublicKey>;
-    /**
-     * Used to find winning branches. A branch wins if it had more participants.
-     * Ties are broken using credential issuance date.
-     */
-    forkIssuers: ComplexSet<PublicKey>;
-    /**
-     * All the credentials processed during this path traversal.
-     */
-    credentials: ComplexSet<PublicKey>;
-    /**
-     * PathState where we had multiple children in the current vertex.
-     * Will be merged with child branches when they converge.
-     */
-    forkPoint?: PathState<A>;
-    /**
-     * Used for a particular path replay with stateOverrides for conflict resolution
-     * forkVertexId is mapped to child vertex selection.
-     * Contains choices that lead to the current state. Value is an array when
-     * some branches converged before converging with the remaining branches.
-     */
-    chosenPath: {
-        [forkVertexId: number]: ChainVertex<A>[];
-    };
-}
-export interface ChainVertex<Assertion> {
-    /**
-     * The field is missing on root and sentinel vertices. Assertion is not undefined to avoid
-     * always asserting two fields.
-     */
-    credential?: Credential;
-    assertion: Assertion;
-    /**
-     * Local incrementing counter used to form paths. Is used only for causality resolution.
-     */
-    id: number;
-    /**
-     * Parents references are used to handle divergent branch merge-points.
-     */
-    parents: ChainVertex<Assertion>[];
-    /**
-     * Child references are traversed when computing the current state.
-     */
-    children: ChainVertex<Assertion>[];
-}
-//# sourceMappingURL=credential-graph.d.ts.map

package/dist/types/src/graph/credential-graph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"credential-graph.d.ts","sourceRoot":"","sources":["../../../../src/graph/credential-graph.ts"],"names":[],"mappings":"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"}

package/dist/types/src/state-machine/member-state-machine.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=member-state-machine.test.d.ts.map

package/dist/types/src/state-machine/member-state-machine.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"member-state-machine.test.d.ts","sourceRoot":"","sources":["../../../../src/state-machine/member-state-machine.test.ts"],"names":[],"mappings":""}