@graphprotocol/hypergraph 0.0.1 → 0.0.2

package/src/connect/types.ts

@@ -58,8 +58,10 @@ export type PublicAppIdentity = {
 export type PrivateAppIdentity = IdentityKeys & {
   address: string;
   addressPrivateKey: string;
+  permissionId: string;
   sessionToken: string;
   sessionTokenExpires: Date;
+  accountAddress: string;
 };
 
 export class InvalidIdentityError {

package/src/entity/decodedEntitiesCache.ts

@@ -5,7 +5,7 @@ export type QueryEntry = {
   data: Array<Entity<AnyNoContext>>; // holds the decoded entities of this query and must be a stable reference and use the same reference for the `entities` array
   listeners: Array<() => void>; // listeners to this query
   isInvalidated: boolean;
-  include: { [K in keyof Schema.Schema.Type<AnyNoContext>]?: Record<string, never> };
+  include: { [K in keyof Schema.Schema.Type<AnyNoContext>]?: Record<string, Record<string, never>> };
 };
 
 export type DecodedEntitiesCacheEntry = {

package/src/entity/findMany.ts

@@ -239,7 +239,7 @@ export function findMany<const S extends AnyNoContext>(
   handle: DocHandle<DocumentContent>,
   type: S,
   filter: EntityFilter<Schema.Schema.Type<S>> | undefined,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, never> } | undefined,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
 ): { entities: Readonly<Array<Entity<S>>>; corruptEntityIds: Readonly<Array<string>> } {
   const decode = Schema.decodeUnknownSync(type);
   // TODO: what's the right way to get the name of the type?
@@ -256,13 +256,13 @@ export function findMany<const S extends AnyNoContext>(
 
   const evaluateFilter = <T>(fieldFilter: EntityFieldFilter<T>, fieldValue: T): boolean => {
     // Handle NOT operator
-    if ('NOT' in fieldFilter && fieldFilter.NOT) {
-      return !evaluateFilter(fieldFilter.NOT, fieldValue);
+    if ('not' in fieldFilter && fieldFilter.not) {
+      return !evaluateFilter(fieldFilter.not, fieldValue);
     }
 
     // Handle OR operator
-    if ('OR' in fieldFilter) {
-      const orFilters = fieldFilter.OR;
+    if ('or' in fieldFilter) {
+      const orFilters = fieldFilter.or;
       if (Array.isArray(orFilters)) {
         return orFilters.some((orFilter) => evaluateFilter(orFilter as EntityFieldFilter<T>, fieldValue));
       }
@@ -337,13 +337,13 @@ export function findMany<const S extends AnyNoContext>(
 
   const evaluateEntityFilter = (entityFilter: EntityFilter<Schema.Schema.Type<S>>, entity: Entity<S>): boolean => {
     // handle top-level NOT operator
-    if ('NOT' in entityFilter && entityFilter.NOT) {
-      return !evaluateCrossFieldFilter(entityFilter.NOT, entity);
+    if ('not' in entityFilter && entityFilter.not) {
+      return !evaluateCrossFieldFilter(entityFilter.not, entity);
     }
 
     // handle top-level OR operator
-    if ('OR' in entityFilter && Array.isArray(entityFilter.OR)) {
-      return entityFilter.OR.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
+    if ('or' in entityFilter && Array.isArray(entityFilter.or)) {
+      return entityFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
     }
 
     // evaluate regular field filters
@@ -374,15 +374,17 @@ export function findMany<const S extends AnyNoContext>(
 
 const stableEmptyArray: Array<unknown> = [];
 
+export type FindManySubscription<S extends AnyNoContext> = {
+  subscribe: (callback: () => void) => () => void;
+  getEntities: () => Readonly<Array<Entity<S>>>;
+};
+
 export function subscribeToFindMany<const S extends AnyNoContext>(
   handle: DocHandle<DocumentContent>,
   type: S,
   filter: { [K in keyof Schema.Schema.Type<S>]?: EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, never> } | undefined,
-): {
-  subscribe: (callback: () => void) => () => void;
-  getEntities: () => Readonly<Array<Entity<S>>>;
-} {
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
+): FindManySubscription<S> {
   const queryKey = filter ? canonicalize(filter) : 'all';
   const decode = Schema.decodeUnknownSync(type);
   // TODO: what's the right way to get the name of the type?

package/src/entity/getEntityRelations.ts

@@ -6,7 +6,7 @@ export const getEntityRelations = <const S extends AnyNoContext>(
   entityId: string,
   type: S,
   doc: DocumentContent,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, never> } | undefined,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
 ) => {
   const relations: Record<string, Entity<AnyNoContext>> = {};
   for (const [fieldName, field] of Object.entries(type.fields)) {

package/src/entity/types.ts

@@ -55,8 +55,8 @@ export type EntityNumberFilter = {
   is?: number;
   greaterThan?: number;
   lessThan?: number;
-  NOT?: EntityNumberFilter;
-  OR?: EntityNumberFilter[];
+  not?: EntityNumberFilter;
+  or?: EntityNumberFilter[];
 };
 
 export type EntityTextFilter = {
@@ -65,21 +65,21 @@ export type EntityTextFilter = {
   endsWith?: string;
   contains?: string;
   equals?: string;
-  NOT?: EntityTextFilter;
-  OR?: EntityTextFilter[];
+  not?: EntityTextFilter;
+  or?: EntityTextFilter[];
 };
 
 export type CrossFieldFilter<T> = {
   [K in keyof T]?: EntityFieldFilter<T[K]>;
 } & {
-  OR?: Array<CrossFieldFilter<T>>;
-  NOT?: CrossFieldFilter<T>;
+  or?: Array<CrossFieldFilter<T>>;
+  not?: CrossFieldFilter<T>;
 };
 
 export type EntityFieldFilter<T> = {
   is?: T;
-  NOT?: EntityFieldFilter<T>;
-  OR?: Array<EntityFieldFilter<T>>;
+  not?: EntityFieldFilter<T>;
+  or?: Array<EntityFieldFilter<T>>;
 } & (T extends boolean
   ? {
       is?: boolean;

package/src/identity/auth-storage.ts

@@ -4,54 +4,64 @@ import type { Storage } from './types.js';
 export const storeIdentity = (storage: Storage, identity: PrivateAppIdentity) => {
   storage.setItem('hypergraph:app-identity-address', identity.address);
   storage.setItem('hypergraph:app-identity-address-private-key', identity.addressPrivateKey);
+  storage.setItem('hypergraph:app-identity-account-address', identity.accountAddress);
   storage.setItem('hypergraph:signature-public-key', identity.signaturePublicKey);
   storage.setItem('hypergraph:signature-private-key', identity.signaturePrivateKey);
   storage.setItem('hypergraph:encryption-public-key', identity.encryptionPublicKey);
   storage.setItem('hypergraph:encryption-private-key', identity.encryptionPrivateKey);
   storage.setItem('hypergraph:session-token', identity.sessionToken);
   storage.setItem('hypergraph:session-token-expires', identity.sessionTokenExpires.toISOString());
+  storage.setItem('hypergraph:permission-id', identity.permissionId);
 };
 
 export const loadIdentity = (storage: Storage): PrivateAppIdentity | null => {
   const address = storage.getItem('hypergraph:app-identity-address');
   const addressPrivateKey = storage.getItem('hypergraph:app-identity-address-private-key');
+  const accountAddress = storage.getItem('hypergraph:app-identity-account-address');
   const signaturePublicKey = storage.getItem('hypergraph:signature-public-key');
   const signaturePrivateKey = storage.getItem('hypergraph:signature-private-key');
   const encryptionPublicKey = storage.getItem('hypergraph:encryption-public-key');
   const encryptionPrivateKey = storage.getItem('hypergraph:encryption-private-key');
   const sessionToken = storage.getItem('hypergraph:session-token');
   const sessionTokenExpires = storage.getItem('hypergraph:session-token-expires');
+  const permissionId = storage.getItem('hypergraph:permission-id');
   if (
     !address ||
     !addressPrivateKey ||
+    !accountAddress ||
     !signaturePublicKey ||
     !signaturePrivateKey ||
     !encryptionPublicKey ||
     !encryptionPrivateKey ||
     !sessionToken ||
-    !sessionTokenExpires
+    !sessionTokenExpires ||
+    !permissionId
   ) {
     return null;
   }
   return {
     address,
     addressPrivateKey,
+    accountAddress,
     signaturePublicKey,
     signaturePrivateKey,
     encryptionPublicKey,
     encryptionPrivateKey,
     sessionToken,
     sessionTokenExpires: new Date(sessionTokenExpires),
+    permissionId,
   };
 };
 
 export const wipeIdentity = (storage: Storage) => {
   storage.removeItem('hypergraph:app-identity-address');
   storage.removeItem('hypergraph:app-identity-address-private-key');
+  storage.removeItem('hypergraph:app-identity-account-address');
   storage.removeItem('hypergraph:signature-public-key');
   storage.removeItem('hypergraph:signature-private-key');
   storage.removeItem('hypergraph:encryption-public-key');
   storage.removeItem('hypergraph:encryption-private-key');
   storage.removeItem('hypergraph:session-token');
   storage.removeItem('hypergraph:session-token-expires');
+  storage.removeItem('hypergraph:permission-id');
 };

package/src/identity/get-verified-identity.ts

@@ -1,4 +1,5 @@
 import * as Schema from 'effect/Schema';
+import type { Chain } from 'viem';
 import * as Messages from '../messages/index.js';
 import { store } from '../store.js';
 import { verifyIdentityOwnership } from './prove-ownership.js';
@@ -6,6 +7,8 @@ import { verifyIdentityOwnership } from './prove-ownership.js';
 export const getVerifiedIdentity = async (
   accountAddress: string,
   syncServerUri: string,
+  chain: Chain,
+  rpcUrl: string,
 ): Promise<{
   accountAddress: string;
   encryptionPublicKey: string;
@@ -32,9 +35,11 @@ export const getVerifiedIdentity = async (
       resDecoded.signaturePublicKey,
       resDecoded.accountProof,
       resDecoded.keyProof,
+      chain,
+      rpcUrl,
     ))
   ) {
-    throw new Error('Invalid identity');
+    throw new Error('Invalid identity in getVerifiedIdentity');
   }
 
   store.send({

package/src/identity/index.ts

@@ -1,6 +1,6 @@
 export * from './auth-storage.js';
 export * from './get-verified-identity.js';
 export * from './identity-encryption.js';
-export * from './logout.js';
 export * from './prove-ownership.js';
+export * from './logout.js';
 export * from './types.js';

package/src/identity/prove-ownership.ts

@@ -1,8 +1,9 @@
-import { type Hex, verifyMessage } from 'viem';
+import { http, type Chain, type Hex, type WalletClient, createPublicClient, verifyMessage } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
+import type { SmartAccountClient } from 'permissionless';
 import { publicKeyToAddress } from '../utils/index.js';
-import type { IdentityKeys, Signer } from './types.js';
+import type { IdentityKeys } 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}`;
@@ -12,15 +13,37 @@ export const getKeyProofMessage = (accountAddress: string, publicKey: string): s
   return `The public key ${publicKey} is owned by the account ${accountAddress}`;
 };
 
+export const accountProofDomain = {
+  name: 'Hypergraph',
+  version: '1',
+};
+
 export const proveIdentityOwnership = async (
-  signer: Signer,
+  walletClient: WalletClient,
+  smartAccountClient: SmartAccountClient,
   accountAddress: string,
   keys: IdentityKeys,
 ): Promise<{ accountProof: string; keyProof: string }> => {
+  if (!smartAccountClient.account) {
+    throw new Error('Smart account client does not have an account');
+  }
+  if (!smartAccountClient.chain) {
+    throw new Error('Smart account client does not have a chain');
+  }
   const publicKey = keys.signaturePublicKey;
-  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
   const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
-  const accountProof = await signer.signMessage(accountProofMessage);
+
+  const accountProof = await smartAccountClient.account.signTypedData({
+    message: {
+      message: getAccountProofMessage(accountAddress, publicKey),
+    },
+    types: {
+      Message: [{ name: 'message', type: 'string' }],
+    },
+    domain: accountProofDomain,
+    primaryType: 'Message',
+  });
+  console.log('accountProof', accountProof);
   const account = privateKeyToAccount(keys.signaturePrivateKey as Hex);
   const keyProof = await account.signMessage({ message: keyProofMessage });
   return { accountProof, keyProof };
@@ -31,12 +54,33 @@ export const verifyIdentityOwnership = async (
   publicKey: string,
   accountProof: string,
   keyProof: string,
+  chain: Chain,
+  rpcUrl: string,
 ): Promise<boolean> => {
-  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
   const keyProofMessage = getKeyProofMessage(accountAddress, publicKey);
-  const validAccountProof = await verifyMessage({
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(rpcUrl),
+  });
+  // console.log('publicClient', publicClient);
+  // console.log('rpcUrl', rpcUrl);
+  // console.log('chain', chain);
+
+  // console.log('accountProof', accountProof);
+  // console.log('accountAddress', accountAddress);
+  // console.log('publicKey', publicKey);
+
+  const accountProofMessage = getAccountProofMessage(accountAddress, publicKey);
+  const validAccountProof = await publicClient.verifyTypedData({
     address: accountAddress as Hex,
-    message: accountProofMessage,
+    message: {
+      message: accountProofMessage,
+    },
+    types: {
+      Message: [{ name: 'message', type: 'string' }],
+    },
+    domain: accountProofDomain,
+    primaryType: 'Message',
     signature: accountProof as Hex,
   });
   if (!validAccountProof) {

package/src/inboxes/message-validation.ts

@@ -1,3 +1,4 @@
+import type { Chain } from 'viem';
 import * as Identity from '../identity/index.js';
 import type * as Messages from '../messages/index.js';
 import type { AccountInboxStorageEntry, SpaceInboxStorageEntry } from '../store.js';
@@ -8,6 +9,8 @@ export const validateSpaceInboxMessage = async (
   inbox: SpaceInboxStorageEntry,
   spaceId: string,
   syncServerUri: string,
+  chain: Chain,
+  rpcUrl: string,
 ) => {
   if (message.signature) {
     if (inbox.authPolicy === 'anonymous') {
@@ -19,7 +22,12 @@ export const validateSpaceInboxMessage = async (
       return false;
     }
     const signer = recoverSpaceInboxMessageSigner(message, spaceId, inbox.inboxId);
-    const verifiedIdentity = await Identity.getVerifiedIdentity(message.authorAccountAddress, syncServerUri);
+    const verifiedIdentity = await Identity.getVerifiedIdentity(
+      message.authorAccountAddress,
+      syncServerUri,
+      chain,
+      rpcUrl,
+    );
     const isValid = signer === verifiedIdentity.signaturePublicKey;
     if (!isValid) {
       console.error('Invalid signature', signer, verifiedIdentity.signaturePublicKey);
@@ -39,6 +47,8 @@ export const validateAccountInboxMessage = async (
   inbox: AccountInboxStorageEntry,
   accountAddress: string,
   syncServerUri: string,
+  chain: Chain,
+  rpcUrl: string,
 ) => {
   if (message.signature) {
     if (inbox.authPolicy === 'anonymous') {
@@ -50,7 +60,12 @@ export const validateAccountInboxMessage = async (
       return false;
     }
     const signer = recoverAccountInboxMessageSigner(message, accountAddress, inbox.inboxId);
-    const verifiedIdentity = await Identity.getVerifiedIdentity(message.authorAccountAddress, syncServerUri);
+    const verifiedIdentity = await Identity.getVerifiedIdentity(
+      message.authorAccountAddress,
+      syncServerUri,
+      chain,
+      rpcUrl,
+    );
     const isValid = signer === verifiedIdentity.signaturePublicKey;
     if (!isValid) {
       console.error('Invalid signature', signer, verifiedIdentity.signaturePublicKey);

package/src/messages/types.ts

@@ -41,6 +41,7 @@ export const KeyBoxWithKeyId = Schema.Struct({
 export type KeyBoxWithKeyId = Schema.Schema.Type<typeof KeyBoxWithKeyId>;
 
 export const IdentityKeyBox = Schema.Struct({
+  signer: Schema.String,
   accountAddress: Schema.String,
   ciphertext: Schema.String,
   nonce: Schema.String,
@@ -60,6 +61,7 @@ export type RequestCreateSpaceEvent = Schema.Schema.Type<typeof RequestCreateSpa
 
 export const RequestConnectCreateSpaceEvent = Schema.Struct({
   type: Schema.Literal('connect-create-space-event'),
+  accountAddress: Schema.String,
   spaceId: Schema.String,
   event: CreateSpaceEvent,
   keyBox: KeyBoxWithKeyId,
@@ -80,6 +82,7 @@ export const RequestCreateInvitationEvent = Schema.Struct({
 export const RequestConnectAddAppIdentityToSpaces = Schema.Struct({
   type: Schema.Literal('connect-add-app-identity-to-spaces'),
   appIdentityAddress: Schema.String,
+  accountAddress: Schema.String,
   spacesInput: Schema.Array(
     Schema.Struct({
       id: Schema.String,
@@ -240,6 +243,7 @@ export type RequestConnectCreateIdentity = Schema.Schema.Type<typeof RequestConn
 export const RequestConnectCreateAppIdentity = Schema.Struct({
   appId: Schema.String,
   address: Schema.String,
+  accountAddress: Schema.String,
   ciphertext: Schema.String,
   nonce: Schema.String,
   signaturePublicKey: Schema.String,
@@ -277,6 +281,7 @@ export const ResponseListSpaces = Schema.Struct({
   spaces: Schema.Array(
     Schema.Struct({
       id: Schema.String,
+      name: Schema.String,
     }),
   ),
 });
@@ -347,6 +352,7 @@ export type ResponseAccountInbox = Schema.Schema.Type<typeof ResponseAccountInbo
 export const ResponseSpace = Schema.Struct({
   type: Schema.Literal('space'),
   id: Schema.String,
+  name: Schema.String,
   events: Schema.Array(SpaceEvent),
   keyBoxes: Schema.Array(KeyBoxWithKeyId),
   updates: Schema.optional(Updates),

package/src/store-connect.ts

@@ -90,7 +90,6 @@ type StoreEvent =
   | { type: 'reset' }
   | { type: 'addUpdateInFlight'; updateId: string }
   | { type: 'removeUpdateInFlight'; updateId: string }
-  | { type: 'setSpaceFromList'; spaceId: string }
   | { type: 'applyEvent'; spaceId: string; event: SpaceEvent; state: SpaceState }
   | { type: 'updateConfirmed'; spaceId: string; clock: number }
   | { type: 'applyUpdate'; spaceId: string; firstUpdateClock: number; lastUpdateClock: number }
@@ -127,6 +126,7 @@ type StoreEvent =
   | {
       type: 'setSpace';
       spaceId: string;
+      name: string;
       updates?: Updates;
       events: SpaceEvent[];
       inboxes?: SpaceInboxStorageEntry[];
@@ -177,57 +177,6 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
         updatesInFlight: context.updatesInFlight.filter((id) => id !== event.updateId),
       };
     },
-    setSpaceFromList: (context, event: { spaceId: 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();
-
-      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 ?? [],
-                automergeDocHandle: result.handle,
-                inboxes: existingSpace.inboxes ?? [],
-              };
-              return newSpace;
-            }
-            return existingSpace;
-          }),
-          lastUpdateClock: {
-            ...context.lastUpdateClock,
-            [event.spaceId]: lastUpdateClock,
-          },
-        };
-      }
-      return {
-        ...context,
-        spaces: [
-          ...context.spaces,
-          {
-            id: event.spaceId,
-            events: [],
-            state: undefined,
-            keys: [],
-            inboxes: [],
-            updates: [],
-            lastUpdateClock: -1,
-            automergeDocHandle: result.handle,
-          },
-        ],
-      };
-    },
     applyEvent: (context, event: { spaceId: string; event: SpaceEvent; state: SpaceState }) => {
       return {
         ...context,