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

@type t() :: %Anoma.Node.Examples.ETransaction{
  backend: Anoma.Node.Transaction.Backends.backend() | nil,
  id: (binary() | nil) | 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()

emit_value_returns_result()

@spec emit_value_returns_result() :: :ok

I verify that Backends.emit_value/3 returns the wrapped result rather than the bare :ok from EventBroker.event/1.

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", writes \\ [["key"]])

@spec inc(String.t(), Noun.t()) :: 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()

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_only_reserve_preserves_state(node_id \\ Node.example_random_id())

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

I verify that Ordering.reserve/3 for a purely read-only transaction preserves the reservation and shard addresses in Ordering state.

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

reserve_and_do(atom, node_id, tx_id, opts)

@spec reserve_and_do(:read | :write, String.t(), binary(), keyword()) :: any()

resubmit_trivial_swap(node_id \\ Node.example_random_id())

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

simple_transaction()

@spec simple_transaction() :: t()

I return an ETransaction struct that holds an example transaction.

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_error_keyspace(node_id \\ Node.example_random_id())

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

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() :: Noun.t()

trivial_transparent_transaction_no_eph()

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

watermark_advances_for_read_only_keys(node_id \\ Node.example_random_id())

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

I verify that shard watermarks advance for keys that are only read (not written) within a block.

Two transactions each read key ["a"] but write to different keys. After ordering, the shard for ["a"] should have its write watermark advanced so that reads at the block height proceed.

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", writes \\ [["key"]])

@spec zero(String.t(), Noun.t()) :: Noun.t()

zero_counter_submit(node_id \\ Node.example_random_id())

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