@graphprotocol/hypergraph 0.0.1

package/src/space-events/create-inbox.ts

@@ -0,0 +1,56 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Effect } from 'effect';
+import type { InboxSenderAuthPolicy } from '../inboxes/types.js';
+import { canonicalize, generateId, hexToBytes, stringToUint8Array } from '../utils/index.js';
+import type { Author, CreateSpaceInboxEvent } from './types.js';
+
+export const createInbox = ({
+  author,
+  spaceId,
+  inboxId,
+  encryptionPublicKey,
+  secretKey,
+  isPublic,
+  authPolicy,
+  previousEventHash,
+}: {
+  author: Author;
+  spaceId: string;
+  inboxId: string;
+  encryptionPublicKey: string;
+  previousEventHash: string;
+  secretKey: string;
+  isPublic: boolean;
+  authPolicy: InboxSenderAuthPolicy;
+}): Effect.Effect<CreateSpaceInboxEvent, undefined> => {
+  const transaction = {
+    type: 'create-space-inbox' as const,
+    id: generateId(),
+    spaceId,
+    inboxId,
+    encryptionPublicKey,
+    secretKey,
+    isPublic,
+    authPolicy,
+    previousEventHash,
+  };
+  const signature = secp256k1.sign(
+    stringToUint8Array(canonicalize(transaction)),
+    hexToBytes(author.signaturePrivateKey),
+    { prehash: true },
+  );
+
+  // Create a SpaceEvent to create the inbox and sign it
+  const spaceEvent = {
+    transaction,
+    author: {
+      accountAddress: author.accountAddress,
+      signature: {
+        hex: signature.toCompactHex(),
+        recovery: signature.recovery,
+      },
+    },
+  } satisfies CreateSpaceInboxEvent;
+
+  return Effect.succeed(spaceEvent);
+};

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

@@ -0,0 +1,41 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Effect } from 'effect';
+
+import { canonicalize, generateId, hexToBytes, stringToUint8Array } from '../utils/index.js';
+import type { Author, CreateInvitationEvent } from './types.js';
+
+type Params = {
+  author: Author;
+  previousEventHash: string;
+  invitee: {
+    accountAddress: string;
+  };
+};
+
+export const createInvitation = ({
+  author,
+  previousEventHash,
+  invitee,
+}: Params): Effect.Effect<CreateInvitationEvent, undefined> => {
+  const transaction = {
+    id: generateId(),
+    type: 'create-invitation' as const,
+    inviteeAccountAddress: invitee.accountAddress,
+    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/create-space.ts

@@ -0,0 +1,35 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Effect } from 'effect';
+
+import { canonicalize, generateId, hexToBytes, stringToUint8Array } from '../utils/index.js';
+import type { Author, CreateSpaceEvent } from './types.js';
+
+type Params = {
+  author: Author;
+  spaceId?: string;
+};
+
+export const createSpace = ({ author, spaceId }: Params): Effect.Effect<CreateSpaceEvent, undefined> => {
+  const transaction = {
+    type: 'create-space' as const,
+    id: spaceId ?? generateId(),
+    creatorAccountAddress: author.accountAddress,
+  };
+  const encodedTransaction = stringToUint8Array(canonicalize(transaction));
+  const signatureResult = secp256k1.sign(encodedTransaction, hexToBytes(author.signaturePrivateKey), {
+    prehash: true,
+  });
+
+  const event: CreateSpaceEvent = {
+    transaction,
+    author: {
+      accountAddress: author.accountAddress,
+      signature: {
+        hex: signatureResult.toCompactHex(),
+        recovery: signatureResult.recovery,
+      },
+    },
+  };
+
+  return Effect.succeed(event);
+};

package/src/space-events/delete-space.ts

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

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

@@ -0,0 +1,10 @@
+import { blake3 } from '@noble/hashes/blake3';
+
+import { bytesToHex, canonicalize } from '../utils/index.js';
+
+import type { SpaceEvent } from './types.js';
+
+export const hashEvent = (event: SpaceEvent): string => {
+  const hash = blake3(canonicalize(event));
+  return bytesToHex(hash);
+};

package/src/space-events/index.ts

@@ -0,0 +1,8 @@
+export * from './accept-invitation.js';
+export * from './apply-event.js';
+export * from './create-inbox.js';
+export * from './create-invitation.js';
+export * from './create-space.js';
+export * from './delete-space.js';
+export * from './hash-event.js';
+export * from './types.js';

package/src/space-events/types.ts

@@ -0,0 +1,137 @@
+import type { ParseError } from 'effect/ParseResult';
+import * as Schema from 'effect/Schema';
+import type { InvalidIdentityError } from '../identity/types.js';
+import { InboxSenderAuthPolicy } from '../inboxes/types.js';
+import { SignatureWithRecovery } from '../types.js';
+
+export const EventAuthor = Schema.Struct({
+  accountAddress: Schema.String,
+  signature: SignatureWithRecovery,
+});
+
+export type EventAuthor = Schema.Schema.Type<typeof Author>;
+
+export const SpaceMember = Schema.Struct({
+  accountAddress: Schema.String,
+  role: Schema.Union(Schema.Literal('admin'), Schema.Literal('member')),
+});
+
+export type SpaceMember = Schema.Schema.Type<typeof SpaceMember>;
+
+export const SpaceInvitation = Schema.Struct({
+  inviteeAccountAddress: Schema.String,
+});
+
+export type SpaceInvitation = Schema.Schema.Type<typeof SpaceInvitation>;
+
+export const SpaceInbox = Schema.Struct({
+  inboxId: Schema.String,
+  encryptionPublicKey: Schema.String,
+  isPublic: Schema.Boolean,
+  authPolicy: InboxSenderAuthPolicy,
+  secretKey: Schema.String,
+});
+
+export type SpaceInbox = Schema.Schema.Type<typeof SpaceInbox>;
+
+export const SpaceState = Schema.Struct({
+  id: Schema.String,
+  invitations: Schema.Record({ key: Schema.String, value: SpaceInvitation }),
+  members: Schema.Record({ key: Schema.String, value: SpaceMember }),
+  removedMembers: Schema.Record({ key: Schema.String, value: SpaceMember }),
+  inboxes: Schema.Record({ key: Schema.String, value: SpaceInbox }),
+  lastEventHash: Schema.String,
+});
+
+export type SpaceState = Schema.Schema.Type<typeof SpaceState>;
+
+export const CreateSpaceEvent = Schema.Struct({
+  transaction: Schema.Struct({
+    type: Schema.Literal('create-space'),
+    id: Schema.String,
+    creatorAccountAddress: Schema.String,
+  }),
+  author: EventAuthor,
+});
+
+export type CreateSpaceEvent = Schema.Schema.Type<typeof CreateSpaceEvent>;
+
+export const DeleteSpaceEvent = Schema.Struct({
+  transaction: Schema.Struct({
+    type: Schema.Literal('delete-space'),
+    id: Schema.String,
+    previousEventHash: Schema.String,
+  }),
+  author: EventAuthor,
+});
+
+export type DeleteSpaceEvent = Schema.Schema.Type<typeof DeleteSpaceEvent>;
+
+export const CreateInvitationEvent = Schema.Struct({
+  transaction: Schema.Struct({
+    type: Schema.Literal('create-invitation'),
+    id: Schema.String,
+    inviteeAccountAddress: Schema.String,
+    previousEventHash: Schema.String,
+  }),
+  author: EventAuthor,
+});
+
+export type CreateInvitationEvent = Schema.Schema.Type<typeof CreateInvitationEvent>;
+
+export const CreateSpaceInboxEvent = Schema.Struct({
+  transaction: Schema.Struct({
+    type: Schema.Literal('create-space-inbox'),
+    id: Schema.String,
+    spaceId: Schema.String,
+    inboxId: Schema.String,
+    encryptionPublicKey: Schema.String,
+    secretKey: Schema.String,
+    isPublic: Schema.Boolean,
+    authPolicy: InboxSenderAuthPolicy,
+    previousEventHash: Schema.String,
+  }),
+  author: EventAuthor,
+});
+
+export type CreateSpaceInboxEvent = Schema.Schema.Type<typeof CreateSpaceInboxEvent>;
+
+export const AcceptInvitationEvent = Schema.Struct({
+  transaction: Schema.Struct({
+    id: Schema.String,
+    type: Schema.Literal('accept-invitation'),
+    previousEventHash: Schema.String,
+  }),
+  author: EventAuthor,
+});
+
+export type AcceptInvitationEvent = Schema.Schema.Type<typeof AcceptInvitationEvent>;
+
+export const SpaceEvent = Schema.Union(
+  CreateSpaceEvent,
+  DeleteSpaceEvent,
+  CreateInvitationEvent,
+  AcceptInvitationEvent,
+  CreateSpaceInboxEvent,
+);
+
+export type SpaceEvent = Schema.Schema.Type<typeof SpaceEvent>;
+
+export const Author = Schema.Struct({
+  accountAddress: Schema.String,
+  signaturePublicKey: Schema.String,
+  signaturePrivateKey: Schema.String,
+  encryptionPublicKey: Schema.String,
+});
+
+export type Author = Schema.Schema.Type<typeof Author>;
+
+export class VerifySignatureError {
+  readonly _tag = 'VerifySignatureError';
+}
+
+export class InvalidEventError {
+  readonly _tag = 'InvalidEventError';
+}
+
+export type ApplyError = ParseError | VerifySignatureError | InvalidEventError | InvalidIdentityError;

package/src/space-info/decrypt-space-info.ts

@@ -0,0 +1,22 @@
+import { bytesToUtf8 } from '@noble/hashes/utils';
+import * as Schema from 'effect/Schema';
+import { decryptMessage } from '../messages/index.js';
+import { hexToBytes } from '../utils/index.js';
+import { SpaceInfoContent } from './types.js';
+
+const decodeSpaceInfoContent = Schema.decodeSync(SpaceInfoContent);
+
+export const decryptSpaceInfo = ({
+  spaceInfo,
+  secretKey,
+}: {
+  spaceInfo: Uint8Array;
+  secretKey: string;
+}) => {
+  const decrypted = decryptMessage({
+    nonceAndCiphertext: spaceInfo,
+    secretKey: hexToBytes(secretKey),
+  });
+  const spaceInfoContent = decodeSpaceInfoContent(JSON.parse(bytesToUtf8(decrypted)));
+  return spaceInfoContent;
+};

package/src/space-info/encrypt-and-sign-space-info.ts

@@ -0,0 +1,50 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { utf8ToBytes } from '@noble/hashes/utils';
+import * as Schema from 'effect/Schema';
+import { encryptMessage } from '../messages/encrypt-message.js';
+import { canonicalize, hexToBytes, stringToUint8Array } from '../utils/index.js';
+import { SpaceInfoContent } from './types.js';
+
+interface EncryptAndSignInfoParams {
+  accountAddress: string;
+  name: string;
+  secretKey: string;
+  signaturePrivateKey: string;
+  spaceId: string;
+}
+
+const encodeSpaceInfoContent = Schema.encodeSync(SpaceInfoContent);
+
+export const encryptAndSignSpaceInfo = ({
+  accountAddress,
+  name,
+  secretKey,
+  signaturePrivateKey,
+  spaceId,
+}: EncryptAndSignInfoParams) => {
+  const infoContent = encryptMessage({
+    message: utf8ToBytes(JSON.stringify(encodeSpaceInfoContent({ name: name }))),
+    secretKey: hexToBytes(secretKey),
+  });
+
+  const messageToSign = stringToUint8Array(
+    canonicalize({
+      accountAddress,
+      infoContent,
+      spaceId,
+    }),
+  );
+
+  const recoverySignature = secp256k1.sign(messageToSign, hexToBytes(signaturePrivateKey), { prehash: true });
+
+  const signature = {
+    hex: recoverySignature.toCompactHex(),
+    recovery: recoverySignature.recovery,
+  };
+
+  return {
+    infoContent,
+    accountAddress,
+    signature,
+  };
+};

package/src/space-info/index.ts

@@ -0,0 +1,3 @@
+export * from './decrypt-space-info.js';
+export * from './encrypt-and-sign-space-info.js';
+export * from './types.js';

package/src/space-info/types.ts

@@ -0,0 +1,7 @@
+import * as Schema from 'effect/Schema';
+
+export const SpaceInfoContent = Schema.Struct({
+  name: Schema.String,
+});
+
+export type SpaceInfoContent = Schema.Schema.Type<typeof SpaceInfoContent>;