anoma · lukaszcz · Jul 29, 2025 · Jul 24, 2025 · Jul 24, 2025 · Jul 24, 2025
diff --git a/AVM/Action.lean b/AVM/Action.lean
@@ -16,11 +16,6 @@ structure CreatedObject where
   object : Object label
   ephemeral : Bool
 
-/-- Used to balance a consumed object that's meant to be destroyed -/
-def CreatedObject.balanceDestroyed (destroyed : SomeConsumedObject) : CreatedObject where
-  object := destroyed.consumed.object
-  ephemeral := true
-
 def CreatedObject.fromSomeObject (o : SomeObject) (ephemeral : Bool) : CreatedObject :=
   { object := o.object
     ephemeral }
@@ -32,6 +27,7 @@ def create'
   (g : StdGen)
   (lab : Ecosystem.Label)
   (memberId : lab.MemberId)
+  (memberData : memberId.Data)
   (args : memberId.Args.type)
   (sconsumed : List SomeConsumedObject)
   (created : List CreatedObject) -- no appdata/logic
@@ -69,7 +65,7 @@ def create'
         let (r, g') := stdNext g
         let (r', g'') := stdNext g'
         let res := dummyResource ⟨r⟩
-        let can_nullify := Anoma.nullifyUniversal res Anoma.NullifierKey.universal rfl rfl
+        let can_nullify := Anoma.nullifyUniversal res
         let nonce := can_nullify.nullifier.toNonce
         let complianceWitness :=
             { consumedResource := res
@@ -88,6 +84,7 @@ def create'
       (Anoma.Tag.Consumed c.can_nullify.nullifier,
         { appData := {
             memberId := memberId,
+            memberData,
             memberArgs := args }})
 
     mkTagDataPairCreated (r : Anoma.Resource)
@@ -96,17 +93,37 @@ def create'
         { label := lab,
           appData := {
             memberId := .falseLogicId,
+            memberData := UUnit.unit,
             memberArgs := UUnit.unit }})
 
 /-- Helper function to create an Action. -/
 def create
   (lab : Ecosystem.Label)
   (memberId : lab.MemberId)
+  (memberData : memberId.Data)
   (args : memberId.Args.type)
   (consumed : List SomeConsumedObject)
   (created : List CreatedObject) -- no appdata/logic
   : Rand (Anoma.Action × Anoma.DeltaWitness) := do
   let g ← get
-  let (action, witness, g') := Action.create' g.down lab memberId args consumed created
+  let (action, witness, g') := Action.create' g.down lab memberId memberData args consumed created
   set (ULift.up g')
   return (action, witness)
+
+end Action
+
+/-- Used to balance a consumed object that's meant to be destroyed -/
+def SomeConsumedObject.balanceDestroyed (destroyed : SomeConsumedObject) : Action.CreatedObject where
+  object := destroyed.consumed.object
+  ephemeral := true
+
+/-- Used to balance a constructed object -/
+def SomeObject.balanceConstructed (constructed : SomeObject) : SomeConsumedObject where
+  consumed :=
+  let obj : Object (constructed.label) :=
+      { constructed.object
+        with nullifierKeyCommitment := Anoma.NullifierKeyCommitment.universal }
+  { object := obj,
+    can_nullify := Anoma.nullifyUniversal (obj.toResource true obj.nonce.get!)
+    ephemeral := true
+    key := Anoma.NullifierKey.universal }
diff --git a/AVM/Class/Translation.lean b/AVM/Class/Translation.lean
@@ -46,10 +46,10 @@ def Constructor.action
       { object := {newObj with nullifierKeyCommitment := Anoma.NullifierKeyCommitment.universal}
         ephemeral := true
         key := Anoma.NullifierKey.universal }
-  let consumed : ConsumedObject classId.label := { consumable with can_nullify := Anoma.nullifyUniversal consumable.resource consumable.key rfl rfl }
+  let consumed : ConsumedObject classId.label := { consumable with can_nullify := Anoma.nullifyUniversal consumable.resource }
   let created : List CreatedObject :=
         [CreatedObject.fromSomeObject newObj.toSomeObject (ephemeral := false)]
-  Action.create lab (.classMember (.constructorId constrId)) args [consumed] created
+  Action.create lab (.classMember (.constructorId constrId)) UUnit.unit args [consumed] created
 
 /-- Creates an Anoma Transaction for a given object construtor. -/
 def Constructor.transaction
@@ -100,7 +100,7 @@ def Method.action
       ephemeral := false }
   let created : List CreatedObject :=
       List.map createObject (method.created self args)
-  Action.create lab (.classMember (.methodId methodId)) args [consumed] created
+  Action.create lab (.classMember (.methodId methodId)) UUnit.unit args [consumed] created
 
 /-- Creates an Anoma Transaction for a given object method. -/
 def Method.transaction
@@ -152,7 +152,7 @@ def Destructor.action
   let createdObject : CreatedObject :=
     { object := self
       ephemeral := true }
-  Action.create lab (.classMember (.destructorId destructorId)) args [consumed] [createdObject]
+  Action.create lab (.classMember (.destructorId destructorId)) UUnit.unit args [consumed] [createdObject]
 
 /-- Creates an Anoma Transaction for a given object destructor. -/
 def Destructor.transaction

diff --git a/AVM/Ecosystem/AppData.lean b/AVM/Ecosystem/AppData.lean
@@ -4,12 +4,22 @@ import AVM.Ecosystem.Label
 
 namespace AVM
 
+structure FunctionData : Type where
+  numConstructed : Nat
+  numDestroyed : Nat
+  numSelvesDestroyed : Nat
+
+def Ecosystem.Label.MemberId.Data {lab : Ecosystem.Label} : lab.MemberId → Type
+  | .functionId _ => FunctionData
+  | _ => UUnit
+
 /-- The app data for an object in a given class consists of:
     1. member logic indicator (indicator which member is being called)
     2. member arguments
   -/
 structure AppData (lab : Ecosystem.Label) where
   memberId : lab.MemberId
+  memberData : memberId.Data
   memberArgs : memberId.Args.type
 
 structure SomeAppData where

diff --git a/AVM/Ecosystem/Member.lean b/AVM/Ecosystem/Member.lean
@@ -3,14 +3,35 @@ import AVM.Object.Consumable
 
 namespace AVM
 
-structure FunctionResult : Type (u + 1) where
-  /-- List of created objects -/
-  created : List SomeObject
-  /-- List of objects destroyed. Destroyed elements will be balanced with automatically generated ephemeral resources -/
+inductive DeconstructionKind : Type where
+  /-- Will be consumed and automatically balanced with an ephemeral resource -/
+  | Destroyed
+  /-- Will be consumed. It is the responsibility of the user to balance disassembled objects with assembled objects -/
+  | Disassembled
+  deriving BEq
+
+structure FunctionResult {lab : Ecosystem.Label} (functionId : lab.FunctionId) : Type (u + 1) where
+  /-- List of assembled objects. Assembled objects will be created.
+      It is the responsibility of the user to ensure that
+      assembled objects balance with the object arguments that are disassembled -/
+  assembled : List SomeObject
+  /-- List of destroyed objects. Destroyed objects will be balanced with automatically generated ephemeral resources -/
   destroyed : List SomeConsumableObject
+  /-- List of constructed objects. Constructed objects will be balanced with automatically generated ephemeral resources -/
+  constructed : List SomeObject
+  /-- For each object argument we specify its usage. See `Usage`.
+  Note that if `argUsage arg = .Destroyed`, then the object that corresponds to `arg` should *not* be put in the destroyed list -/
+  argDeconstruction : functionId.ObjectArgNames → DeconstructionKind
+
+def FunctionResult.numSelvesDestroyed
+  {lab : Ecosystem.Label}
+  {functionId : lab.FunctionId}
+  (res : FunctionResult functionId)
+  : Nat :=
+  functionId.objectArgNames.countP (fun a => res.argDeconstruction a == .Destroyed)
 
 structure Function {lab : Ecosystem.Label} (functionId : lab.FunctionId) where
   /-- Computes the result of a function call. See `FunctionResult`. -/
-  body (selves : functionId.Selves) (args : functionId.Args.type) : FunctionResult
+  body (selves : functionId.Selves) (args : functionId.Args.type) : FunctionResult functionId
   /-- Extra function logic. -/
   invariant (selves : functionId.Selves) (args : functionId.Args.type) : Bool
diff --git a/AVM/Ecosystem/Translation.lean b/AVM/Ecosystem/Translation.lean
@@ -28,28 +28,39 @@ def Function.logic
   (eco : Ecosystem lab)
   (args : Logic.Args lab)
   (funId : lab.FunctionId)
+  (funData : FunctionData)
   (fargs : funId.Args.type)
   : Bool :=
   let fn : Function funId := eco.functions funId
-  let try (argsConsumedSelves, argsDestroyed) :=
-      args.consumed |> Logic.filterOutDummy |>.splitAtExact funId.numObjectArgs
+  let try (argsConsumedSelves, argsConstructedEph, argsDestroyed, UUnit.unit) :=
+      args.consumed
+      |> Logic.filterOutDummy
+      |>.splitsExact [funId.numObjectArgs, funData.numConstructed, funData.numDestroyed]
   let try argsConsumedObjects : funId.Selves := Function.parseObjectArgs argsConsumedSelves.toList funId
-  let consumedSelvesList : List SomeObject :=
-     (lab.objectArgNamesEnum funId).toList.map
-     (fun arg => argsConsumedObjects arg |>.toSomeObject)
   (eco.functions funId).invariant argsConsumedObjects fargs
-   && Logic.checkResourcesData consumedSelvesList argsConsumedSelves.toList
-   && let funRes : FunctionResult := fn.body argsConsumedObjects fargs
-      let createdObjects : List SomeObject := funRes.created
+   && let funRes : FunctionResult funId := fn.body argsConsumedObjects fargs
+      let createdObjects : List SomeObject := funRes.assembled
       let destroyedObjects : List SomeObject := funRes.destroyed.map SomeConsumableObject.toSomeObject
-      let try (argsCreated, argsDestroyedEph) := args.created |> Logic.filterOutDummy
-              |>.splitAtExact createdObjects.length
+      let constructedObjects : List SomeObject := funRes.constructed
+      let consumedDestroyedObjects : List SomeObject :=
+        funId.objectArgNames.filterMap (fun arg => match funRes.argDeconstruction arg with
+        | .Destroyed => argsConsumedObjects arg |>.toSomeObject |> some
+        | .Disassembled => none)
+      let try (argsCreated, argsConstructed, argsDestroyedEph, argsSelvesDestroyedEph, UUnit.unit) :=
+        args.created
+        |> Logic.filterOutDummy
+        |>.splitsExact [createdObjects.length, funData.numConstructed, funData.numDestroyed, funData.numSelvesDestroyed]
       Logic.checkResourcesData createdObjects argsCreated.toList
-      && Logic.checkResourcesData destroyedObjects argsDestroyed
-      && Logic.checkResourcesData destroyedObjects argsDestroyedEph
+      && Logic.checkResourcesData destroyedObjects argsDestroyed.toList
+      && Logic.checkResourcesData destroyedObjects argsDestroyedEph.toList
+      && Logic.checkResourcesData constructedObjects argsConstructed.toList
+      && Logic.checkResourcesData constructedObjects argsConstructedEph.toList
+      && Logic.checkResourcesData consumedDestroyedObjects argsSelvesDestroyedEph.toList
       && Logic.checkResourcesPersistent args.consumed
       && Logic.checkResourcesPersistent argsCreated.toList
-      && Logic.checkResourcesEphemeral argsDestroyedEph
+      && Logic.checkResourcesPersistent argsDestroyed.toList
+      && Logic.checkResourcesEphemeral argsDestroyedEph.toList
+      && Logic.checkResourcesEphemeral argsConstructedEph.toList
 
 def Function.action
   {lab : Ecosystem.Label}
@@ -61,19 +72,34 @@ def Function.action
   : Rand (Option (Anoma.Action × Anoma.DeltaWitness)) := do
   let fn : Function funId := eco.functions funId
   let try consumedObjects : funId.Selves := Function.parseObjectArgs args.consumed funId
-  let try consumedSelves : List SomeConsumedObject :=
+  let try consumedSelves : List (funId.ObjectArgNames × SomeConsumedObject) :=
     (lab.objectArgNamesEnum funId).toList
-    |>.map (fun arg =>
-      (consumedObjects arg).toSomeObject
-      |> SomeObject.toConsumable false (keys arg)
-      |> SomeConsumableObject.consume)
+    |>.map (fun (arg : funId.ObjectArgNames) => do
+      let try obj := consumedObjects arg
+                     |>.toSomeObject
+                     |> SomeObject.toConsumable false (keys arg)
+                     |> SomeConsumableObject.consume
+      some (arg, obj))
     |>.getSome
-  let funRes : FunctionResult := fn.body consumedObjects fargs
-  let createdObjects : List CreatedObject := funRes.created |>
+  let funRes : FunctionResult funId := fn.body consumedObjects fargs
+  let selvesDestroyedEph : List CreatedObject :=
+    consumedSelves.filterMap (fun (arg, consumed) =>
+      match funRes.argDeconstruction arg with
+      | .Destroyed => some (consumed.balanceDestroyed)
+      | .Disassembled => none)
+  let createdObjects : List CreatedObject := funRes.assembled |>
       List.map (fun x => CreatedObject.fromSomeObject x (ephemeral := false))
   let try destroyed : List SomeConsumedObject := funRes.destroyed.map (·.consume) |>.getSome
-  let destroyedEph : List CreatedObject := destroyed.map CreatedObject.balanceDestroyed
-  let r ← Action.create lab (.functionId funId) fargs (consumedSelves ++ destroyed) (createdObjects ++ destroyedEph)
+  let destroyedEph : List CreatedObject := destroyed.map (·.balanceDestroyed)
+  let constructed : List CreatedObject := funRes.constructed.map (fun c => CreatedObject.fromSomeObject c false)
+  let constructedEph : List SomeConsumedObject := funRes.constructed.map (·.balanceConstructed)
+  let funData : FunctionData :=
+    { numConstructed := constructed.length
+      numDestroyed := destroyed.length
+      numSelvesDestroyed := selvesDestroyedEph.length }
+  let r ← Action.create lab (.functionId funId) funData fargs
+          (consumed := consumedSelves.map Prod.snd ++ constructedEph ++ destroyed)
+          (created := createdObjects ++ constructed ++ destroyedEph ++ selvesDestroyedEph)
   pure (some r)
 
 private def logic'
@@ -89,8 +115,8 @@ private def logic'
   | Consumed =>
     match args.data with
     | {memberId := .falseLogicId, ..} => false
-    | {memberId := .classMember mem, memberArgs} => Class.checkClassMemberLogic args eco mem memberArgs
-    | {memberId := .functionId fn, memberArgs} => Function.logic eco args fn memberArgs
+    | {memberId := .classMember mem, memberArgs, ..} => Class.checkClassMemberLogic args eco mem memberArgs
+    | {memberId := .functionId fn, memberArgs, memberData} => Function.logic eco args fn memberData memberArgs
 
 def logic
   {lab : Ecosystem.Label}

diff --git a/AVM/Intent/Translation.lean b/AVM/Intent/Translation.lean
@@ -61,7 +61,7 @@ def Intent.action'
   let (r1, g2) := stdNext g1
   let (r2, g3) := stdNext g2
   let res := Action.dummyResource ⟨r1⟩
-  let can_nullify := Anoma.nullifyUniversal res Anoma.NullifierKey.universal rfl rfl
+  let can_nullify := Anoma.nullifyUniversal res
   let nonce := can_nullify.nullifier.toNonce
   let intentResource : Anoma.Resource := Intent.toResource intent args provided nonce
   let createdWitness : Anoma.ComplianceWitness :=
@@ -101,6 +101,7 @@ where
         { label := label,
           appData := {
             memberId := .classMember (classId := classId) (Class.Label.MemberId.intentId ilab),
+            memberData := UUnit.unit
             memberArgs := UUnit.unit }})
 
 /-- An action which consumes the provided objects and creates the intent. -/

diff --git a/Anoma/Resource.lean b/Anoma/Resource.lean
@@ -62,13 +62,12 @@ def nullify (key : Anoma.NullifierKey) (res : Resource) : Decidable (CanNullifyR
   | isTrue p => isTrue (by constructor; exact p)
   | isFalse n => isFalse (by intro h; cases h; contradiction)
 
-def nullifyUniversal (res : Resource) (key : Anoma.NullifierKey)
-  (p1 : key = .universal)
-  (p2 : res.nullifierKeyCommitment = .universal)
-  : CanNullifyResource key res
+def nullifyUniversal (res : Resource)
+  (p1 : res.nullifierKeyCommitment = .universal := by rfl)
+  : CanNullifyResource .universal res
   := by
   constructor
-  rw [p1, p2]
+  rw [p1]
   constructor
 
 inductive Commitment where

diff --git a/Applib.lean b/Applib.lean
@@ -8,6 +8,7 @@ macro "noIntents" lab:ident clab:ident : term => `(fun _ h => by simp [$lab:iden
 macro "noDestructors" : term => `(fun x => Empty.elim x)
 macro "noFunctions" : term => `(fun x => Empty.elim x)
 macro "noMethods" : term => `(fun x => Empty.elim x)
+macro "noConstructors" : term => `(fun x => Empty.elim x)
 
 class IsObject (s : Type) where
   label : Class.Label
@@ -74,24 +75,31 @@ structure DestroyableObject where
   anObject : AnObject
   key : Anoma.NullifierKey := Anoma.NullifierKey.universal
 
-structure FunctionResult where
+structure FunctionResult {lab : Ecosystem.Label} (funId : lab.FunctionId) where
   created : List AnObject := []
+  constructed : List AnObject := []
   destroyed : List DestroyableObject := []
+  argDeconstruction : funId.ObjectArgNames → DeconstructionKind := fun _ => .Disassembled
 
-def FunctionResult.toAVM (r : FunctionResult) : AVM.FunctionResult where
-  created := r.created.map (·.toSomeObject)
+def FunctionResult.empty {lab : Ecosystem.Label} (funId : lab.FunctionId) : FunctionResult funId :=
+  {created := [], destroyed := [], constructed := []}
+
+def FunctionResult.toAVM {lab : Ecosystem.Label} {funId : lab.FunctionId} (r : FunctionResult funId) : AVM.FunctionResult funId where
+  assembled := r.created.map (·.toSomeObject)
+  constructed := r.constructed.map (·.toSomeObject)
   destroyed := r.destroyed.map (fun d => d.anObject.toSomeObject.toConsumable false d.key)
+  argDeconstruction := r.argDeconstruction
 
 def defFunction
   (lab : Ecosystem.Label)
   (funId : lab.FunctionId)
   (argsInfo : (a : funId.ObjectArgNames) → ObjectArgInfo lab funId a)
-  (body : ObjectArgs lab funId argsInfo → funId.Args.type → FunctionResult)
+  (body : ObjectArgs lab funId argsInfo → funId.Args.type → FunctionResult funId)
   (invariant : ObjectArgs lab funId argsInfo → funId.Args.type → Bool := fun _ _ => true)
   : Function funId where
-  body (selves : funId.Selves) (args : funId.Args.type) : AVM.FunctionResult :=
+  body (selves : funId.Selves) (args : funId.Args.type) : AVM.FunctionResult funId :=
     match FinEnum.decImageOption' (enum := lab.objectArgNamesEnum funId) (getArg selves) with
-    | none => {created := [], destroyed := []}
+    | none => FunctionResult.empty funId |>.toAVM
     | some (p : (argName : funId.ObjectArgNames) → (argsInfo argName).type) => (body p args).toAVM
   invariant (selves : funId.Selves) (args : funId.Args.type) : Bool :=
     match FinEnum.decImageOption' (enum := lab.objectArgNamesEnum funId) (getArg selves) with

diff --git a/Apps/Kudos.lean b/Apps/Kudos.lean
@@ -22,6 +22,7 @@ abbrev PublicIden := Anoma.NullifierKeyCommitment
 /- 3. Split: The onwer of a kudos can partition a kudos token into a list of tokens with smaller quantities -/
 /-           such that the aggregate quantity is equal to the original -/
 /- 4. Burn: The owner of a kudos token can destroy it if themself is the originator of the token -/
+/- 5. Merge: Merge two Kudos object of the same denomination and owner into a single one -/
 
 structure Kudos where
   quantity : Nat