@dxos/credentials 0.5.0 → 0.5.1-main.0ba1ecb

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

@@ -5,16 +5,23 @@
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type Credential, type SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { type AsyncCallback, Callback, ComplexMap } from '@dxos/util';
+import { type Credential, SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { 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;
 }
 
@@ -22,28 +29,29 @@ export interface MemberInfo {
  * Tracks the list of members (with roles) for the space.
  * Provides a list of admitted feeds.
  */
-export class MemberStateMachine {
-  private _creator: MemberInfo | undefined;
+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);
 
-  /**
-   * Member IDENTITY key => info
-   */
-  private _members = new ComplexMap<PublicKey, MemberInfo>(PublicKey.hash);
-
-  readonly onMemberAdmitted = new Callback<AsyncCallback<MemberInfo>>();
+  readonly onMemberRoleChanged = this._hashgraph.onSubjectStateChanged;
 
   constructor(private readonly _spaceKey: PublicKey) {}
 
   get creator(): MemberInfo | undefined {
-    return this._creator;
+    return this._ownerKey && this._hashgraph.getSubjectState(this._ownerKey);
   }
 
   get members(): ReadonlyMap<PublicKey, MemberInfo> {
-    return this._members;
+    return this._hashgraph.getState();
+  }
+
+  get membershipChainHeads(): PublicKey[] {
+    return this._hashgraph.getLeafIds();
   }
 
-  getRole(member: PublicKey): SpaceMember.Role | undefined {
-    return this._members.get(member)?.assertion.role;
+  getRole(member: PublicKey): SpaceMember.Role {
+    return this._getRole(this._hashgraph.getGlobalStateScope(), member);
   }
 
   /**
@@ -56,59 +64,109 @@ export class MemberStateMachine {
     switch (assertion['@type']) {
       case 'dxos.halo.credentials.SpaceMember': {
         invariant(assertion.spaceKey.equals(this._spaceKey));
-
-        // Ignore duplicate admissions.
-        if (this._members.has(credential.subject.id)) {
-          return;
+        if (this._ownerKey == null && credential.issuer === this._spaceKey) {
+          this._ownerKey = credential.subject.id;
         }
-
-        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;
+        if (assertion.profile != null) {
+          this._memberProfiles.set(credential.subject.id, assertion.profile);
         }
-
-        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);
+        await this._hashgraph.addVertex(credential, assertion);
         break;
       }
-
       case 'dxos.halo.credentials.MemberProfile': {
-        const member = this._members.get(credential.subject.id);
-        if (!member) {
-          log.warn('Member not found', { id: credential.subject.id });
-        } else {
+        const member = this._hashgraph.getSubjectState(credential.subject.id);
+        if (member) {
           member.profile = assertion.profile;
+        } else {
+          log.warn('Member not found', { id: credential.subject.id });
         }
+        this._memberProfiles.set(credential.subject.id, assertion.profile);
         break;
       }
-
       default:
         throw new Error('Invalid assertion type');
     }
   }
 
-  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;
+  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;
       }
     }
+    return realRole;
   }
 }

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

@@ -5,6 +5,7 @@
 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';
 
@@ -136,7 +137,7 @@ describe('SpaceStateMachine', () => {
       ),
     ).toEqual(true);
 
-    // Create the space member credential.
+    // // Create the space member credential.
     expect(
       await spaceState.process(
         await createCredential({
@@ -175,7 +176,7 @@ describe('SpaceStateMachine', () => {
           assertion: {
             '@type': 'dxos.halo.credentials.SpaceMember',
             spaceKey: space,
-            role: SpaceMember.Role.MEMBER,
+            role: SpaceMember.Role.EDITOR,
             genesisFeedKey: feed,
           },
           signer: keyring,
@@ -187,22 +188,25 @@ describe('SpaceStateMachine', () => {
     ).toEqual(true);
 
     expect(spaceState.genesisCredential).toBeDefined();
-    expect(Array.from(spaceState.members.values())).toMatchObject([
-      {
-        key: identity,
-        assertion: {
-          spaceKey: space,
-          role: SpaceMember.Role.ADMIN,
+    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,
+          },
         },
-      },
-      {
-        key: identity2,
-        assertion: {
-          spaceKey: space,
-          role: SpaceMember.Role.MEMBER,
+        {
+          key: identity2,
+          assertion: {
+            spaceKey: space,
+            role: SpaceMember.Role.EDITOR,
+          },
         },
-      },
-    ]);
+      ].sort(comparator),
+    );
     expect(Array.from(spaceState.feeds.values())).toMatchObject([]);
     expect(spaceState.credentials).toHaveLength(3);
   });

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

@@ -19,6 +19,7 @@ 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;
@@ -42,8 +43,6 @@ 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.
@@ -61,7 +60,7 @@ export class SpaceStateMachine implements SpaceState {
   private _credentialProcessors: CredentialConsumer<any>[] = [];
 
   readonly onCredentialProcessed = new Callback<AsyncCallback<Credential>>();
-  readonly onMemberAdmitted = this._members.onMemberAdmitted;
+  readonly onMemberRoleChanged = this._members.onMemberRoleChanged;
   readonly onFeedAdmitted = this._feeds.onFeedAdmitted;
   readonly onDelegatedInvitation = this._invitations.onDelegatedInvitation;
   readonly onDelegatedInvitationRemoved = this._invitations.onDelegatedInvitationRemoved;
@@ -76,6 +75,10 @@ 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;
   }
@@ -153,24 +156,6 @@ 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.');
@@ -184,7 +169,6 @@ export class SpaceStateMachine implements SpaceState {
           log.warn('Space genesis credential must be issued to space.');
           return false;
         }
-
         this._genesisCredential = credential;
         break;
       }
@@ -262,21 +246,16 @@ export class SpaceStateMachine implements SpaceState {
   }
 
   private _canInviteNewMembers(key: PublicKey): boolean {
-    return key.equals(this._spaceKey) || this._members.getRole(key) === SpaceMember.Role.ADMIN;
+    return (
+      key.equals(this._spaceKey) ||
+      this._members.getRole(key) === SpaceMember.Role.ADMIN ||
+      this._members.getRole(key) === SpaceMember.Role.OWNER
+    );
   }
 
   private _canAdmitFeeds(key: PublicKey): boolean {
     const role = this._members.getRole(key);
-    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']);
+    return role === SpaceMember.Role.EDITOR || role === SpaceMember.Role.ADMIN || role === SpaceMember.Role.OWNER;
   }
 }