chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/check_sql_statements.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import sys
+from subprocess import check_output
+
+# check for duplicate index names
+
+
+def check_create(sql_type: str, cwd: str, exemptions: set[tuple[str, str]] = set()) -> int:
+    # the need for this change seems to come from the git precommit plus the python pre-commit environment
+    # having GIT_DIR specified but not GIT_WORK_TREE.  this is an issue in some less common git setups
+    # such as with worktrees, at least in particular uses of them.  i think that we could switch to letting
+    # pre-commit provide the file list instead of reaching out to git to build that list ourselves.  until we
+    # make time to handle that, this is an alternative to alleviate the issue.
+    exemptions = {(cwd + "/" + file, name) for file, name in exemptions}
+    lines = check_output(["git", "grep", f"CREATE {sql_type}"]).decode("ascii").split("\n")
+
+    ret = 0
+
+    items: dict[str, str] = {}
+    for line in lines:
+        if f"CREATE {sql_type}" not in line:
+            continue
+        if line.startswith("tests/"):
+            continue
+        if "db_upgrade_func.py" in line:
+            continue
+        if not line.startswith(cwd):
+            continue
+
+        name = line.split(f"CREATE {sql_type}")[1]
+        if name.startswith(" IF NOT EXISTS"):
+            name = name[14:]
+        name = name.strip()
+        name = name.split()[0]
+        name = name.split("(")[0]
+
+        if name in items:
+            # these appear as a duplicates, but one is for v1 and the other for v2
+            if (line.split()[0][:-1], name) not in exemptions:
+                print(f'duplicate {sql_type} "{name}"\n    {items[name]}\n    {line}')
+                ret += 1
+
+        items[name] = line
+
+    return ret
+
+
+ret = 0
+
+ret += check_create("INDEX", "chia/wallet")
+ret += check_create(
+    "INDEX",
+    "chia/full_node",
+    {
+        ("block_store.py", "is_fully_compactified"),
+        ("block_store.py", "height"),
+    },
+)
+ret += check_create("TABLE", "chia/wallet")
+ret += check_create(
+    "TABLE",
+    "chia/full_node",
+    {
+        ("block_store.py", "sub_epoch_segments_v3"),
+        ("block_store.py", "full_blocks"),
+        ("coin_store.py", "coin_record"),
+        ("hint_store.py", "hints"),
+    },
+)
+sys.exit(ret)

chia/_tests/chia-start-sim

@@ -0,0 +1,42 @@
+_kill_servers() {
+  PROCS=`ps -e | grep -E 'chia|vdf_client' -v "chia-start-sim" | awk '!/grep/' | awk '{print $1}'`
+  if [ -n "$PROCS" ]; then
+    echo "$PROCS" | xargs -L1 kill -KILL
+  fi
+}
+
+_kill_servers
+
+BG_PIDS=""
+_run_bg_cmd() {
+  "$@" &
+  BG_PIDS="$BG_PIDS $!"
+}
+
+
+_term() {
+  echo "Caught TERM or INT signal, killing all servers."
+  for PID in $BG_PIDS; do
+    kill -TERM "$PID"
+  done
+  _kill_servers
+}
+
+echo "Starting local blockchain simulation. Runs a local introducer and chia system."
+echo "Note that this simulation will not work if connected to external nodes."
+
+# Starts a harvester, farmer, timelord, introducer, and 3 full nodes, locally.
+# Please note that the simulation is meant to be run locally and not connected to external nodes.
+# NOTE: you must run install.sh when changing this file
+
+ _run_bg_cmd chia_farmer --logging.log_stdout=True --logging.log_level=INFO
+ _run_bg_cmd chia_harvester --logging.log_stdout=True --logging.log_level=INFO
+ _run_bg_cmd chia_timelord --logging.log_stdout=True --logging.log_level=INFO
+ _run_bg_cmd chia_timelord_launcher --logging.log_stdout=True --logging.log_level=INFO
+_run_bg_cmd chia_introducer --logging.log_stdout=True --logging.log_level=INFO
+_run_bg_cmd chia_full_node --port=8444 --database_path="simulation_1.db" --rpc_port=8555 --introducer_peer.host="127.0.0.1" --introducer_peer.port=8445 --logging.log_stdout=True --logging.log_level=INFO --logging.log_level=INFO
+sleep 1
+_run_bg_cmd chia_full_node --port=8002 --database_path="simulation_2.db" --rpc_port=8556 --introducer_peer.host="127.0.0.1" --introducer_peer.port=8445 --logging.log_stdout=True --logging.log_level=INFO
+ _run_bg_cmd python -m chia.daemon.server --logging.log_stdout=True --logging.log_level=INFO
+
+wait

chia/_tests/clvm/benchmark_costs.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
+from chia.consensus.cost_calculator import NPCResult
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.full_node.bundle_tools import simple_solution_generator
+from chia.types.blockchain_format.program import INFINITE_COST
+from chia.types.generator_types import BlockGenerator
+from chia.types.spend_bundle import SpendBundle
+from chia.util.ints import uint64
+
+
+def cost_of_spend_bundle(spend_bundle: SpendBundle) -> int:
+    program: BlockGenerator = simple_solution_generator(spend_bundle)
+    # always use the post soft-fork2 semantics
+    npc_result: NPCResult = get_name_puzzle_conditions(
+        program,
+        INFINITE_COST,
+        mempool_mode=True,
+        height=DEFAULT_CONSTANTS.HARD_FORK_HEIGHT,
+        constants=DEFAULT_CONSTANTS,
+    )
+    return uint64(0 if npc_result.conds is None else npc_result.conds.cost)

chia/_tests/clvm/coin_store.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterator
+from dataclasses import dataclass, replace
+from typing import Optional
+
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.cost_calculator import NPCResult
+from chia.full_node.bundle_tools import simple_solution_generator
+from chia.full_node.mempool_check_conditions import mempool_check_time_locks
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_record import CoinRecord
+from chia.types.spend_bundle import SpendBundle
+from chia.util.errors import Err
+from chia.util.ints import uint32, uint64
+
+MAX_COST = 11000000000
+
+
+class BadSpendBundleError(Exception):
+    pass
+
+
+@dataclass
+class CoinTimestamp:
+    seconds: int
+    height: uint32
+
+
+class CoinStore:
+    def __init__(self, constants: ConsensusConstants, reward_mask: int = 0):
+        self._db: dict[bytes32, CoinRecord] = dict()
+        self._ph_index: dict = defaultdict(list)
+        self._reward_mask = reward_mask
+        self._constants = constants
+
+    def farm_coin(
+        self,
+        puzzle_hash: bytes32,
+        birthday: CoinTimestamp,
+        amount: int = 1024,
+        prefix=bytes32.fromhex("ccd5bb71183532bff220ba46c268991a00000000000000000000000000000000"),
+    ) -> Coin:
+        parent = bytes32(
+            [
+                a | b
+                for a, b in zip(
+                    prefix,
+                    birthday.height.to_bytes(32, "big"),
+                )
+            ],
+        )
+        # parent = birthday.height.to_bytes(32, "big")
+        coin = Coin(parent, puzzle_hash, uint64(amount))
+        self._add_coin_entry(coin, birthday)
+        return coin
+
+    def validate_spend_bundle(self, spend_bundle: SpendBundle, now: CoinTimestamp, max_cost: int) -> int:
+        # this should use blockchain consensus code
+
+        program = simple_solution_generator(spend_bundle)
+        # always use the post soft-fork2 semantics
+        result: NPCResult = get_name_puzzle_conditions(
+            program, max_cost, mempool_mode=True, height=uint32(3886635), constants=self._constants
+        )
+        if result.error is not None:
+            raise BadSpendBundleError(f"condition validation failure {Err(result.error)}")
+
+        ephemeral_db = dict(self._db)
+        assert result.conds is not None
+        for spend in result.conds.spends:
+            for puzzle_hash, amount, hint in spend.create_coin:
+                coin = Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(amount))
+                name = coin.name()
+                ephemeral_db[name] = CoinRecord(
+                    coin,
+                    uint32(now.height),
+                    uint32(0),
+                    False,
+                    uint64(now.seconds),
+                )
+
+        err = mempool_check_time_locks(
+            ephemeral_db,
+            result.conds,
+            # TODO: this is technically not right, it's supposed to be the
+            # previous transaction block's height
+            uint32(now.height),
+            # TODO: this is technically not right, it's supposed to be the
+            # previous transaction block's timestamp
+            uint64(now.seconds),
+        )
+
+        if err is not None:
+            raise BadSpendBundleError(f"condition validation failure {Err(err)}")
+
+        return 0
+
+    def update_coin_store_for_spend_bundle(
+        self,
+        spend_bundle: SpendBundle,
+        now: CoinTimestamp,
+        max_cost: int,
+    ):
+        err = self.validate_spend_bundle(spend_bundle, now, max_cost)
+        if err != 0:
+            raise BadSpendBundleError(f"validation failure {err}")
+        additions = spend_bundle.additions()
+        removals = spend_bundle.removals()
+        for new_coin in additions:
+            self._add_coin_entry(new_coin, now)
+        for spent_coin in removals:
+            coin_name = spent_coin.name()
+            coin_record = self._db[coin_name]
+            self._db[coin_name] = replace(coin_record, spent_block_index=now.height)
+        return additions, spend_bundle.coin_spends
+
+    def coins_for_puzzle_hash(self, puzzle_hash: bytes32) -> Iterator[Coin]:
+        for coin_name in self._ph_index[puzzle_hash]:
+            coin_entry = self._db[coin_name]
+            assert coin_entry.coin.puzzle_hash == puzzle_hash
+            yield coin_entry.coin
+
+    def all_coins(self) -> Iterator[Coin]:
+        for coin_entry in self._db.values():
+            yield coin_entry.coin
+
+    def all_unspent_coins(self) -> Iterator[Coin]:
+        for coin_entry in self._db.values():
+            if not coin_entry.spent:
+                yield coin_entry.coin
+
+    def _add_coin_entry(self, coin: Coin, birthday: CoinTimestamp) -> None:
+        name = coin.name()
+        # assert name not in self._db
+        self._db[name] = CoinRecord(
+            coin,
+            uint32(birthday.height),
+            uint32(0),
+            False,
+            uint64(birthday.seconds),
+        )
+        self._ph_index[coin.puzzle_hash].append(name)
+
+    def coin_record(self, coin_id: bytes32) -> Optional[CoinRecord]:
+        return self._db.get(coin_id)

chia/_tests/clvm/test_chialisp_deserialization.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import pytest
+
+from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.util.byte_types import hexstr_to_bytes
+from chia.wallet.puzzles.load_clvm import load_clvm
+
+DESERIALIZE_MOD = load_clvm("chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles")
+
+
+def serialized_atom_overflow(size):
+    if size == 0:
+        size_blob = b"\x80"
+    elif size < 0x40:
+        size_blob = bytes([0x80 | size])
+    elif size < 0x2000:
+        size_blob = bytes([0xC0 | (size >> 8), (size >> 0) & 0xFF])
+    elif size < 0x100000:
+        size_blob = bytes([0xE0 | (size >> 16), (size >> 8) & 0xFF, (size >> 0) & 0xFF])
+    elif size < 0x8000000:
+        size_blob = bytes(
+            [
+                0xF0 | (size >> 24),
+                (size >> 16) & 0xFF,
+                (size >> 8) & 0xFF,
+                (size >> 0) & 0xFF,
+            ]
+        )
+    elif size < 0x400000000:
+        size_blob = bytes(
+            [
+                0xF8 | (size >> 32),
+                (size >> 24) & 0xFF,
+                (size >> 16) & 0xFF,
+                (size >> 8) & 0xFF,
+                (size >> 0) & 0xFF,
+            ]
+        )
+    else:
+        size_blob = bytes(
+            [
+                0xFC | ((size >> 40) & 0xFF),
+                (size >> 32) & 0xFF,
+                (size >> 24) & 0xFF,
+                (size >> 16) & 0xFF,
+                (size >> 8) & 0xFF,
+                (size >> 0) & 0xFF,
+            ]
+        )
+    extra_str = "01" * 1000
+    return size_blob.hex() + extra_str
+
+
+def test_deserialization_simple_list():
+    # ("hello" "friend")
+    b = hexstr_to_bytes("ff8568656c6c6fff86667269656e6480")
+    cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+    print(cost, output)
+    prog = Program.to(output)
+    assert prog == Program.from_bytes(b)
+
+
+def test_deserialization_password_coin():
+    # (i (= (sha256 2) (q 0x2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824)) (c (q 51) (c 5 (c (q 100) (q ())))) (q "wrong password"))  # noqa
+    b = hexstr_to_bytes(
+        "ff04ffff0affff0bff0280ffff01ffa02cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98248080ffff05ffff01ff3380ffff05ff05ffff05ffff01ff6480ffff01ff8080808080ffff01ff8e77726f6e672070617373776f72648080"
+    )
+    cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+    print(cost, output)
+    prog = Program.to(output)
+    assert prog == Program.from_bytes(b)
+
+
+def test_deserialization_large_numbers():
+    # '(99999999999999999999999999999999999999999999999999999999999999999 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -99999999999999999999999999999999999999999999999999999999999999999999999999999)'  # noqa
+    b = hexstr_to_bytes(
+        "ff9c00f316271c7fc3908a8bef464e3945ef7a253609ffffffffffffffffffb00fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa1ff22ea0179500526edb610f148ec0c614155678491902d6000000000000000000180"
+    )
+    cost, output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+    print(cost, output)
+    prog = Program.to(output)
+    assert prog == Program.from_bytes(b)
+
+
+def test_overflow_atoms():
+    b = hexstr_to_bytes(serialized_atom_overflow(0xFFFFFFFF))
+    with pytest.raises(Exception):
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+
+    b = hexstr_to_bytes(serialized_atom_overflow(0x3FFFFFFFF))
+    with pytest.raises(Exception):
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+
+    b = hexstr_to_bytes(serialized_atom_overflow(0xFFFFFFFFFF))
+    with pytest.raises(Exception):
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])
+
+    b = hexstr_to_bytes(serialized_atom_overflow(0x1FFFFFFFFFF))
+    with pytest.raises(Exception):
+        _cost, _output = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [b])

chia/_tests/clvm/test_clvm_step.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from clvm_tools_rs import start_clvm_program
+
+factorial = (
+    "ff02ffff01ff02ff02ffff04ff02ffff04ff05ff80808080ffff04ffff01ff02"
+    + "ffff03ffff09ff05ffff010180ffff01ff0101ffff01ff12ff05ffff02ff02ff"
+    + "ff04ff02ffff04ffff11ff05ffff010180ff808080808080ff0180ff018080"
+)
+
+factorial_function_hash = "de3687023fa0a095d65396f59415a859dd46fc84ed00504bf4c9724fca08c9de"
+factorial_sym = {factorial_function_hash: "factorial"}
+
+
+def test_simple_program_run() -> None:
+    p = start_clvm_program(factorial, "ff0580", factorial_sym)
+
+    last: Optional[Any] = None
+    location: Optional[Any] = None
+
+    while not p.is_ended():
+        step_result = p.step()
+        if step_result is not None:
+            last = step_result
+            assert "Failure" not in last
+
+            if "Operator-Location" in last:
+                location = last["Operator-Location"]
+
+    assert last is not None
+    assert location is not None
+    if last is not None and location is not None:
+        assert "Final" in last
+        assert int(last["Final"]) == 120
+        assert location.startswith("factorial")

chia/_tests/clvm/test_condition_codes.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import importlib_resources
+from clvm.casts import int_from_bytes
+
+from chia.types.condition_opcodes import ConditionOpcode
+
+
+def test_condition_codes_is_complete() -> None:
+    condition_codes_path = importlib_resources.files("chia.wallet.puzzles").joinpath("condition_codes.clib")
+    contents = condition_codes_path.read_text(encoding="utf-8")
+    for opcode in ConditionOpcode:
+        assert f"(defconstant {opcode.name} {int_from_bytes(opcode.value)})" in contents

chia/_tests/clvm/test_curry_and_treehash.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import pytest
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle  # import (puzzle_for_pk, puzzle_hash_for_pk, MOD)
+from chia.wallet.util.curry_and_treehash import (
+    calculate_hash_of_quoted_mod_hash,
+    curry_and_treehash,
+    shatree_atom,
+    shatree_atom_list,
+    shatree_int,
+)
+
+
+def test_curry_and_treehash() -> None:
+    arbitrary_mod = p2_delegated_puzzle_or_hidden_puzzle.MOD
+    arbitrary_mod_hash = arbitrary_mod.get_tree_hash()
+
+    # we don't really care what `arbitrary_mod` is. We just need some code
+
+    quoted_mod_hash = calculate_hash_of_quoted_mod_hash(arbitrary_mod_hash)
+
+    for v in range(500):
+        args = [v, v * v, v * v * v]
+        # we don't really care about the arguments either
+        puzzle = arbitrary_mod.curry(*args)
+        puzzle_hash_via_curry = puzzle.get_tree_hash()
+        hashed_args = [Program.to(_).get_tree_hash() for _ in args]
+        puzzle_hash_via_f = curry_and_treehash(quoted_mod_hash, *hashed_args)
+        assert puzzle_hash_via_curry == puzzle_hash_via_f
+
+
+@pytest.mark.parametrize(
+    "value", [[], [bytes32([3] * 32)], [bytes32.zeros, bytes32([1] * 32)], [bytes([1]), bytes([1, 2, 3])]]
+)
+def test_shatree_atom_list(value: list[bytes]) -> None:
+    h1 = shatree_atom_list(value)
+    h2 = Program.to(value).get_tree_hash()
+    assert h1 == h2
+
+
+@pytest.mark.parametrize("value", [0, -1, 1, 0x7F, 0x80, 100000000, -10000000])
+def test_shatree_int(value: int) -> None:
+    h1 = shatree_int(value)
+    h2 = Program.to(value).get_tree_hash()
+    assert h1 == h2
+
+
+@pytest.mark.parametrize("value", [bytes([1] * 1), bytes([]), bytes([5] * 1000)])
+def test_shatree_atom(value: bytes) -> None:
+    h1 = shatree_atom(value)
+    h2 = Program.to(value).get_tree_hash()
+    assert h1 == h2

chia/_tests/clvm/test_message_conditions.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import dataclasses
+
+import pytest
+from chia_rs import Coin, G2Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint64
+
+from chia._tests.util.spend_sim import CostLogger, sim_and_client
+from chia.types.blockchain_format.program import Program
+from chia.types.coin_spend import make_spend
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.errors import Err
+from chia.wallet.conditions import MessageParticipant, ReceiveMessage, SendMessage
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+ACS = Program.to(1)
+ACS_PH = ACS.get_tree_hash()
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "mode",
+    [i for i in range(0b001001, 0b111111 + 1) if i % 8 != 0],  # skipping anything ending in 000
+)
+async def test_basic_message_send_receive(mode: int, cost_logger: CostLogger) -> None:
+    async with sim_and_client() as (sim, client):
+        # Farm two ACS coins
+        await sim.farm_block(ACS_PH)
+        [sender_coin, receiver_coin] = await client.get_coin_records_by_puzzle_hash(ACS_PH)
+
+        # Try only a sent message
+        send_condition = SendMessage(
+            b"foo",
+            mode_integer=uint8(mode),
+            receiver=MessageParticipant(
+                parent_id_committed=receiver_coin.coin.parent_coin_info if mode & 0b000100 else None,
+                puzzle_hash_committed=receiver_coin.coin.puzzle_hash if mode & 0b000010 else None,
+                amount_committed=receiver_coin.coin.amount if mode & 0b000001 else None,
+                coin_id_committed=receiver_coin.coin.name() if mode & 0b000111 == 0b000111 else None,
+            ),
+        )
+        only_sender = WalletSpendBundle(
+            [
+                make_spend(
+                    sender_coin.coin,
+                    ACS,
+                    Program.to([send_condition.to_program()]),
+                ),
+            ],
+            G2Element(),
+        )
+        result = await client.push_tx(only_sender)
+        assert result == (MempoolInclusionStatus.FAILED, Err.MESSAGE_NOT_SENT_OR_RECEIVED)
+
+        # Try only a received message
+        receive_condition = ReceiveMessage(
+            b"foo",
+            mode_integer=uint8(mode),
+            sender=MessageParticipant(
+                parent_id_committed=sender_coin.coin.parent_coin_info if mode & 0b100000 else None,
+                puzzle_hash_committed=sender_coin.coin.puzzle_hash if mode & 0b010000 else None,
+                amount_committed=sender_coin.coin.amount if mode & 0b001000 else None,
+                coin_id_committed=sender_coin.coin.name() if mode & 0b111000 == 0b111000 else None,
+            ),
+        )
+        only_receiver = WalletSpendBundle(
+            [
+                make_spend(
+                    receiver_coin.coin,
+                    ACS,
+                    Program.to([receive_condition.to_program()]),
+                ),
+            ],
+            G2Element(),
+        )
+        result = await client.push_tx(only_receiver)
+        assert result == (MempoolInclusionStatus.FAILED, Err.MESSAGE_NOT_SENT_OR_RECEIVED)
+
+        # Make sure they succeed together
+        result = await client.push_tx(WalletSpendBundle.aggregate([only_sender, only_receiver]))
+        assert result == (MempoolInclusionStatus.SUCCESS, None)
+
+        # Quickly test back and forth parsing
+        assert SendMessage.from_program(send_condition.to_program()).to_program() == send_condition.to_program()
+        assert (
+            ReceiveMessage.from_program(receive_condition.to_program()).to_program() == receive_condition.to_program()
+        )
+
+        # Quickly test mode calculation
+        assert (
+            dataclasses.replace(send_condition, sender=receive_condition.sender, mode_integer=None).mode
+            == send_condition.mode
+        )
+        assert (
+            dataclasses.replace(receive_condition, receiver=send_condition.receiver, mode_integer=None).mode
+            == receive_condition.mode
+        )
+
+
+def test_message_error_conditions() -> None:
+    with pytest.raises(ValueError, match="Must specify at least one committment"):
+        MessageParticipant()
+
+    test_coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
+    with pytest.raises(ValueError, match="You must specify all or none"):
+        MessageParticipant(coin_id_committed=test_coin.name(), parent_id_committed=bytes32.zeros)
+
+    with pytest.raises(AssertionError, match="The value for coin_id_committed must be equal"):
+        MessageParticipant(
+            coin_id_committed=test_coin.name(),
+            parent_id_committed=bytes32.zeros,
+            puzzle_hash_committed=bytes32.zeros,
+            amount_committed=uint64(1),
+        )
+
+    for mode in range(0b001, 0b111 + 1):
+        with pytest.raises(AssertionError, match="If mode_integer is manually specified"):
+            MessageParticipant(
+                mode_integer=uint8(mode),
+                parent_id_committed=test_coin.parent_coin_info if not mode & 0b100 else None,
+                puzzle_hash_committed=test_coin.puzzle_hash if not mode & 0b010 else None,
+                amount_committed=test_coin.amount if (not mode & 0b001) or (mode == 0b111) else None,
+            )
+
+    with pytest.raises(ValueError, match="without committment information"):
+        MessageParticipant(
+            mode_integer=uint8(0b111),
+        ).necessary_args
+
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+        SendMessage(
+            msg=b"foo",
+            sender=MessageParticipant(coin_id_committed=test_coin.name()),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either mode_integer or both sender and reciever"):
+        SendMessage(
+            msg=b"foo",
+            receiver=MessageParticipant(coin_id_committed=test_coin.name()),
+        )
+
+    with pytest.raises(AssertionError, match="don't match the sender's mode"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            sender=MessageParticipant(mode_integer=uint8(0b001)),
+        )
+
+    with pytest.raises(AssertionError, match="don't match the receiver's mode"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            receiver=MessageParticipant(mode_integer=uint8(0b001)),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either var_args or receiver"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+        )
+
+    with pytest.raises(ValueError, match="Must specify either var_args or sender"):
+        ReceiveMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+        )
+
+    with pytest.raises(AssertionError, match="do not match the specified arguments"):
+        SendMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            var_args=[Program.to(test_coin.name())],
+            receiver=MessageParticipant(coin_id_committed=bytes32.zeros),
+        )
+
+    with pytest.raises(AssertionError, match="do not match the specified arguments"):
+        ReceiveMessage(
+            msg=b"foo",
+            mode_integer=uint8(0b111111),
+            var_args=[Program.to(test_coin.name())],
+            sender=MessageParticipant(coin_id_committed=bytes32.zeros),
+        )