Anoma.RM.Transparent.Transaction (Anoma v0.31.0)

@type t() :: %Anoma.RM.Transparent.Transaction{
  actions: MapSet.t(Anoma.RM.Transparent.Action.t()),
  delta_proof: <<_::0>>,
  roots: MapSet.t(integer())
}

Functions

action_precis(t)

@spec action_precis(t()) ::
  {:ok, %{created: MapSet.t(integer()), consumed: MapSet.t(integer())}}
  | {:error, String.t()}

I am the action precis function for the transparent transaction.

Given a transaction, I go through the actions contained therein gathering all consumed and created resource hashes. If any action has an intersection, I error.

actions_check(t)

@spec actions_check(t()) :: bool()

I am the actions check for the transparent transaction.

I verify each action in the approprite field using the provided interface.

compose(t1, t2)

@spec compose(t(), t()) :: t()

I am the compose interface for transparent transaction.

I take unions of the provided roots and actions.

create(roots, actions)

@spec create(MapSet.t(integer()), MapSet.t(Anoma.RM.Transparent.Action.t())) :: t()

I am the transparent transaction creation interface.

Given roots and actions, I create an appropriate transaction.

delta(t)

@spec delta(t()) :: integer()

I am the transparent transaction delta.

Given a transaction, I simply sum over the contained actions.

disjointness_verification(t)

@spec disjointness_verification(t()) :: bool()

I am the disjointness verification function for the transparent transaction.

I check whether all actions are disjoint in terms of created and consumed resources.

from_noun(list)

@spec from_noun(Noun.t()) :: {:ok, t()} | :error

to_noun(t)

@spec to_noun(t()) :: Noun.t()

verify(t)

@spec verify(t()) :: bool()

I am the transparent transaction verification function.

I provide all the specified checks for the transaction to be considered valid.