Transaction

def get_block(self, with_tx_data: bool = False):
    from eth_rpc.block import Block

    """Load a block hash"""

    return Block.load_by_hash(self.block_hash, with_tx_data=with_tx_data)

def model_post_init(self, __context):
    network = self.__class__._network
    object.__setattr__(self, "_network", network)
    # overwrite the .rpc() classmethod
    object.__setattr__(self, "rpc", self._rpc)

@classmethod
def rpc(cls) -> "RPC":
    """
    This uses the default network, unless a network has been provided
    """
    from ._transport import _force_get_global_rpc

    if cls._network is None:
        return _force_get_global_rpc()
    response = _force_get_global_rpc(cls._network)
    return response

@classmethod
def get_by_hash(
    self, tx_hash: HexStr
) -> RPCResponseModel[TransactionRequest, Optional["Transaction[Network]"]]:
    return RPCResponseModel(
        self.rpc().get_tx_by_hash,
        TransactionRequest(
            tx_hash=tx_hash,
        ),
    )

@classmethod
def get_pending_by_hash(
    self, tx_hash: HexStr
) -> RPCResponseModel[TransactionRequest, PendingTransaction]:
    return RPCResponseModel(
        self.rpc().get_pending_tx_by_hash,
        TransactionRequest(
            tx_hash=tx_hash,
        ),
    )

@classmethod
def get_receipt_by_hash(
    self, tx_hash: HexStr
) -> RPCResponseModel[TransactionRequest, "Transaction[Network]"]:
    return RPCResponseModel(
        self.rpc().get_tx_receipt,
        TransactionRequest(
            tx_hash=tx_hash,
        ),
    )

@classmethod
def send_raw_transaction(
    cls, tx: HexStr
) -> RPCResponseModel[RawTransaction, HexStr]:
    return RPCResponseModel(
        cls.rpc().send_raw_tx,
        RawTransaction(
            signed_tx=tx,
        ),
    )

@classmethod
def get_by_index(
    self,
    transaction_index: int,
    block_hash: HexStr | None = None,
    block_number: int | BLOCK_STRINGS | None = None,
) -> RPCResponseModel[
    GetTransactionByBlockHash | GetTransactionByBlockNumber, "Transaction[Network]"
]:
    if block_hash is None and block_number is None:
        raise ValueError("Must provide either block_hash or block_number")
    if block_hash:
        return RPCResponseModel(
            self.rpc().get_tx_by_block_hash,
            GetTransactionByBlockHash(
                block_hash=block_hash,
                index=HexInteger(transaction_index),
            ),
        )
    block_number = cast(int | BLOCK_STRINGS, block_number)
    return RPCResponseModel(
        self.rpc().get_tx_by_block_number,
        GetTransactionByBlockNumber(
            block_number=(
                HexInteger(block_number)
                if isinstance(block_number, int)
                else block_number
            ),
            index=HexInteger(transaction_index),
        ),
    )

@classmethod
async def subscribe_pending(  # noqa: C901
    self,
) -> AsyncIterator[PendingTransaction]:  # noqa: C901
    rpc = _force_get_global_rpc()
    async for w3_connection in connect(
        rpc.wss,
        ping_interval=60,
        ping_timeout=60,
        max_queue=10000,
        open_timeout=30,
    ):
        try:
            await self._send_subscription_request(
                w3_connection,
            )
            subscription_response: SubscriptionResponse = json.loads(
                await w3_connection.recv()
            )
            if not subscription_response.get("result"):
                raise ValueError(subscription_response)
        except Exception as e:
            raise e

        while True:
            try:
                message = await asyncio.wait_for(w3_connection.recv(), timeout=32.0)
                message_json: JsonPendingWssResponse = json.loads(message)
                if "params" not in message_json:
                    raise ValueError(message_json)

                transaction_hash: HexStr = message_json["params"]["result"]
                transaction = await self.get_pending_by_hash(transaction_hash)
                if transaction:
                    yield transaction
            except asyncio.exceptions.TimeoutError:
                pass
            except (
                ConnectionClosedError,
                ConnectionResetError,
                OSError,  # No route to host
                asyncio.exceptions.IncompleteReadError,  # TODO: should this be handled differently?
            ) as err:
                logger.error("connection terminated unexpectedly: %s", err)
                await asyncio.sleep(1)
                # we're in an iterator, so make a new connection and continue listening
                break
            except Exception as err:
                logger.error("unknown connection error: %s", err)
                await asyncio.sleep(1)
                # we're in an iterator, so make a new connection and continue listening
                break

def receipt(
    self,
) -> RPCResponseModel[TransactionRequest, Optional[TransactionReceipt]]:
    return RPCResponseModel(
        self.rpc().get_tx_receipt,
        TransactionRequest(
            tx_hash=self.hash,
        ),
    )