anoma · janmasrovira · Sep 4, 2025 · Sep 2, 2025 · Sep 2, 2025 · Sep 2, 2025
diff --git a/AVM.lean b/AVM.lean
@@ -3,3 +3,5 @@ import AVM.Class
 import AVM.Class.Translation
 import AVM.Task
 import AVM.Task.Translation
+import AVM.Program
+import AVM.Program.Translation
diff --git a/AVM/Class/Member.lean b/AVM/Class/Member.lean
@@ -1,23 +1,23 @@
-import AVM.Class.Member.Body
+import AVM.Program
 
 namespace AVM.Class
 
 structure Constructor {lab : Ecosystem.Label} (cid : lab.ClassId) (constrId : cid.label.ConstructorId) where
   /-- Constructor call body. -/
-  body : constrId.Args.type → Member.Body lab (ObjectData cid.label) .empty
+  body : constrId.Args.type → Program lab (ObjectData cid.label)
   /-- Extra constructor logic. The constructor invariant is combined with
       auto-generated constructor body constraints to create the constructor logic. -/
   invariant : constrId.Args.type → Bool
 
 structure Destructor.{u} {lab : Ecosystem.Label} (cid : lab.ClassId) (destructorId : cid.label.DestructorId) : Type (u + 1) where
   /-- Destructor call body. -/
-  body : (self : Object cid.label) → destructorId.Args.type → Member.Body lab PUnit .empty
+  body : (self : Object cid.label) → destructorId.Args.type → Program lab PUnit
   /-- Extra destructor logic. -/
   invariant : (self : Object cid.label) → destructorId.Args.type → Bool
 
 structure Method {lab : Ecosystem.Label} (cid : lab.ClassId) (methodId : cid.label.MethodId) : Type (u + 1) where
   /-- Method call body. -/
-  body : (self : Object cid.label) → methodId.Args.type → Member.Body lab (Object cid.label) .empty
+  body : (self : Object cid.label) → methodId.Args.type → Program lab (Object cid.label)
   /-- Extra method logic. The method invariant is combined with auto-generated
       method body constraints to create the method logic. -/
   invariant : (self : Object cid.label) → methodId.Args.type → Bool

diff --git a/AVM/Class/Translation.lean b/AVM/Class/Translation.lean
@@ -139,23 +139,23 @@ def logic {lab : Ecosystem.Label} {classId : lab.ClassId} (cl : Class classId) (
 
 mutual
 
-partial def Member.Body.tasks {α} {params : Task.Parameters} {lab : Ecosystem.Label} (eco : Ecosystem lab) (body : Member.Body lab α params) (vals : body.params.Product) : List Task :=
-  let vals1 := Member.Body.prefixProduct body vals
+partial def Program.tasks {α} {params : Task.Parameters} {lab : Ecosystem.Label} (eco : Ecosystem lab) (body : Program' lab α params) (vals : body.params.Product) : List Task :=
+  let vals1 := Program'.prefixProduct body vals
   match body with
   | .constructor classId constrId args next =>
     let constr := eco.classes classId |>.constructors constrId
     let task := constr.task eco (args vals1)
-    task :: next.tasks eco vals
+    task :: Program.tasks eco next vals
   | .destructor classId destrId selfId args next =>
     let destr := eco.classes classId |>.destructors destrId
     let task := destr.task eco (selfId vals1) (args vals1)
-    task :: next.tasks eco vals
+    task :: Program.tasks eco next vals
   | .method classId methodId selfId args next =>
     let method := eco.classes classId |>.methods methodId
     let task := method.task eco (selfId vals1) (args vals1)
-    task :: next.tasks eco vals
+    task :: Program.tasks eco next vals
   | .fetch _ next =>
-    next.tasks eco vals
+    Program.tasks eco next vals
   | .return _ =>
     []
 
@@ -172,7 +172,7 @@ partial def Constructor.task
   let params := Task.Parameters.genId (fun _ => bodyParams)
   Task.absorbParams params fun ⟨newId, vals⟩ =>
     let body := constr.body args
-    let tasks := body.tasks eco vals
+    let tasks := Program.tasks eco body vals
     let newObjData : ObjectData classId.label := body.returnValue vals
     let newObj : SomeObject :=
       let obj : Object classId.label :=
@@ -183,7 +183,7 @@ partial def Constructor.task
     let consumedObj := newObj.toConsumable (ephemeral := true)
     let createdObjects : List CreatedObject :=
       [CreatedObject.fromSomeObject newObj (ephemeral := false)]
-    Task.compose (constr.message ⟨bodyParams.Product⟩ vals newId args) tasks consumedObj createdObjects
+    Task.composeWithMessage (constr.message ⟨bodyParams.Product⟩ vals newId args) tasks [consumedObj] createdObjects
 
 /-- Creates a Task for a given object destructor. -/
 partial def Destructor.task
@@ -199,13 +199,13 @@ partial def Destructor.task
   let bodyParams (self : Object classId.label) := (destructor.body self args).params
   let params := Task.Parameters.fetch consumedObjectId bodyParams
   Task.absorbParams params fun ⟨self, vals⟩ =>
-    let tasks : List Task := (destructor.body self args).tasks eco vals
+    let tasks : List Task := Program.tasks eco (destructor.body self args) vals
     let consumedObj := self.toSomeObject.toConsumable (ephemeral := false)
     let createdObjects : List CreatedObject :=
       [{ uid := self.uid,
          data := self.data,
          ephemeral := true }]
-    Task.compose (destructor.message ⟨(bodyParams self).Product⟩ vals selfId args) tasks consumedObj createdObjects
+    Task.composeWithMessage (destructor.message ⟨(bodyParams self).Product⟩ vals selfId args) tasks [consumedObj] createdObjects
 
 partial def Method.task
   {lab : Ecosystem.Label}
@@ -221,13 +221,13 @@ partial def Method.task
   let params := Task.Parameters.fetch consumedObjectId bodyParams
   Task.absorbParams params fun ⟨self, vals⟩ =>
     let body := method.body self args
-    let tasks : List Task := body.tasks eco vals
+    let tasks : List Task := Program.tasks eco body vals
     let consumedObj := self.toSomeObject.toConsumable (ephemeral := false)
     let obj := (body.returnValue vals).toSomeObject
     let createdObjects : List CreatedObject :=
       [{ uid := obj.object.uid,
          data := obj.object.data,
          ephemeral := false }]
-    Task.compose (method.message ⟨(bodyParams self).Product⟩ vals selfId args) tasks consumedObj createdObjects
+    Task.composeWithMessage (method.message ⟨(bodyParams self).Product⟩ vals selfId args) tasks [consumedObj] createdObjects
 
 end -- mutual
diff --git a/AVM/Class/Member/Body.lean → AVM/Program.lean b/AVM/Class/Member/Body.lean → AVM/Program.lean
@@ -3,62 +3,62 @@ import AVM.Class.Label
 import AVM.Ecosystem.Label
 import AVM.Task.Parameters
 
-namespace AVM.Class
+namespace AVM
 
 /-- The parameters `params` represent objects fetched and new object ids
   generated in the body before the current statement. -/
-inductive Member.Body.{u} (lab : Ecosystem.Label) (ReturnType : Type u) : Task.Parameters.{u} → Type (u + 1) where
+inductive Program'.{u} (lab : Ecosystem.Label) (ReturnType : Type u) : Task.Parameters.{u} → Type (u + 1) where
   | constructor
       {params : Task.Parameters}
       (cid : lab.ClassId)
       (constrId : cid.label.ConstructorId)
       (args : params.Product → constrId.Args.type)
-      (next : Member.Body lab ReturnType params.snocGenId)
-      : Member.Body lab ReturnType params
+      (next : Program' lab ReturnType params.snocGenId)
+      : Program' lab ReturnType params
   | destructor
       {params : Task.Parameters}
       (cid : lab.ClassId)
       (destrId : cid.label.DestructorId)
       (selfId : params.Product → ObjectId)
       (args : params.Product → destrId.Args.type)
-      (next : Member.Body lab ReturnType params)
-      : Member.Body lab ReturnType params
+      (next : Program' lab ReturnType params)
+      : Program' lab ReturnType params
   | method
       {params : Task.Parameters}
       (cid : lab.ClassId)
       (methodId : cid.label.MethodId)
       (selfId : params.Product → ObjectId)
       (args : params.Product → methodId.Args.type)
-      (next : Member.Body lab ReturnType params)
-      : Member.Body lab ReturnType params
+      (next : Program' lab ReturnType params)
+      : Program' lab ReturnType params
   | fetch
       {params : Task.Parameters}
       (objId : params.Product → TypedObjectId)
-      (next : Member.Body lab ReturnType (params.snocFetch objId))
-      : Member.Body lab ReturnType params
+      (next : Program' lab ReturnType (params.snocFetch objId))
+      : Program' lab ReturnType params
   | return
       {params : Task.Parameters}
       (val : params.Product → ReturnType)
-      : Member.Body lab ReturnType params
+      : Program' lab ReturnType params
 
 /-- All body parameters - the parameters at the point of the return statement. -/
-def Member.Body.params {lab ReturnType params} (body : Member.Body lab ReturnType params) : Task.Parameters :=
+def Program'.params {lab ReturnType params} (body : Program' lab ReturnType params) : Task.Parameters :=
   match body with
   | .constructor _ _ _ next => next.params
   | .destructor _ _ _ _ next => next.params
   | .method _ _ _ _ next => next.params
   | .fetch _ next => next.params
   | .return _ => params
 
-def Member.Body.returnValue {lab ReturnType params} (body : Member.Body lab ReturnType params) (vals : body.params.Product) : ReturnType :=
+def Program'.returnValue {lab ReturnType params} (body : Program' lab ReturnType params) (vals : body.params.Product) : ReturnType :=
   match body with
   | .constructor _ _ _ next => next.returnValue vals
   | .destructor _ _ _ _ next => next.returnValue vals
   | .method _ _ _ _ next => next.returnValue vals
   | .fetch _ next => next.returnValue vals
   | .return val => val vals
 
-def Member.Body.prefixProduct {lab ReturnType params} (body : Member.Body lab ReturnType params) (vals : body.params.Product)
+def Program'.prefixProduct {lab ReturnType params} (body : Program' lab ReturnType params) (vals : body.params.Product)
   : params.Product :=
   match body with
   | .constructor _ _ _ next =>
@@ -69,7 +69,7 @@ def Member.Body.prefixProduct {lab ReturnType params} (body : Member.Body lab Re
     prefixProduct next vals |> Task.Parameters.Values.dropLastFetch
   | .return _ => vals
 
-def Member.Body.map {lab : Ecosystem.Label} {A B : Type u} {params : Task.Parameters} (f : A → B) (body : Member.Body lab A params) : Member.Body lab B params :=
+def Program'.map {lab : Ecosystem.Label} {A B : Type u} {params : Task.Parameters} (f : A → B) (body : Program' lab A params) : Program' lab B params :=
   match body with
   | .constructor cid constrId args next =>
     .constructor cid constrId args (map f next)
@@ -81,3 +81,6 @@ def Member.Body.map {lab : Ecosystem.Label} {A B : Type u} {params : Task.Parame
     .fetch objId (map f next)
   | .return val =>
     .return (fun p => f (val p))
+
+def Program (lab : Ecosystem.Label) (ReturnType : Type u) : Type (u + 1) :=
+  Program' lab ReturnType Task.Parameters.empty
diff --git a/AVM/Program/Translation.lean b/AVM/Program/Translation.lean
@@ -0,0 +1,12 @@
+import AVM.Program
+import AVM.Class.Translation
+import AVM.Task.Translation
+
+namespace AVM
+
+def Program.compile {lab : Ecosystem.Label} (eco : Ecosystem lab) (prog : Program lab Unit) : Anoma.Program :=
+  let task : Task :=
+    Task.absorbParams prog.params fun vals =>
+      Class.Program.tasks eco prog vals |>
+        Task.compose
+  task.toProgram
diff --git a/AVM/Task.lean b/AVM/Task.lean
@@ -15,18 +15,18 @@ structure Task.Actions where
   step. Tasks enable modularity of the translation – they are at the right
   level of abstraction to compose translations of different message sends,
   enabling nested method calls and subobjects. -/
-structure Task where
+structure Task.{u} : Type (u + 1) where
   /-- Task parameters - objects to fetch from the Anoma system and new object
     ids to generate. -/
   params : Task.Parameters
   /-- The message to send to the recipient. -/
-  message : params.Product → SomeMessage
+  message : params.Product → Option SomeMessage
   /-- Task actions - actions to perform parameterised by fetched objects and new
     object ids. -/
   actions : params.Product → Rand (Option Task.Actions)
 deriving Inhabited
 
-def Task.absorbParams (params : Task.Parameters) (task : params.Product → Task) : Task :=
+def Task.absorbParams.{u} (params : Task.Parameters) (task : params.Product → Task.{u}) : Task.{u} :=
   { params := params.append (fun vals => (task vals).params),
     message := fun vals =>
       let ⟨vals1, vals2⟩ := Task.Parameters.splitProduct vals
@@ -55,7 +55,8 @@ def Task.composeMessages (tasks : List Task) (vals : HList (Products tasks)) : L
   match tasks, vals with
   | [], _ => []
   | task :: tasks', HList.cons vals' vals'' =>
-    task.message vals' :: composeMessages tasks' vals''
+    (task.message vals' |>.toList) ++
+      composeMessages tasks' vals''
 
 def Task.composeParams (tasks : List Task) : Task.Parameters :=
   tasks |>.map (·.params) |> .concat
@@ -73,23 +74,30 @@ def Task.composeActions
       deltaWitness := Anoma.DeltaWitness.compose witness actions.deltaWitness }
 
 def Task.composeWithAction
-  (msg : SomeMessage)
+  (msg : Option SomeMessage)
   (tasks : List Task)
   (mkAction : HList (Products tasks) → Rand (Option (Anoma.Action × Anoma.DeltaWitness)))
   : Task :=
   { params := composeParams tasks,
     message := fun _ => msg,
     actions := composeActions tasks mkAction }
 
-def Task.compose
+def Task.composeWithMessage
   (msg : SomeMessage)
   (tasks : List Task)
-  (consumedObj : SomeConsumableObject)
+  (consumedObjs : List SomeConsumableObject)
   (createdObjects : List CreatedObject)
   : Task :=
   let mkAction (vals : HList (Products tasks))
     : Rand (Option (Anoma.Action × Anoma.DeltaWitness)) :=
-    let try consumedObject := consumedObj.consume
+    let try consumedObjects := consumedObjs.map (·.consume) |>.getSome
     let createdMessages := composeMessages tasks vals
-    Action.create [consumedObject] createdObjects [msg] createdMessages
+    Action.create consumedObjects createdObjects [msg] createdMessages
   Task.composeWithAction msg tasks mkAction
+
+def Task.compose (tasks : List Task) : Task :=
+  let mkAction (vals : HList (Products tasks))
+    : Rand (Option (Anoma.Action × Anoma.DeltaWitness)) :=
+    let createdMessages := composeMessages tasks vals
+    Action.create [] [] [] createdMessages
+  Task.composeWithAction none tasks mkAction
diff --git a/AVM/Task/Translation.lean b/AVM/Task/Translation.lean
@@ -5,13 +5,19 @@ namespace AVM.Task
 
 /-- Creates an Anoma Transaction for a given Task. -/
 def toTransaction (task : Task) (vals : task.params.Product) : Rand (Option Anoma.Transaction) := do
-  let (action, witness) ← Action.create [] [] [] [task.message vals]
-  let try actions : Task.Actions ← task.actions vals
-  let witness' : Anoma.DeltaWitness :=
-    Anoma.DeltaWitness.compose actions.deltaWitness witness
-  let acts : List Anoma.Action := action :: actions.actions
-  pure <|
-    some
+  match task.message vals with
+  | none =>
+    let try actions : Task.Actions ← task.actions vals
+    pure <| some <|
+      { actions := actions.actions,
+        deltaProof := Anoma.Transaction.generateDeltaProof actions.deltaWitness actions.actions }
+  | some msg =>
+    let (action, witness) ← Action.create [] [] [] [msg]
+    let try actions : Task.Actions ← task.actions vals
+    let witness' : Anoma.DeltaWitness :=
+      Anoma.DeltaWitness.compose witness actions.deltaWitness
+    let acts : List Anoma.Action := action :: actions.actions
+    pure <| some <|
       { actions := acts,
         deltaProof := Anoma.Transaction.generateDeltaProof witness' acts }
 

diff --git a/Applib.lean b/Applib.lean
@@ -1,2 +1,3 @@
 import Applib.Surface
 import Applib.Authorization
+import Applib.Translation
diff --git a/Applib/Surface/Member.lean b/Applib/Surface/Member.lean
@@ -20,14 +20,14 @@ def defMethod (cl : Type) [i : IsObject cl] {methodId : i.classId.label.MethodId
       let self' := i.fromObject self.data
       let prog := body self' args
       prog.map (fun obj => {self with data := i.toObject obj})
-        |>.toBody
+        |>.toAVM
 
 def defConstructor {cl : Type} [i : IsObject cl] {constrId : i.classId.label.ConstructorId}
  (body : constrId.Args.type → Program i.label cl)
  (invariant : constrId.Args.type → Bool := fun _ => true)
  : Class.Constructor i.classId constrId where
     invariant (args : constrId.Args.type) := invariant args
-    body (args : constrId.Args.type) := body args |>.map i.toObject |>.toBody
+    body (args : constrId.Args.type) := body args |>.map i.toObject |>.toAVM
 
 def defDestructor {cl : Type} [i : IsObject cl] {destructorId : i.classId.label.DestructorId}
  (body : (self : cl) → destructorId.Args.type → Program i.label PUnit := fun _ _ => Program.return fun _ => ())
@@ -37,4 +37,4 @@ def defDestructor {cl : Type} [i : IsObject cl] {destructorId : i.classId.label.
       let self' := i.fromObject self.data
       invariant self' args
     body (self : Object i.classId.label) (args : destructorId.Args.type) :=
-      body (i.fromObject self.data) args |>.toBody
+      body (i.fromObject self.data) args |>.toAVM
diff --git a/Applib/Surface/Program.lean b/Applib/Surface/Program.lean
@@ -103,17 +103,17 @@ inductive Program' (lab : Ecosystem.Label) (ReturnType : Type) : Program.Paramet
       (val : params.Product → ReturnType)
       : Program' lab ReturnType params
 
-def Program'.toBody {lab ReturnType params} (prog : Program' lab ReturnType params) : Class.Member.Body lab ReturnType params.toTaskParameters :=
+def Program'.toAVM {lab ReturnType params} (prog : Program' lab ReturnType params) : AVM.Program' lab ReturnType params.toTaskParameters :=
   match prog with
   | .create C cid constrId args next =>
-    let next' := cast (by rw [Program.Parameters.toTaskParameters_genId]) (toBody next)
+    let next' := cast (by rw [Program.Parameters.toTaskParameters_genId]) (Program'.toAVM next)
     .constructor cid constrId (convertFun args) next'
   | .destroy cid destrId selfId args next =>
-    .destructor cid destrId (convertFun selfId) (convertFun args) (toBody next)
+    .destructor cid destrId (convertFun selfId) (convertFun args) (Program'.toAVM next)
   | .call cid methodId selfId args next =>
-    .method cid methodId (convertFun selfId) (convertFun args) (toBody next)
+    .method cid methodId (convertFun selfId) (convertFun args) (Program'.toAVM next)
   | @fetch _ _ _ C i objId next =>
-    let next' := cast (by rw [Program.Parameters.toTaskParameters_snocFetch C objId]) (toBody next)
+    let next' := cast (by rw [Program.Parameters.toTaskParameters_snocFetch C objId]) (Program'.toAVM next)
     .fetch (fun vals => ⟨i.classId.label, objId (Task.Parameters.Values.toProgramParameterValues vals)⟩) next'
   | .return val =>
     .return (convertFun val)

diff --git a/Applib/Translation.lean b/Applib/Translation.lean
@@ -0,0 +1,8 @@
+import Applib.Surface.Program
+
+namespace Applib
+
+def Program.compile {lab : AVM.Ecosystem.Label} (eco : AVM.Ecosystem lab) (prog : Program lab Unit) : Anoma.Program :=
+  prog.toAVM |> AVM.Program.compile eco
+
+end Applib