@graphprotocol/hypergraph 0.0.1

package/src/messages/types.ts

@@ -0,0 +1,506 @@
+import * as Schema from 'effect/Schema';
+
+import { InboxSenderAuthPolicy } from '../inboxes/types.js';
+import {
+  AcceptInvitationEvent,
+  CreateInvitationEvent,
+  CreateSpaceEvent,
+  CreateSpaceInboxEvent,
+  SpaceEvent,
+} from '../space-events/index.js';
+import { SignatureWithRecovery } from '../types.js';
+export const SignedUpdate = Schema.Struct({
+  update: Schema.Uint8Array,
+  accountAddress: Schema.String,
+  signature: SignatureWithRecovery,
+  updateId: Schema.String,
+});
+
+export const Updates = Schema.Struct({
+  updates: Schema.Array(SignedUpdate),
+  firstUpdateClock: Schema.Number,
+  lastUpdateClock: Schema.Number,
+});
+
+export type Updates = Schema.Schema.Type<typeof Updates>;
+
+export const KeyBox = Schema.Struct({
+  accountAddress: Schema.String,
+  ciphertext: Schema.String,
+  nonce: Schema.String,
+  authorPublicKey: Schema.String,
+});
+
+export type KeyBox = Schema.Schema.Type<typeof KeyBox>;
+
+export const KeyBoxWithKeyId = Schema.Struct({
+  ...KeyBox.fields,
+  id: Schema.String,
+});
+
+export type KeyBoxWithKeyId = Schema.Schema.Type<typeof KeyBoxWithKeyId>;
+
+export const IdentityKeyBox = Schema.Struct({
+  accountAddress: Schema.String,
+  ciphertext: Schema.String,
+  nonce: Schema.String,
+});
+
+export type IdentityKeyBox = Schema.Schema.Type<typeof IdentityKeyBox>;
+
+export const RequestCreateSpaceEvent = Schema.Struct({
+  type: Schema.Literal('create-space-event'),
+  spaceId: Schema.String,
+  event: CreateSpaceEvent,
+  keyBox: KeyBoxWithKeyId,
+  name: Schema.String,
+});
+
+export type RequestCreateSpaceEvent = Schema.Schema.Type<typeof RequestCreateSpaceEvent>;
+
+export const RequestConnectCreateSpaceEvent = Schema.Struct({
+  type: Schema.Literal('connect-create-space-event'),
+  spaceId: Schema.String,
+  event: CreateSpaceEvent,
+  keyBox: KeyBoxWithKeyId,
+  infoContent: Schema.String,
+  infoSignature: SignatureWithRecovery,
+  name: Schema.String,
+});
+
+export type RequestConnectCreateSpaceEvent = Schema.Schema.Type<typeof RequestConnectCreateSpaceEvent>;
+
+export const RequestCreateInvitationEvent = Schema.Struct({
+  type: Schema.Literal('create-invitation-event'),
+  spaceId: Schema.String,
+  event: CreateInvitationEvent,
+  keyBoxes: Schema.Array(KeyBoxWithKeyId),
+});
+
+export const RequestConnectAddAppIdentityToSpaces = Schema.Struct({
+  type: Schema.Literal('connect-add-app-identity-to-spaces'),
+  appIdentityAddress: Schema.String,
+  spacesInput: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+      keyBoxes: Schema.Array(KeyBoxWithKeyId),
+    }),
+  ),
+});
+
+export type RequestConnectAddAppIdentityToSpaces = Schema.Schema.Type<typeof RequestConnectAddAppIdentityToSpaces>;
+
+export type RequestCreateInvitationEvent = Schema.Schema.Type<typeof RequestCreateInvitationEvent>;
+
+export const RequestAcceptInvitationEvent = Schema.Struct({
+  type: Schema.Literal('accept-invitation-event'),
+  spaceId: Schema.String,
+  event: AcceptInvitationEvent,
+});
+
+export type RequestAcceptInvitationEvent = Schema.Schema.Type<typeof RequestAcceptInvitationEvent>;
+
+export const RequestSubscribeToSpace = Schema.Struct({
+  type: Schema.Literal('subscribe-space'),
+  id: Schema.String,
+  lastKnownUpdateClock: Schema.optional(Schema.Number),
+});
+
+export type RequestSubscribeToSpace = Schema.Schema.Type<typeof RequestSubscribeToSpace>;
+
+export const RequestListSpaces = Schema.Struct({
+  type: Schema.Literal('list-spaces'),
+});
+
+export type RequestListSpaces = Schema.Schema.Type<typeof RequestListSpaces>;
+
+export const RequestListInvitations = Schema.Struct({
+  type: Schema.Literal('list-invitations'),
+});
+
+export type RequestListInvitations = Schema.Schema.Type<typeof RequestListInvitations>;
+
+export const RequestCreateUpdate = Schema.Struct({
+  type: Schema.Literal('create-update'),
+  accountAddress: Schema.String,
+  update: Schema.Uint8Array,
+  spaceId: Schema.String,
+  updateId: Schema.String, // used to identify the confirmation message
+  signature: SignatureWithRecovery,
+});
+
+export const RequestCreateAccountInbox = Schema.Struct({
+  type: Schema.Literal('create-account-inbox'),
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  encryptionPublicKey: Schema.String,
+  signature: SignatureWithRecovery,
+});
+
+export type RequestCreateAccountInbox = Schema.Schema.Type<typeof RequestCreateAccountInbox>;
+
+export const RequestCreateSpaceInboxEvent = Schema.Struct({
+  type: Schema.Literal('create-space-inbox-event'),
+  spaceId: Schema.String,
+  event: CreateSpaceInboxEvent,
+});
+
+export type RequestCreateSpaceInboxEvent = Schema.Schema.Type<typeof RequestCreateSpaceInboxEvent>;
+
+export const RequestGetLatestSpaceInboxMessages = Schema.Struct({
+  type: Schema.Literal('get-latest-space-inbox-messages'),
+  spaceId: Schema.String,
+  inboxId: Schema.String,
+  since: Schema.Date,
+});
+
+export type RequestGetLatestSpaceInboxMessages = Schema.Schema.Type<typeof RequestGetLatestSpaceInboxMessages>;
+
+export const RequestGetLatestAccountInboxMessages = Schema.Struct({
+  type: Schema.Literal('get-latest-account-inbox-messages'),
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  since: Schema.Date,
+});
+
+export type RequestGetLatestAccountInboxMessages = Schema.Schema.Type<typeof RequestGetLatestAccountInboxMessages>;
+
+export const RequestGetAccountInboxes = Schema.Struct({
+  type: Schema.Literal('get-account-inboxes'),
+});
+
+export type RequestGetAccountInboxes = Schema.Schema.Type<typeof RequestGetAccountInboxes>;
+
+export const RequestMessage = Schema.Union(
+  RequestCreateSpaceEvent,
+  RequestCreateInvitationEvent,
+  RequestAcceptInvitationEvent,
+  RequestSubscribeToSpace,
+  RequestListSpaces,
+  RequestListInvitations,
+  RequestCreateUpdate,
+  RequestCreateAccountInbox,
+  RequestCreateSpaceInboxEvent,
+  RequestGetLatestSpaceInboxMessages,
+  RequestGetLatestAccountInboxMessages,
+  RequestGetAccountInboxes,
+);
+
+export type RequestMessage = Schema.Schema.Type<typeof RequestMessage>;
+
+export type RequestCreateUpdate = Schema.Schema.Type<typeof RequestCreateUpdate>;
+
+export const RequestLoginNonce = Schema.Struct({
+  accountAddress: Schema.String,
+});
+
+export type RequestLoginNonce = Schema.Schema.Type<typeof RequestLoginNonce>;
+
+export const RequestLogin = Schema.Struct({
+  accountAddress: Schema.String,
+  message: Schema.String,
+  signature: Schema.String,
+});
+
+export type RequestLogin = Schema.Schema.Type<typeof RequestLogin>;
+
+export const RequestLoginWithSigningKey = Schema.Struct({
+  accountAddress: Schema.String,
+  message: Schema.String,
+  publicKey: Schema.String,
+  signature: Schema.String,
+});
+
+export type RequestLoginWithSigningKey = Schema.Schema.Type<typeof RequestLoginWithSigningKey>;
+
+export const RequestCreateIdentity = Schema.Struct({
+  keyBox: IdentityKeyBox,
+  accountProof: Schema.String,
+  keyProof: Schema.String,
+  message: Schema.String,
+  signaturePublicKey: Schema.String,
+  encryptionPublicKey: Schema.String,
+  signature: Schema.String,
+});
+
+export type RequestCreateIdentity = Schema.Schema.Type<typeof RequestCreateIdentity>;
+
+export const RequestConnectCreateIdentity = Schema.Struct({
+  keyBox: IdentityKeyBox,
+  accountProof: Schema.String,
+  keyProof: Schema.String,
+  signaturePublicKey: Schema.String,
+  encryptionPublicKey: Schema.String,
+});
+
+export type RequestConnectCreateIdentity = Schema.Schema.Type<typeof RequestConnectCreateIdentity>;
+
+export const RequestConnectCreateAppIdentity = Schema.Struct({
+  appId: Schema.String,
+  address: Schema.String,
+  ciphertext: Schema.String,
+  nonce: Schema.String,
+  signaturePublicKey: Schema.String,
+  encryptionPublicKey: Schema.String,
+  accountProof: Schema.String,
+  keyProof: Schema.String,
+});
+
+export type RequestConnectCreateAppIdentity = Schema.Schema.Type<typeof RequestConnectCreateAppIdentity>;
+
+export const ResponseConnectCreateIdentity = Schema.Struct({
+  success: Schema.Boolean,
+});
+
+export type ResponseConnectCreateIdentity = Schema.Schema.Type<typeof ResponseConnectCreateIdentity>;
+
+export const RequestCreateSpaceInboxMessage = Schema.Struct({
+  ciphertext: Schema.String,
+  signature: Schema.optional(SignatureWithRecovery),
+  authorAccountAddress: Schema.optional(Schema.String),
+});
+
+export type RequestCreateSpaceInboxMessage = Schema.Schema.Type<typeof RequestCreateSpaceInboxMessage>;
+
+export const RequestCreateAccountInboxMessage = Schema.Struct({
+  ciphertext: Schema.String,
+  signature: Schema.optional(SignatureWithRecovery),
+  authorAccountAddress: Schema.optional(Schema.String),
+});
+
+export type RequestCreateAccountInboxMessage = Schema.Schema.Type<typeof RequestCreateAccountInboxMessage>;
+
+export const ResponseListSpaces = Schema.Struct({
+  type: Schema.Literal('list-spaces'),
+  spaces: Schema.Array(
+    Schema.Struct({
+      id: Schema.String,
+    }),
+  ),
+});
+
+export type ResponseListSpaces = Schema.Schema.Type<typeof ResponseListSpaces>;
+
+export const Invitation = Schema.Struct({
+  id: Schema.String,
+  previousEventHash: Schema.String,
+  spaceId: Schema.String,
+});
+
+export type Invitation = Schema.Schema.Type<typeof Invitation>;
+
+export const ResponseListInvitations = Schema.Struct({
+  type: Schema.Literal('list-invitations'),
+  invitations: Schema.Array(Invitation),
+});
+
+export type ResponseListInvitations = Schema.Schema.Type<typeof ResponseListInvitations>;
+
+export const ResponseSpaceEvent = Schema.Struct({
+  type: Schema.Literal('space-event'),
+  spaceId: Schema.String,
+  event: SpaceEvent,
+});
+
+export type ResponseSpaceEvent = Schema.Schema.Type<typeof ResponseSpaceEvent>;
+
+export const InboxMessage = Schema.Struct({
+  id: Schema.String,
+  ciphertext: Schema.String,
+  signature: Schema.optional(SignatureWithRecovery),
+  authorAccountAddress: Schema.optional(Schema.String),
+  createdAt: Schema.Date,
+});
+
+export type InboxMessage = Schema.Schema.Type<typeof InboxMessage>;
+
+export const SpaceInbox = Schema.Struct({
+  inboxId: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  encryptionPublicKey: Schema.String,
+  secretKey: Schema.String,
+});
+
+export type SpaceInbox = Schema.Schema.Type<typeof SpaceInbox>;
+
+export const AccountInbox = Schema.Struct({
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  encryptionPublicKey: Schema.String,
+  signature: SignatureWithRecovery,
+});
+
+export type AccountInbox = Schema.Schema.Type<typeof AccountInbox>;
+
+export const ResponseAccountInbox = Schema.Struct({
+  type: Schema.Literal('account-inbox'),
+  inbox: AccountInbox,
+});
+
+export type ResponseAccountInbox = Schema.Schema.Type<typeof ResponseAccountInbox>;
+
+export const ResponseSpace = Schema.Struct({
+  type: Schema.Literal('space'),
+  id: Schema.String,
+  events: Schema.Array(SpaceEvent),
+  keyBoxes: Schema.Array(KeyBoxWithKeyId),
+  updates: Schema.optional(Updates),
+  inboxes: Schema.Array(SpaceInbox),
+});
+
+export type ResponseSpace = Schema.Schema.Type<typeof ResponseSpace>;
+
+export const ResponseUpdateConfirmed = Schema.Struct({
+  type: Schema.Literal('update-confirmed'),
+  updateId: Schema.String,
+  clock: Schema.Number,
+  spaceId: Schema.String,
+});
+
+export type ResponseUpdateConfirmed = Schema.Schema.Type<typeof ResponseUpdateConfirmed>;
+
+export const ResponseUpdatesNotification = Schema.Struct({
+  type: Schema.Literal('updates-notification'),
+  updates: Updates,
+  spaceId: Schema.String,
+});
+
+export type ResponseUpdatesNotification = Schema.Schema.Type<typeof ResponseUpdatesNotification>;
+
+export const ResponseSpaceInboxMessage = Schema.Struct({
+  type: Schema.Literal('space-inbox-message'),
+  spaceId: Schema.String,
+  inboxId: Schema.String,
+  message: InboxMessage,
+});
+
+export type ResponseSpaceInboxMessage = Schema.Schema.Type<typeof ResponseSpaceInboxMessage>;
+
+export const ResponseSpaceInboxMessages = Schema.Struct({
+  type: Schema.Literal('space-inbox-messages'),
+  spaceId: Schema.String,
+  inboxId: Schema.String,
+  messages: Schema.Array(InboxMessage),
+});
+
+export type ResponseSpaceInboxMessages = Schema.Schema.Type<typeof ResponseSpaceInboxMessages>;
+
+export const ResponseAccountInboxMessage = Schema.Struct({
+  type: Schema.Literal('account-inbox-message'),
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  message: InboxMessage,
+});
+
+export type ResponseAccountInboxMessage = Schema.Schema.Type<typeof ResponseAccountInboxMessage>;
+
+export const ResponseAccountInboxMessages = Schema.Struct({
+  type: Schema.Literal('account-inbox-messages'),
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  messages: Schema.Array(InboxMessage),
+});
+
+export type ResponseAccountInboxMessages = Schema.Schema.Type<typeof ResponseAccountInboxMessages>;
+
+export const ResponseAccountInboxes = Schema.Struct({
+  type: Schema.Literal('account-inboxes'),
+  inboxes: Schema.Array(AccountInbox),
+});
+
+export type ResponseAccountInboxes = Schema.Schema.Type<typeof ResponseAccountInboxes>;
+
+export const ResponseMessage = Schema.Union(
+  ResponseListSpaces,
+  ResponseListInvitations,
+  ResponseSpace,
+  ResponseSpaceEvent,
+  ResponseUpdateConfirmed,
+  ResponseUpdatesNotification,
+  ResponseAccountInbox,
+  ResponseSpaceInboxMessage,
+  ResponseSpaceInboxMessages,
+  ResponseAccountInboxMessage,
+  ResponseAccountInboxMessages,
+  ResponseAccountInboxes,
+);
+
+export type ResponseMessage = Schema.Schema.Type<typeof ResponseMessage>;
+
+export const ResponseIdentityEncrypted = Schema.Struct({
+  keyBox: IdentityKeyBox,
+});
+
+export type ResponseIdentityEncrypted = Schema.Schema.Type<typeof ResponseIdentityEncrypted>;
+
+export const ResponseIdentity = Schema.Struct({
+  accountAddress: Schema.String,
+  signaturePublicKey: Schema.String,
+  encryptionPublicKey: Schema.String,
+  accountProof: Schema.String,
+  keyProof: Schema.String,
+});
+
+export type ResponseIdentity = Schema.Schema.Type<typeof ResponseIdentity>;
+
+export const SpaceInboxPublic = Schema.Struct({
+  inboxId: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  encryptionPublicKey: Schema.String,
+  creationEvent: CreateSpaceInboxEvent,
+});
+
+export type SpaceInboxPublic = Schema.Schema.Type<typeof SpaceInboxPublic>;
+
+export const ResponseSpaceInboxPublic = Schema.Struct({
+  inbox: SpaceInboxPublic,
+});
+
+export type ResponseSpaceInboxPublic = Schema.Schema.Type<typeof ResponseSpaceInboxPublic>;
+
+export const ResponseListSpaceInboxesPublic = Schema.Struct({
+  inboxes: Schema.Array(SpaceInboxPublic),
+});
+
+export type ResponseListSpaceInboxesPublic = Schema.Schema.Type<typeof ResponseListSpaceInboxesPublic>;
+
+export const AccountInboxPublic = Schema.Struct({
+  accountAddress: Schema.String,
+  inboxId: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  encryptionPublicKey: Schema.String,
+  signature: SignatureWithRecovery,
+});
+
+export type AccountInboxPublic = Schema.Schema.Type<typeof AccountInboxPublic>;
+
+export const ResponseAccountInboxPublic = Schema.Struct({
+  inbox: AccountInboxPublic,
+});
+
+export type ResponseAccountInboxPublic = Schema.Schema.Type<typeof ResponseAccountInboxPublic>;
+
+export const ResponseListAccountInboxesPublic = Schema.Struct({
+  inboxes: Schema.Array(AccountInboxPublic),
+});
+
+export type ResponseListAccountInboxesPublic = Schema.Schema.Type<typeof ResponseListAccountInboxesPublic>;
+
+export const ResponseIdentityNotFoundError = Schema.Struct({
+  accountAddress: Schema.String,
+});
+
+export type ResponseIdentityNotFoundError = Schema.Schema.Type<typeof ResponseIdentityNotFoundError>;
+
+export const ResponseIdentityExistsError = Schema.Struct({
+  accountAddress: Schema.String,
+});
+
+export type ResponseIdentityExistsError = Schema.Schema.Type<typeof ResponseIdentityExistsError>;

package/src/space-events/accept-invitation.ts

@@ -0,0 +1,36 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Effect } from 'effect';
+
+import { canonicalize, generateId, hexToBytes, stringToUint8Array } from '../utils/index.js';
+import type { AcceptInvitationEvent, Author } from './types.js';
+
+type Params = {
+  author: Author;
+  previousEventHash: string;
+};
+
+export const acceptInvitation = ({
+  author,
+  previousEventHash,
+}: Params): Effect.Effect<AcceptInvitationEvent, undefined> => {
+  const transaction = {
+    id: generateId(),
+    type: 'accept-invitation' as const,
+    previousEventHash,
+  };
+  const encodedTransaction = stringToUint8Array(canonicalize(transaction));
+  const signatureResult = secp256k1.sign(encodedTransaction, hexToBytes(author.signaturePrivateKey), {
+    prehash: true,
+  });
+
+  return Effect.succeed({
+    transaction,
+    author: {
+      accountAddress: author.accountAddress,
+      signature: {
+        hex: signatureResult.toCompactHex(),
+        recovery: signatureResult.recovery,
+      },
+    },
+  });
+};

package/src/space-events/apply-event.ts

@@ -0,0 +1,150 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { sha256 } from '@noble/hashes/sha256';
+import { Effect, Schema } from 'effect';
+import type { InvalidIdentityError, PublicIdentity } from '../identity/types.js';
+import { canonicalize, stringToUint8Array } from '../utils/index.js';
+import { hashEvent } from './hash-event.js';
+import {
+  type ApplyError,
+  InvalidEventError,
+  SpaceEvent,
+  type SpaceInbox,
+  type SpaceInvitation,
+  type SpaceMember,
+  type SpaceState,
+  VerifySignatureError,
+} from './types.js';
+
+type Params = {
+  state: SpaceState | undefined;
+  event: SpaceEvent;
+  getVerifiedIdentity: (accountAddress: string) => Effect.Effect<PublicIdentity, InvalidIdentityError>;
+};
+
+const decodeSpaceEvent = Schema.decodeUnknownEither(SpaceEvent);
+
+export const applyEvent = ({
+  state,
+  event: rawEvent,
+  getVerifiedIdentity,
+}: Params): Effect.Effect<SpaceState, ApplyError> => {
+  const decodedEvent = decodeSpaceEvent(rawEvent);
+  if (decodedEvent._tag === 'Left') {
+    return decodedEvent.left;
+  }
+  const event = decodedEvent.right;
+
+  if (event.transaction.type !== 'create-space') {
+    if (state === undefined) {
+      return Effect.fail(new InvalidEventError());
+    }
+    if (event.transaction.previousEventHash !== state.lastEventHash) {
+      return Effect.fail(new InvalidEventError());
+    }
+  }
+
+  const encodedTransaction = stringToUint8Array(canonicalize(event.transaction));
+
+  let signatureInstance = secp256k1.Signature.fromCompact(event.author.signature.hex);
+  signatureInstance = signatureInstance.addRecoveryBit(event.author.signature.recovery);
+  const authorPublicKey = `0x${signatureInstance.recoverPublicKey(sha256(encodedTransaction)).toHex()}`;
+
+  return Effect.gen(function* () {
+    const identity = yield* getVerifiedIdentity(event.author.accountAddress);
+    if (authorPublicKey !== identity.signaturePublicKey) {
+      yield* Effect.fail(new VerifySignatureError());
+    }
+
+    let id = '';
+    let members: { [accountAddress: string]: SpaceMember } = {};
+    let removedMembers: { [accountAddress: string]: SpaceMember } = {};
+    let invitations: { [id: string]: SpaceInvitation } = {};
+    let inboxes: { [inboxId: string]: SpaceInbox } = {};
+    if (event.transaction.type === 'create-space') {
+      id = event.transaction.id;
+      members[event.transaction.creatorAccountAddress] = {
+        accountAddress: event.transaction.creatorAccountAddress,
+        role: 'admin',
+      };
+    } else if (state !== undefined) {
+      id = state.id;
+      members = { ...state.members };
+      removedMembers = { ...state.removedMembers };
+      invitations = { ...state.invitations };
+      inboxes = { ...state.inboxes };
+      if (event.transaction.type === 'accept-invitation') {
+        // is already a member
+        if (members[event.author.accountAddress] !== undefined) {
+          yield* Effect.fail(new InvalidEventError());
+        }
+
+        // find the invitation
+        const result = Object.entries(invitations).find(
+          ([, invitation]) => invitation.inviteeAccountAddress === event.author.accountAddress,
+        );
+        if (!result) {
+          yield* Effect.fail(new InvalidEventError());
+        }
+
+        // @ts-expect-error type issue? we checked that result is not undefined before
+        const [id, invitation] = result;
+
+        members[invitation.inviteeAccountAddress] = {
+          accountAddress: invitation.inviteeAccountAddress,
+          role: 'member',
+        };
+        delete invitations[id];
+        if (removedMembers[event.author.accountAddress] !== undefined) {
+          delete removedMembers[event.author.accountAddress];
+        }
+      } else {
+        // check if the author is an admin
+        if (members[event.author.accountAddress]?.role !== 'admin') {
+          yield* Effect.fail(new InvalidEventError());
+        }
+
+        if (event.transaction.type === 'delete-space') {
+          removedMembers = { ...members };
+          members = {};
+          invitations = {};
+        } else if (event.transaction.type === 'create-invitation') {
+          if (members[event.transaction.inviteeAccountAddress] !== undefined) {
+            yield* Effect.fail(new InvalidEventError());
+          }
+          for (const invitation of Object.values(invitations)) {
+            if (invitation.inviteeAccountAddress === event.transaction.inviteeAccountAddress) {
+              yield* Effect.fail(new InvalidEventError());
+            }
+          }
+
+          invitations[event.transaction.id] = {
+            inviteeAccountAddress: event.transaction.inviteeAccountAddress,
+          };
+        } else if (event.transaction.type === 'create-space-inbox') {
+          if (inboxes[event.transaction.inboxId] !== undefined) {
+            yield* Effect.fail(new InvalidEventError());
+          }
+          inboxes[event.transaction.inboxId] = {
+            inboxId: event.transaction.inboxId,
+            encryptionPublicKey: event.transaction.encryptionPublicKey,
+            isPublic: event.transaction.isPublic,
+            authPolicy: event.transaction.authPolicy,
+            secretKey: event.transaction.secretKey,
+          };
+        } else {
+          // state is required for all events except create-space
+          yield* Effect.fail(new InvalidEventError());
+        }
+      }
+    }
+
+    return {
+      id,
+      members,
+      removedMembers,
+      invitations,
+      inboxes,
+      lastEventHash: hashEvent(event),
+    };
+  });
+};