Anoma.Node.Examples.ETransaction (Anoma v0.34.0)

@type t() :: %Anoma.Node.Examples.ETransaction{
  backend: Anoma.Node.Transaction.Backends.backend() | nil,
  id: binary() | nil,
  noun: Noun.t() | nil,
  result: Anoma.Node.Transaction.Mempool.tx_result() | nil
}

Functions

add_append(node_id \\ Node.example_random_id())

@spec add_append(String.t()) :: String.t()

add_rewrites(node_id \\ Node.example_random_id())

@spec add_rewrites(String.t()) :: String.t()

append_then_read(node_id \\ Node.example_random_id())

@spec append_then_read(String.t()) :: String.t()

append_then_read_same(node_id \\ Node.example_random_id())

@spec append_then_read_same(String.t()) :: String.t()

append_then_read_several(node_id \\ Node.example_random_id())

@spec append_then_read_several(String.t()) :: String.t()

append_twice_then_read(node_id \\ Node.example_random_id())

@spec append_twice_then_read(String.t()) :: String.t()

append_twice_then_read_with_commit(node_id \\ Node.example_random_id())

@spec append_twice_then_read_with_commit(String.t()) :: String.t()

bluf()

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

bluf_transaction_errors(node_id \\ Node.example_random_id())

@spec bluf_transaction_errors(String.t()) :: String.t()

bluff_txs_write_nothing(node_id \\ Node.example_random_id())

@spec bluff_txs_write_nothing(String.t()) :: String.t()

complicated_storage(node_id \\ Node.example_random_id())

@spec complicated_storage(String.t()) :: String.t()

complicated_storage_with_commit(node_id \\ Node.example_random_id())

@spec complicated_storage_with_commit(String.t()) :: String.t()

faulty_transaction(id \\ random_transaction_id())

@spec faulty_transaction(String.t()) :: t()

I return an ETransaction struct that holds an example transaction.

inc(key \\ "key")

@spec inc(String.t()) :: {Anoma.Node.Transaction.Backends.backend(), Noun.t()}

inc_counter_submit_after_bluff(node_id \\ Node.example_random_id())

@spec inc_counter_submit_after_bluff(String.t()) :: String.t()

inc_counter_submit_after_zero(node_id \\ Node.example_random_id())

@spec inc_counter_submit_after_zero(String.t()) :: String.t()

inc_counter_submit_with_zero(node_id \\ Node.example_random_id())

@spec inc_counter_submit_with_zero(String.t()) :: String.t()

ord_order_first(node_id \\ Node.example_random_id())

@spec ord_order_first(String.t()) :: String.t()

ord_read_future_then_write(node_id \\ Node.example_random_id())

@spec ord_read_future_then_write(String.t()) :: String.t()

ord_write_then_read(node_id \\ Node.example_random_id())

@spec ord_write_then_read(String.t()) :: String.t()

random_transaction_id()

@spec random_transaction_id() :: String.t()

I create a random transaction id.

read_future_then_write(node_id \\ Node.example_random_id())

@spec read_future_then_write(String.t()) :: String.t()

read_other_future_then_write(node_id \\ Node.example_random_id())

@spec read_other_future_then_write(String.t()) :: String.t()

read_txs_actually_read(node_id \\ Node.example_random_id())

@spec read_txs_actually_read(String.t()) :: String.t()

read_txs_read_recent(node_id \\ Node.example_random_id())

@spec read_txs_read_recent(String.t()) :: String.t()

read_txs_write_nothing(node_id \\ Node.example_random_id())

@spec read_txs_write_nothing(String.t()) :: String.t()

recieve_round_event(node_id, round)

@spec recieve_round_event(String.t(), non_neg_integer()) :: :ok | :error_tx

resubmit_trivial_swap(node_id \\ Node.example_random_id())

@spec resubmit_trivial_swap(String.t()) :: String.t()

simple_transaction(id \\ random_transaction_id())

@spec simple_transaction(String.t()) :: t()

I return an ETransaction struct that holds an example transaction.

start_ordering(node_id \\ Node.example_random_id())

@spec start_ordering(String.t()) :: GenServer.on_start()

start_storage(node_id \\ Node.example_random_id())

@spec start_storage(String.t()) :: GenServer.on_start()

start_tx_module(node_id \\ Node.example_random_id())

@spec start_tx_module(String.t()) :: Anoma.Node.Examples.ENode.t() | any()

submit_failed_trivial_swap(node_id \\ Node.example_random_id())

@spec submit_failed_trivial_swap(String.t()) :: String.t()

submit_successful_trivial_swap(node_id \\ Node.example_random_id())

@spec submit_successful_trivial_swap(String.t()) :: String.t()

trivial_transparent_transaction()

@spec trivial_transparent_transaction() ::
  {Anoma.Node.Transaction.Backends.backend(), Noun.t()}

trivial_transparent_transaction_no_eph()

@spec trivial_transparent_transaction_no_eph() ::
  {Anoma.Node.Transaction.Backends.backend(), Noun.t()}

write_future_multiple_then_write_present(node_id \\ Node.example_random_id())

@spec write_future_multiple_then_write_present(String.t()) :: String.t()

write_future_then_write_present(node_id \\ Node.example_random_id())

@spec write_future_then_write_present(String.t()) :: String.t()

write_multiple_then_read(node_id \\ Node.example_random_id())

@spec write_multiple_then_read(String.t()) :: String.t()

write_then_read(node_id \\ Node.example_random_id())

@spec write_then_read(String.t()) :: String.t()

write_then_read_other(node_id \\ Node.example_random_id())

@spec write_then_read_other(String.t()) :: String.t()

zero(key \\ "key")

@spec zero(String.t()) :: {Anoma.Node.Transaction.Backends.backend(), Noun.t()}

zero_counter_submit(node_id \\ Node.example_random_id())

@spec zero_counter_submit(String.t()) :: String.t()