Handle time event in model handler

package.json

@@ -13,14 +13,14 @@
     "@biomejs/biome": "1.8.1",
     "@jest/globals": "^29.7.0",
     "@swc/cli": "^0.3.12",
-    "@swc/core": "^1.5.29",
+    "@swc/core": "^1.6.1",
     "@swc/jest": "^0.2.36",
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.2",
+    "@types/node": "^20.14.5",
     "del-cli": "^5.1.0",
     "jest": "^29.7.0",
-    "tsx": "^4.15.4",
-    "turbo": "^2.0.3",
+    "tsx": "^4.15.6",
+    "turbo": "^2.0.4",
     "typescript": "^5.4.5"
   },
   "pnpm": {

packages/ethereum-did/package.json

@@ -37,7 +37,7 @@
     "caip": "^1.1.1",
     "did-session": "^3.1.0",
     "dids": "^5.0.2",
-    "viem": "^2.14.0"
+    "viem": "^2.15.1"
   },
   "jest": {
     "extensionsToTreatAsEsm": [".ts"],

packages/events/src/codecs.ts

@@ -7,6 +7,7 @@ import {
   decode,
   optional,
   sparse,
+  strict,
   string,
   tuple,
   unknown,
@@ -78,3 +79,21 @@ export function assertSignedEvent(
 ): asserts input is SignedEvent {
   decodeSignedEvent(input)
 }
+
+export const TimeEvent = strict(
+  {
+    id: cid,
+    prev: cid,
+    proof: cid,
+    path: string,
+  },
+  'TimeEvent',
+)
+export type TimeEvent = TypeOf<typeof TimeEvent>
+
+export function decodeTimeEvent(input: unknown): TimeEvent {
+  return decode(TimeEvent, input)
+}
+export function assertTimeEvent(input: unknown): asserts input is TimeEvent {
+  decodeTimeEvent(input)
+}

packages/events/src/index.ts

@@ -2,8 +2,11 @@ export {
   GenericEventHeader,
   InitEventHeader,
   SignedEvent,
+  TimeEvent,
   assertSignedEvent,
+  assertTimeEvent,
   decodeSignedEvent,
+  decodeTimeEvent,
 } from './codecs.js'
 export {
   type EventContainer,

packages/model-handler/package.json

@@ -40,10 +40,12 @@
   },
   "devDependencies": {
     "@ceramic-sdk/ethereum-did": "workspace:^",
+    "@ceramic-sdk/identifiers": "workspace:^",
     "@ceramic-sdk/key-did": "workspace:^",
     "@didtools/codecs": "^3.0.0",
     "@types/lodash.ismatch": "^4.4.9",
-    "json-schema-typed": "^8.0.1"
+    "json-schema-typed": "^8.0.1",
+    "multiformats": "^13.1.1"
   },
   "jest": {
     "extensionsToTreatAsEsm": [".ts"],

packages/model-handler/src/handler.ts

@@ -1,23 +1,25 @@
 import {
-  type SignedEvent,
+  SignedEvent,
   type SignedEventContainer,
+  TimeEvent,
   signedEventToContainer,
 } from '@ceramic-sdk/events'
 import {
+  type ModelEvent,
   ModelInitEventPayload,
   ModelMetadata,
   type ModelState,
   assertValidModelContent,
-  getModelStreamID,
   validateController,
 } from '@ceramic-sdk/model-protocol'
 import type { DID } from 'dids'
+import type { CID } from 'multiformats/cid'
 
 import {
   validateImplementedInterfaces,
   validateInterface,
 } from './interfaces-validation.js'
-import type { Context } from './types.js'
+import type { Context, InitContext, TimeContext } from './types.js'
 
 export async function getInitEventContainer(
   verifier: DID,
@@ -27,8 +29,9 @@ export async function getInitEventContainer(
 }
 
 export async function handleInitEvent(
+  cid: CID,
   event: SignedEvent,
-  context: Context,
+  context: InitContext,
 ): Promise<ModelState> {
   const { payload } = await getInitEventContainer(context.verifier, event)
 
@@ -47,10 +50,46 @@ export async function handleInitEvent(
     await validateImplementedInterfaces(content, context)
   }
 
-  const streamID = getModelStreamID({
-    data: payload.data,
-    header: payload.header,
-  })
+  return {
+    cid,
+    content,
+    metadata,
+    log: [event],
+  }
+}
 
-  return { id: streamID.toString(), content, metadata, log: [event] }
+export async function handleTimeEvent(
+  cid: CID,
+  event: TimeEvent,
+  context: TimeContext,
+): Promise<ModelState> {
+  const state = await context.getModelState(event.id)
+  if (!state.cid.equals(event.id)) {
+    throw new Error(
+      `Invalid state with model ${state.cid} provided for time event ${cid}: expected model ${event.id}`,
+    )
+  }
+
+  const init = state.log[0]
+  if (init == null) {
+    throw new Error(
+      `Invalid state for model ${state.cid} provided for time event ${cid}: no events in log`,
+    )
+  }
+
+  return { ...state, log: [...state.log, event] }
+}
+
+export async function handleEvent(
+  cid: CID,
+  event: ModelEvent,
+  context: Context,
+): Promise<ModelState> {
+  if (SignedEvent.is(event)) {
+    return await handleInitEvent(cid, event, context)
+  }
+  if (TimeEvent.is(event)) {
+    return await handleTimeEvent(cid, event, context)
+  }
+  throw new Error(`Unsupported event: ${cid}`)
 }

packages/model-handler/src/interfaces-validation.ts

@@ -8,7 +8,7 @@ import { JsonReference } from 'json-ptr'
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
 import isMatch from 'lodash.ismatch'
 
-import type { Context } from './types.js'
+import type { InitContext } from './types.js'
 
 export type Schema = Exclude<JSONSchema, boolean>
 
@@ -740,15 +740,15 @@ export function validateInterfaceImplementation(
 
 export async function validateImplementedInterfaces(
   model: ModelDefinition,
-  context: Context,
+  context: InitContext,
 ): Promise<void> {
   const errors: Array<Error> = []
 
   const toValidate = ((model as ModelDefinitionV2).implements ?? []).map(
     async (interfaceID) => {
       try {
         const interfaceDefinition =
-          await context.loadModelDefinition(interfaceID)
+          await context.getModelDefinition(interfaceID)
         validateInterfaceImplementation(interfaceID, interfaceDefinition, model)
       } catch (error) {
         errors.push(error as Error)

packages/model-handler/src/types.ts

@@ -1,7 +1,14 @@
-import type { ModelDefinition } from '@ceramic-sdk/model-protocol'
+import type { ModelDefinition, ModelState } from '@ceramic-sdk/model-protocol'
 import type { DID } from 'dids'
+import type { CID } from 'multiformats/cid'
 
-export type Context = {
-  loadModelDefinition: (id: string) => Promise<ModelDefinition>
+export type InitContext = {
+  getModelDefinition: (id: string) => Promise<ModelDefinition>
   verifier: DID
 }
+
+export type TimeContext = {
+  getModelState: (cid: CID) => Promise<ModelState>
+}
+
+export type Context = InitContext & TimeContext