chia-blockchain 2.4.4__py3-none-any.whl

chia/types/mempool_item.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.spend_bundle import SpendBundle
+from chia.types.spend_bundle_conditions import SpendBundleConditions
+from chia.util.ints import uint32, uint64
+from chia.util.streamable import recurse_jsonify
+
+
+@dataclass(frozen=True)
+class BundleCoinSpend:
+    coin_spend: CoinSpend
+    eligible_for_dedup: bool
+    eligible_for_fast_forward: bool
+    additions: List[Coin]
+    # cost on the specific solution in this item
+    cost: Optional[uint64] = None
+
+
+@dataclass(frozen=True)
+class MempoolItem:
+    spend_bundle: SpendBundle
+    fee: uint64
+    conds: SpendBundleConditions
+    spend_bundle_name: bytes32
+    height_added_to_mempool: uint32
+
+    # If present, this SpendBundle is not valid at or before this height
+    assert_height: Optional[uint32] = None
+
+    # If present, this SpendBundle is not valid once the block height reaches
+    # the specified height
+    assert_before_height: Optional[uint32] = None
+    assert_before_seconds: Optional[uint64] = None
+
+    # Map of coin ID to coin spend data between the bundle and its
+    # SpendBundleConditions
+    bundle_coin_spends: Dict[bytes32, BundleCoinSpend] = field(default_factory=dict)
+
+    def __lt__(self, other: MempoolItem) -> bool:
+        return self.fee_per_cost < other.fee_per_cost
+
+    def __hash__(self) -> int:
+        return hash(self.spend_bundle_name)
+
+    @property
+    def fee_per_cost(self) -> float:
+        return int(self.fee) / int(self.cost)
+
+    @property
+    def name(self) -> bytes32:
+        return self.spend_bundle_name
+
+    @property
+    def cost(self) -> uint64:
+        return uint64(0 if self.conds is None else self.conds.cost)
+
+    @property
+    def additions(self) -> List[Coin]:
+        additions: List[Coin] = []
+        for spend in self.conds.spends:
+            for puzzle_hash, amount, _ in spend.create_coin:
+                coin = Coin(spend.coin_id, puzzle_hash, uint64(amount))
+                additions.append(coin)
+        return additions
+
+    @property
+    def removals(self) -> List[Coin]:
+        return self.spend_bundle.removals()
+
+    def to_json_dict(self) -> Dict[str, Any]:
+        return {
+            "spend_bundle": recurse_jsonify(self.spend_bundle),
+            "fee": recurse_jsonify(self.fee),
+            "npc_result": {"Error": None, "conds": recurse_jsonify(self.conds)},
+            "cost": recurse_jsonify(self.cost),
+            "spend_bundle_name": recurse_jsonify(self.spend_bundle_name),
+            "additions": recurse_jsonify(self.additions),
+            "removals": recurse_jsonify(self.removals),
+        }

chia/types/mempool_submission_status.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Union
+
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.ints import uint8
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclass(frozen=True)
+class MempoolSubmissionStatus(Streamable):
+    """
+    :sent_to: in `TradeRecord` and `TransactionRecord` are a
+    Tuple of (peer_id: str, status: MempoolInclusionStatus, error: Optional[str])
+    MempoolInclusionStatus is represented as a uint8 in those structs so they can be `Streamable`
+    """
+
+    peer_id: str
+    inclusion_status: uint8  # MempoolInclusionStatus
+    error_msg: Optional[str]
+
+    def to_json_dict_convenience(self) -> Dict[str, Union[str, MempoolInclusionStatus, Optional[str]]]:
+        formatted = self.to_json_dict()
+        formatted["inclusion_status"] = MempoolInclusionStatus(self.inclusion_status).name
+        return formatted
+
+    def __str__(self) -> str:
+        return f"{self.to_json_dict_convenience()}"

chia/types/mojos.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from typing import NewType
+
+from chia.util.ints import uint64
+
+Mojos = NewType("Mojos", uint64)

chia/types/peer_info.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import ipaddress
+from dataclasses import dataclass
+from typing import Union
+
+from chia.util.ints import uint16, uint64
+from chia.util.network import IPAddress
+from chia.util.streamable import Streamable, streamable
+
+
+@dataclass(frozen=True)
+class UnresolvedPeerInfo:
+    host: str
+    port: uint16
+
+
+# TODO, Replace unsafe_hash with frozen and drop the __init__ as soon as all PeerInfo call sites pass in an IPAddress.
+@dataclass(unsafe_hash=True)
+class PeerInfo:
+    _ip: IPAddress
+    _port: uint16
+
+    # TODO, Drop this as soon as all call PeerInfo calls pass in an IPAddress
+    def __init__(self, host: Union[IPAddress, str], port: int):
+        self._ip = host if isinstance(host, IPAddress) else IPAddress.create(host)
+        self._port = uint16(port)
+
+    # Kept here for compatibility until all places where its used transitioned to IPAddress instead of str.
+    @property
+    def host(self) -> str:
+        return str(self._ip)
+
+    @property
+    def ip(self) -> IPAddress:
+        return self._ip
+
+    @property
+    def port(self) -> uint16:
+        return self._port
+
+    # Functions related to peer bucketing in new/tried tables.
+    def get_key(self) -> bytes:
+        if self.ip.is_v4:
+            key = ipaddress.IPv6Address(int(ipaddress.IPv6Address("2002::")) | (int(self.ip) << 80)).packed
+        else:
+            key = self.ip.packed
+        key += bytes([self.port // 0x100, self.port & 0x0FF])
+        return key
+
+    def get_group(self) -> bytes:
+        # TODO: Port everything from Bitcoin.
+        if self.ip.is_v4:
+            return bytes([1]) + self.ip.packed[:2]
+        else:
+            return bytes([0]) + self.ip.packed[:4]
+
+
+@streamable
+@dataclass(frozen=True)
+class TimestampedPeerInfo(Streamable):
+    host: str
+    port: uint16
+    timestamp: uint64

chia/types/signing_mode.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class SigningMode(Enum):
+    # Cipher suites used for BLS signatures defined at:
+    # https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature-05#name-ciphersuites
+
+    # CHIP-0002 signs the result of sha256tree(cons("Chia Signed Message", message)) using the
+    # BLS message augmentation scheme
+    CHIP_0002 = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG:CHIP-0002_"
+
+    # Same as above but with the message specified as a string of hex characters
+    CHIP_0002_HEX_INPUT = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG:CHIP-0002_HEX"
+
+    # Standard BLS signatures used by Chia use the BLS message augmentation scheme
+    # https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-bls-signature-05#name-sign
+    BLS_MESSAGE_AUGMENTATION_UTF8_INPUT = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG:utf8input_"
+
+    # Same as above but with the message specified as a string of hex characters
+    BLS_MESSAGE_AUGMENTATION_HEX_INPUT = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG:hexinput_"
+
+    # Use for verifying signatures made with Tangem cards
+    CHIP_0002_P2_DELEGATED_CONDITIONS = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG:CHIP-0002_P2_DELEGATED_PUZZLE"
+
+
+# https://github.com/Chia-Network/chips/blob/80e4611fe52b174bf1a0382b9dff73805b18b8c6/CHIPs/chip-0002.md#signmessage
+CHIP_0002_SIGN_MESSAGE_PREFIX = "Chia Signed Message"

chia/types/spend_bundle.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+import chia_rs
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.util.errors import Err, ValidationError
+
+from .coin_spend import compute_additions_with_cost
+
+SpendBundle = chia_rs.SpendBundle
+T_SpendBundle = TypeVar("T_SpendBundle", bound="SpendBundle")
+
+
+# This function executes all the puzzles to compute the difference between
+# additions and removals
+def estimate_fees(spend_bundle: SpendBundle) -> int:
+    """Unsafe to use for fees validation!!!"""
+    removed_amount = 0
+    added_amount = 0
+    max_cost = int(DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM)
+    for cs in spend_bundle.coin_spends:
+        removed_amount += cs.coin.amount
+        coins, cost = compute_additions_with_cost(cs, max_cost=max_cost)
+        max_cost -= cost
+        if max_cost < 0:
+            raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "estimate_fees() for SpendBundle")
+        for c in coins:
+            added_amount += c.amount
+    return removed_amount - added_amount

chia/types/spend_bundle_conditions.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import chia_rs
+
+ELIGIBLE_FOR_DEDUP = chia_rs.ELIGIBLE_FOR_DEDUP
+SpendConditions = chia_rs.SpendConditions
+SpendBundleConditions = chia_rs.SpendBundleConditions

chia/types/transaction_queue_entry.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+from dataclasses import dataclass, field
+from typing import ClassVar, Generic, Optional, Tuple, TypeVar, Union
+
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.types.spend_bundle import SpendBundle
+from chia.util.errors import Err
+
+T = TypeVar("T")
+
+
+class ValuedEventSentinel:
+    pass
+
+
+@dataclasses.dataclass
+class ValuedEvent(Generic[T]):
+    _value_sentinel: ClassVar[ValuedEventSentinel] = ValuedEventSentinel()
+
+    _event: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
+    _value: Union[ValuedEventSentinel, T] = _value_sentinel
+
+    def set(self, value: T) -> None:
+        if not isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value already set")
+        self._value = value
+        self._event.set()
+
+    async def wait(self) -> T:
+        await self._event.wait()
+        if isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value not set despite event being set")
+        return self._value
+
+
+@dataclass(frozen=True)
+class TransactionQueueEntry:
+    """
+    A transaction received from peer. This is put into a queue, and not yet in the mempool.
+    """
+
+    transaction: SpendBundle = field(compare=False)
+    transaction_bytes: Optional[bytes] = field(compare=False)
+    spend_name: bytes32
+    peer: Optional[WSChiaConnection] = field(compare=False)
+    test: bool = field(compare=False)
+    done: ValuedEvent[Tuple[MempoolInclusionStatus, Optional[Err]]] = field(
+        default_factory=ValuedEvent,
+        compare=False,
+    )

chia/types/unfinished_block.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import chia_rs
+
+UnfinishedBlock = chia_rs.UnfinishedBlock

chia/types/unfinished_header_block.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from chia.types.blockchain_format.foliage import Foliage, FoliageTransactionBlock
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.vdf import VDFProof
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.util.ints import uint128
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclass(frozen=True)
+class UnfinishedHeaderBlock(Streamable):
+    # Same as a FullBlock but without TransactionInfo and Generator, used by light clients
+    finished_sub_slots: List[EndOfSubSlotBundle]  # If first sb
+    reward_chain_block: RewardChainBlockUnfinished  # Reward chain trunk data
+    challenge_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot
+    reward_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot
+    foliage: Foliage  # Reward chain foliage data
+    foliage_transaction_block: Optional[FoliageTransactionBlock]  # Reward chain foliage data (tx block)
+    transactions_filter: bytes  # Filter for block transactions
+
+    @property
+    def prev_header_hash(self) -> bytes32:
+        return self.foliage.prev_block_hash
+
+    @property
+    def header_hash(self) -> bytes32:
+        return self.foliage.get_hash()
+
+    @property
+    def total_iters(self) -> uint128:
+        return self.reward_chain_block.total_iters

chia/types/weight_proof.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+
+import chia_rs
+
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlock
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.types.header_block import HeaderBlock
+from chia.util.streamable import Streamable, streamable
+
+SubEpochData = chia_rs.SubEpochData
+
+# number of challenge blocks
+# Average iters for challenge blocks
+# |--A-R----R-------R--------R------R----R----------R-----R--R---|       Honest difficulty 1000
+#           0.16
+
+#  compute total reward chain blocks
+# |----------------------------A---------------------------------|       Attackers chain 1000
+#                            0.48
+# total number of challenge blocks == total number of reward chain blocks
+
+
+SubEpochChallengeSegment = chia_rs.SubEpochChallengeSegment
+SubEpochSegments = chia_rs.SubEpochSegments
+SubSlotData = chia_rs.SubSlotData
+
+
+@streamable
+@dataclass(frozen=True)
+# this is used only for serialization to database
+class RecentChainData(Streamable):
+    recent_chain_data: List[HeaderBlock]
+
+
+@streamable
+@dataclass(frozen=True)
+class ProofBlockHeader(Streamable):
+    finished_sub_slots: List[EndOfSubSlotBundle]
+    reward_chain_block: RewardChainBlock
+
+
+@streamable
+@dataclass(frozen=True)
+class WeightProof(Streamable):
+    sub_epochs: List[SubEpochData]
+    sub_epoch_segments: List[SubEpochChallengeSegment]  # sampled sub epoch
+    recent_chain_data: List[HeaderBlock]

chia/util/action_scope.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass, field
+from typing import AsyncIterator, Awaitable, Callable, Generic, Optional, Protocol, Type, TypeVar, final
+
+import aiosqlite
+
+from chia.util.db_wrapper import DBWrapper2, execute_fetchone
+
+
+class ResourceManager(Protocol):
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def managed(cls, initial_resource: SideEffects) -> AsyncIterator[ResourceManager]:  # pragma: no cover
+        # yield included to make this a generator as expected by @contextlib.asynccontextmanager
+        yield  # type: ignore[misc]
+
+    @contextlib.asynccontextmanager
+    async def use(self) -> AsyncIterator[None]:  # pragma: no cover
+        # yield included to make this a generator as expected by @contextlib.asynccontextmanager
+        yield
+
+    async def get_resource(self, resource_type: Type[_T_SideEffects]) -> _T_SideEffects: ...
+
+    async def save_resource(self, resource: SideEffects) -> None: ...
+
+
+@dataclass
+class SQLiteResourceManager:
+
+    _db: DBWrapper2
+    _active_writer: Optional[aiosqlite.Connection] = field(init=False, default=None)
+
+    def get_active_writer(self) -> aiosqlite.Connection:
+        if self._active_writer is None:
+            raise RuntimeError("Can only access resources while under `use()` context manager")
+
+        return self._active_writer
+
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def managed(cls, initial_resource: SideEffects) -> AsyncIterator[ResourceManager]:
+        async with DBWrapper2.managed(":memory:", reader_count=0) as db:
+            self = cls(db)
+            async with self._db.writer() as conn:
+                await conn.execute("CREATE TABLE side_effects(total blob)")
+                await conn.execute(
+                    "INSERT INTO side_effects VALUES(?)",
+                    (bytes(initial_resource),),
+                )
+            yield self
+
+    @contextlib.asynccontextmanager
+    async def use(self) -> AsyncIterator[None]:
+        if self._active_writer is not None:
+            raise RuntimeError("SQLiteResourceManager cannot currently support nested transactions")
+        async with self._db.writer() as conn:
+            self._active_writer = conn
+            try:
+                yield
+            finally:
+                self._active_writer = None
+
+    async def get_resource(self, resource_type: Type[_T_SideEffects]) -> _T_SideEffects:
+        row = await execute_fetchone(self.get_active_writer(), "SELECT total FROM side_effects")
+        assert row is not None
+        side_effects = resource_type.from_bytes(row[0])
+        return side_effects
+
+    async def save_resource(self, resource: SideEffects) -> None:
+        # This sets all rows (there's only one) to the new serialization
+        await self.get_active_writer().execute(
+            "UPDATE side_effects SET total=?",
+            (bytes(resource),),
+        )
+
+
+class SideEffects(Protocol):
+    def __bytes__(self) -> bytes: ...
+
+    @classmethod
+    def from_bytes(cls: Type[_T_SideEffects], blob: bytes) -> _T_SideEffects: ...
+
+
+_T_SideEffects = TypeVar("_T_SideEffects", bound=SideEffects)
+_T_Config = TypeVar("_T_Config")
+
+
+@final
+@dataclass
+class ActionScope(Generic[_T_SideEffects, _T_Config]):
+    """
+    The idea of an "action" is to map a single client input to many potentially distributed functions and side
+    effects. The action holds on to a temporary state that the many callers modify at will but only one at a time.
+    When the action is closed, the state is still available and can be committed elsewhere or discarded.
+
+    Utilizes a "resource manager" to hold the state in order to take advantage of rollbacks and prevent concurrent tasks
+    from interfering with each other.
+    """
+
+    _resource_manager: ResourceManager
+    _side_effects_format: Type[_T_SideEffects]
+    _config: _T_Config  # An object not intended to be mutated during the lifetime of the scope
+    _callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]] = None
+    _final_side_effects: Optional[_T_SideEffects] = field(init=False, default=None)
+
+    @property
+    def side_effects(self) -> _T_SideEffects:
+        if self._final_side_effects is None:
+            raise RuntimeError(
+                "Can only request ActionScope.side_effects after exiting context manager. "
+                "While in context manager, use ActionScope.use()."
+            )
+
+        return self._final_side_effects
+
+    @property
+    def config(self) -> _T_Config:
+        return self._config
+
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def new_scope(
+        cls,
+        side_effects_format: Type[_T_SideEffects],
+        # I want a default here in case a use case doesn't want to take advantage of the config but no default seems to
+        # satisfy the type hint _T_Config so we'll just ignore this.
+        config: _T_Config = object(),  # type: ignore[assignment]
+        resource_manager_backend: Type[ResourceManager] = SQLiteResourceManager,
+    ) -> AsyncIterator[ActionScope[_T_SideEffects, _T_Config]]:
+        async with resource_manager_backend.managed(side_effects_format()) as resource_manager:
+            self = cls(_resource_manager=resource_manager, _side_effects_format=side_effects_format, _config=config)
+
+            yield self
+
+            async with self.use(_callbacks_allowed=False) as interface:
+                if self._callback is not None:
+                    await self._callback(interface)
+                self._final_side_effects = interface.side_effects
+
+    @contextlib.asynccontextmanager
+    async def use(self, _callbacks_allowed: bool = True) -> AsyncIterator[StateInterface[_T_SideEffects]]:
+        async with self._resource_manager.use():
+            side_effects = await self._resource_manager.get_resource(self._side_effects_format)
+            interface = StateInterface(side_effects, _callbacks_allowed, self._callback)
+
+            yield interface
+
+            await self._resource_manager.save_resource(interface.side_effects)
+            self._callback = interface.callback
+
+
+@dataclass
+class StateInterface(Generic[_T_SideEffects]):
+    side_effects: _T_SideEffects
+    _callbacks_allowed: bool
+    _callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]] = None
+
+    @property
+    def callback(self) -> Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]]:
+        return self._callback
+
+    def set_callback(self, new_callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]]) -> None:
+        if not self._callbacks_allowed:
+            raise RuntimeError("Callback cannot be edited from inside itself")
+
+        self._callback = new_callback

chia/util/api_decorators.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import functools
+import logging
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional, Type, TypeVar, Union, get_type_hints
+
+from typing_extensions import Concatenate, ParamSpec
+
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.util.streamable import Streamable
+
+log = logging.getLogger(__name__)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+S = TypeVar("S", bound=Streamable)
+Self = TypeVar("Self")
+
+
+metadata_attribute_name = "_chia_api_metadata"
+
+
+@dataclass
+class ApiMetadata:
+    request_type: ProtocolMessageTypes
+    message_class: Type[Streamable]
+    peer_required: bool = False
+    bytes_required: bool = False
+    execute_task: bool = False
+    reply_types: List[ProtocolMessageTypes] = field(default_factory=list)
+
+
+def get_metadata(function: Callable[..., object]) -> Optional[ApiMetadata]:
+    return getattr(function, metadata_attribute_name, None)
+
+
+def _set_metadata(function: Callable[..., object], metadata: ApiMetadata) -> None:
+    setattr(function, metadata_attribute_name, metadata)
+
+
+# TODO: This hinting does not express that the returned callable *_bytes parameter
+#       corresponding to the first parameter name will be filled in by the wrapper.
+def api_request(
+    peer_required: bool = False,
+    bytes_required: bool = False,
+    execute_task: bool = False,
+    reply_types: Optional[List[ProtocolMessageTypes]] = None,
+) -> Callable[[Callable[Concatenate[Self, S, P], R]], Callable[Concatenate[Self, Union[bytes, S], P], R]]:
+    non_optional_reply_types: List[ProtocolMessageTypes]
+    if reply_types is None:
+        non_optional_reply_types = []
+    else:
+        non_optional_reply_types = reply_types
+
+    def inner(f: Callable[Concatenate[Self, S, P], R]) -> Callable[Concatenate[Self, Union[bytes, S], P], R]:
+        @functools.wraps(f)
+        def wrapper(self: Self, original: Union[bytes, S], *args: P.args, **kwargs: P.kwargs) -> R:
+            arg: S
+            if isinstance(original, bytes):
+                if metadata.bytes_required:
+                    kwargs[message_name_bytes] = original
+                arg = message_class.from_bytes(original)
+            else:
+                arg = original
+                if metadata.bytes_required:
+                    kwargs[message_name_bytes] = bytes(original)
+
+            return f(self, arg, *args, **kwargs)
+
+        message_name, message_class = next(
+            (name, hint) for name, hint in get_type_hints(f).items() if name not in {"self", "peer", "return"}
+        )
+        message_name_bytes = f"{message_name}_bytes"
+
+        metadata = ApiMetadata(
+            request_type=getattr(ProtocolMessageTypes, f.__name__),
+            peer_required=peer_required,
+            bytes_required=bytes_required,
+            execute_task=execute_task,
+            reply_types=non_optional_reply_types,
+            message_class=message_class,
+        )
+
+        _set_metadata(function=wrapper, metadata=metadata)
+
+        return wrapper
+
+    return inner