@graphprotocol/hypergraph 0.0.1 → 0.0.2

package/src/store.ts

@@ -1,10 +1,12 @@
 import type { AnyDocumentId, DocHandle, Repo } from '@automerge/automerge-repo';
 import { type Store, createStore } from '@xstate/store';
 import type { PrivateAppIdentity } from './connect/types.js';
+import type { DocumentContent } from './entity/types.js';
 import { mergeMessages } from './inboxes/merge-messages.js';
 import type { InboxSenderAuthPolicy } from './inboxes/types.js';
 import type { Invitation, Updates } from './messages/index.js';
 import type { SpaceEvent, SpaceState } from './space-events/index.js';
+import type { Mapping } from './types.js';
 import { idToAutomergeId } from './utils/automergeId.js';
 
 export type InboxMessageStorageEntry = {
@@ -42,15 +44,17 @@ export type AccountInboxStorageEntry = {
 
 export type SpaceStorageEntry = {
   id: string;
+  name: string;
   events: SpaceEvent[];
   state: SpaceState | undefined;
   keys: { id: string; key: string }[];
-  automergeDocHandle: DocHandle<unknown> | undefined;
+  automergeDocHandle: DocHandle<DocumentContent>;
   inboxes: SpaceInboxStorageEntry[];
 };
 
 interface StoreContext {
   spaces: SpaceStorageEntry[];
+  spacesLoadingIsPending: boolean;
   updatesInFlight: string[];
   invitations: Invitation[];
   repo: Repo | null;
@@ -66,10 +70,12 @@ interface StoreContext {
   identity: PrivateAppIdentity | null;
   lastUpdateClock: { [spaceId: string]: number };
   accountInboxes: AccountInboxStorageEntry[];
+  mapping: Mapping;
 }
 
 const initialStoreContext: StoreContext = {
   spaces: [],
+  spacesLoadingIsPending: true,
   updatesInFlight: [],
   invitations: [],
   repo: null,
@@ -78,14 +84,16 @@ const initialStoreContext: StoreContext = {
   identity: null,
   lastUpdateClock: {},
   accountInboxes: [],
+  mapping: {},
 };
 
 type StoreEvent =
   | { type: 'setInvitations'; invitations: Invitation[] }
+  | { type: 'setMapping'; mapping: Mapping }
   | { type: 'reset' }
   | { type: 'addUpdateInFlight'; updateId: string }
   | { type: 'removeUpdateInFlight'; updateId: string }
-  | { type: 'setSpaceFromList'; spaceId: string }
+  | { type: 'setSpacesList'; spaces: { id: string; name: string }[] }
   | { type: 'applyEvent'; spaceId: string; event: SpaceEvent; state: SpaceState }
   | { type: 'updateConfirmed'; spaceId: string; clock: number }
   | { type: 'applyUpdate'; spaceId: string; firstUpdateClock: number; lastUpdateClock: number }
@@ -122,6 +130,7 @@ type StoreEvent =
   | {
       type: 'setSpace';
       spaceId: string;
+      name: string;
       updates?: Updates;
       events: SpaceEvent[];
       inboxes?: SpaceInboxStorageEntry[];
@@ -154,9 +163,15 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
         invitations: event.invitations,
       };
     },
+    setMapping: (context, event: { mapping: Mapping }) => {
+      return {
+        ...context,
+        mapping: event.mapping,
+      };
+    },
     reset: (context) => {
       // once the repo is initialized, there is no need to reset it
-      return { ...initialStoreContext, repo: context.repo };
+      return { ...initialStoreContext, repo: context.repo, mapping: context.mapping };
     },
     addUpdateInFlight: (context, event: { updateId: string }) => {
       return {
@@ -170,56 +185,68 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
         updatesInFlight: context.updatesInFlight.filter((id) => id !== event.updateId),
       };
     },
-    setSpaceFromList: (context, event: { spaceId: string }) => {
+    setSpacesList: (context, event: { spaces: { id: string; name: string }[] }) => {
       if (!context.repo) {
         return context;
       }
-      const existingSpace = context.spaces.find((s) => s.id === event.spaceId);
-      const lastUpdateClock = context.lastUpdateClock[event.spaceId] ?? -1;
-      const result = context.repo.findWithProgress(idToAutomergeId(event.spaceId) as AnyDocumentId);
 
-      // set it to ready to interact with the document
-      result.handle.doneLoading();
+      let storeContext: StoreContext = { ...context, spacesLoadingIsPending: false };
 
-      if (existingSpace) {
-        return {
-          ...context,
-          spaces: context.spaces.map((existingSpace) => {
-            if (existingSpace.id === event.spaceId) {
-              const newSpace: SpaceStorageEntry = {
-                id: existingSpace.id,
-                events: existingSpace.events ?? [],
-                state: existingSpace.state,
-                keys: existingSpace.keys ?? [],
+      for (const space of event.spaces) {
+        const existingSpace = context.spaces.find((s) => s.id === space.id);
+        const lastUpdateClock = context.lastUpdateClock[space.id] ?? -1;
+        const result = context.repo.findWithProgress<DocumentContent>(idToAutomergeId(space.id) as AnyDocumentId);
+
+        // set it to ready to interact with the document
+        result.handle.doneLoading();
+
+        if (existingSpace) {
+          storeContext = {
+            ...storeContext,
+            spaces: storeContext.spaces.map((existingSpace) => {
+              if (existingSpace.id === space.id) {
+                const newSpace: SpaceStorageEntry = {
+                  id: existingSpace.id,
+                  name: existingSpace.name,
+                  events: existingSpace.events ?? [],
+                  state: existingSpace.state,
+                  keys: existingSpace.keys ?? [],
+                  automergeDocHandle: result.handle,
+                  inboxes: existingSpace.inboxes ?? [],
+                };
+                return newSpace;
+              }
+              return existingSpace;
+            }),
+            lastUpdateClock: {
+              ...storeContext.lastUpdateClock,
+              [space.id]: lastUpdateClock,
+            },
+          };
+        } else {
+          storeContext = {
+            ...storeContext,
+            spaces: [
+              ...storeContext.spaces,
+              {
+                id: space.id,
+                name: space.name,
+                events: [],
+                state: undefined,
+                keys: [],
+                inboxes: [],
                 automergeDocHandle: result.handle,
-                inboxes: existingSpace.inboxes ?? [],
-              };
-              return newSpace;
-            }
-            return existingSpace;
-          }),
-          lastUpdateClock: {
-            ...context.lastUpdateClock,
-            [event.spaceId]: lastUpdateClock,
-          },
-        };
+              },
+            ],
+            lastUpdateClock: {
+              ...storeContext.lastUpdateClock,
+              [space.id]: -1,
+            },
+          };
+        }
       }
-      return {
-        ...context,
-        spaces: [
-          ...context.spaces,
-          {
-            id: event.spaceId,
-            events: [],
-            state: undefined,
-            keys: [],
-            inboxes: [],
-            updates: [],
-            lastUpdateClock: -1,
-            automergeDocHandle: result.handle,
-          },
-        ],
-      };
+
+      return storeContext;
     },
     applyEvent: (context, event: { spaceId: string; event: SpaceEvent; state: SpaceState }) => {
       return {
@@ -398,6 +425,7 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
       context,
       event: {
         spaceId: string;
+        name: string;
         updates?: Updates;
         inboxes?: SpaceInboxStorageEntry[];
         events: SpaceEvent[];
@@ -410,11 +438,12 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
     ) => {
       const existingSpace = context.spaces.find((s) => s.id === event.spaceId);
       if (!existingSpace && context.repo) {
-        const result = context.repo.findWithProgress(idToAutomergeId(event.spaceId) as AnyDocumentId);
+        const result = context.repo.findWithProgress<DocumentContent>(idToAutomergeId(event.spaceId) as AnyDocumentId);
         // set it to ready to interact with the document
         result.handle.doneLoading();
 
         const newSpace: SpaceStorageEntry = {
+          name: event.name,
           id: event.spaceId,
           events: event.events,
           state: event.spaceState,
@@ -473,7 +502,8 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
       return {
         ...context,
         authenticated: true,
-        identity: event.identity,
+        // TODO: remove hard-coded account address and use the one from the identity
+        identity: { ...event.identity },
       };
     },
     resetAuth: (context) => {

package/src/type/type.ts

@@ -17,9 +17,11 @@ export const Point = Schema.transform(Schema.String, Schema.Array(Number), {
   encode: (points: readonly number[]) => points.join(','),
 });
 
-export const Relation = <S extends AnyNoContext>(schema: S) =>
-  Field({
+export const Relation = <S extends AnyNoContext>(schema: S) => {
+  const relationSchema = Field({
     select: Schema.Array(schema) as unknown as Schema.Schema<ReadonlyArray<EntityWithRelation<S>>>,
     insert: Schema.optional(Schema.Array(Schema.String)),
     update: Schema.Undefined,
   });
+  return relationSchema;
+};

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { Id as Grc20Id } from '@graphprotocol/grc-20';
 import * as Data from 'effect/Data';
 import * as Schema from 'effect/Schema';
 
@@ -19,13 +20,16 @@ export type ConnectAuthPayload = Schema.Schema.Type<typeof ConnectAuthPayload>;
 export const ConnectCallbackResult = Schema.Struct({
   appIdentityAddress: Schema.String,
   appIdentityAddressPrivateKey: Schema.String,
+  accountAddress: Schema.String,
+  permissionId: Schema.String,
   signaturePublicKey: Schema.String,
   signaturePrivateKey: Schema.String,
   encryptionPublicKey: Schema.String,
   encryptionPrivateKey: Schema.String,
   sessionToken: Schema.String,
   sessionTokenExpires: Schema.Date,
-  spaces: Schema.Array(Schema.Struct({ id: Schema.String })),
+  privateSpaces: Schema.Array(Schema.Struct({ id: Schema.String })),
+  publicSpaces: Schema.Array(Schema.Struct({ id: Schema.String })),
 });
 
 export type ConnectCallbackResult = Schema.Schema.Type<typeof ConnectCallbackResult>;
@@ -45,3 +49,17 @@ export class FailedToParseConnectAuthUrl extends Data.TaggedError('FailedToParse
 export class FailedToParseAuthCallbackUrl extends Data.TaggedError('FailedToParseAuthCallbackUrl')<{
   message: string;
 }> {}
+
+export type MappingEntry = {
+  typeIds: Grc20Id.Id[];
+  properties?: {
+    [key: string]: Grc20Id.Id;
+  };
+  relations?: {
+    [key: string]: Grc20Id.Id;
+  };
+};
+
+export type Mapping = {
+  [key: string]: MappingEntry;
+};

package/src/utils/automergeId.ts

@@ -4,7 +4,7 @@ import { parse as parseUuid, stringify as stringifyUuid } from 'uuid';
 /**
  * Converts a UUID into Base58Check
  */
-export function idToAutomergeId(uuid: string, _versionByte = 0x00) {
+export function idToAutomergeId(uuid: string) {
   const payload = parseUuid(uuid);
   return bs58check.encode(payload);
 }

package/dist/connect/prove-ownership.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prove-ownership.d.ts","sourceRoot":"","sources":["../../src/connect/prove-ownership.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,sBAAsB,GAAI,gBAAgB,MAAM,EAAE,WAAW,MAAM,KAAG,MAElF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,gBAAgB,MAAM,EAAE,WAAW,MAAM,KAAG,MAE9E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,QAAQ,MAAM,EACd,gBAAgB,MAAM,EACtB,MAAM,YAAY,KACjB,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAQpD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,gBAAgB,MAAM,EACtB,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,UAAU,MAAM,KACf,OAAO,CAAC,OAAO,CAwBjB,CAAC"}

package/src/connect/prove-ownership.ts

@@ -1,58 +0,0 @@
-import { type Hex, verifyMessage } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-
-import { publicKeyToAddress } from '../utils/index.js';
-import type { IdentityKeys, Signer } from './types.js';
-
-export const getAccountProofMessage = (accountAddress: string, publicKey: string): string => {
-  return `This message proves I am the owner of the account ${accountAddress} and the public key ${publicKey}`;
-};
-
-export const getKeyProofMessage = (accountAddress: string, publicKey: string): string => {
-  return `The public key ${publicKey} is owned by the account ${accountAddress}`;
-};
-
-export const proveIdentityOwnership = async (
-  signer: Signer,
-  accountAddress: string,
-  keys: IdentityKeys,
-): Promise<{ accountProof: string; keyProof: string }> => {
-  const publicKey = keys.signaturePublicKey;
-  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
-  const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
-  const accountProof = await signer.signMessage(accountProofMessage);
-  const account = privateKeyToAccount(keys.signaturePrivateKey as Hex);
-  const keyProof = await account.signMessage({ message: keyProofMessage });
-  return { accountProof, keyProof };
-};
-
-export const verifyIdentityOwnership = async (
-  accountAddress: string,
-  publicKey: string,
-  accountProof: string,
-  keyProof: string,
-): Promise<boolean> => {
-  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
-  const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
-  const validAccountProof = await verifyMessage({
-    address: accountAddress as Hex,
-    message: accountProofMessage,
-    signature: accountProof as Hex,
-  });
-  if (!validAccountProof) {
-    console.log('Invalid account proof');
-    return false;
-  }
-
-  const keyAddress = publicKeyToAddress(publicKey) as Hex;
-  const validKeyProof = await verifyMessage({
-    address: keyAddress,
-    message: keyProofMessage,
-    signature: keyProof as Hex,
-  });
-  if (!validKeyProof) {
-    console.log('Invalid key proof');
-    return false;
-  }
-  return true;
-};