Method transact

raiden/network/rpc/client.py:1159–1404

Allocates an unique `nonce` and send the transaction to the blockchain. This can fail for a few reasons: - The account doesn't have sufficient Eth to pay for the gas. - The gas price was too low. - Another transaction with the same `nonce` was sent before. This may

(self, transaction: Union[TransactionEstimated, EthTransfer])

        return pending.estimate_gas(BLOCK_ID_PENDING)

    def transact(self, transaction: Union[TransactionEstimated, EthTransfer]) -> TransactionSent:
        """Allocates an unique `nonce` and send the transaction to the blockchain.

        This can fail for a few reasons:

        - The account doesn't have sufficient Eth to pay for the gas.
        - The gas price was too low.
        - Another transaction with the same `nonce` was sent before. This may
          happen because:
          - Another application is using the same private key.
          - The node restarted and the `nonce` recovered by
            `discover_next_available_nonce` was too low, which can happend
            because:
            - The transactions currenlty in the pool are not taken into
              account.
            - There was a gap in the `nonce`s of the transaction in the pool,
              once the gap is filled a `nonce` is reused. This is most likely a
              bug.
        """

        # Exposing the JSONRPCClient with a nice name for the instance closure.
        client = self

        @dataclass
        class TransactionSlot:
            from_address: Address
            data: Union[SmartContractCall, ByteCode, EthTransfer]
            eth_node: Optional[EthClient]
            extra_log_details: Dict[str, Any]
            startgas: int
            gas_price: int
            nonce: Nonce

            def __post_init__(self) -> None:
                self.extra_log_details.setdefault("token", str(uuid4()))

                typecheck(self.from_address, T_Address)
                typecheck(self.data, (SmartContractCall, ByteCode, EthTransfer))
                typecheck(self.startgas, int)
                typecheck(self.gas_price, int)
                typecheck(self.nonce, T_Nonce)

            def to_log_details(self) -> Dict[str, Any]:
                log_details = self.data.to_log_details()
                log_details.update(self.extra_log_details)
                log_details.update(
                    {
                        "node": to_checksum_address(client.address),
                        "from_address": to_checksum_address(self.from_address),
                        "eth_node": self.eth_node,
                        "startgas": self.startgas,
                        "gas_price": self.gas_price,
                        "nonce": self.nonce,
                    }
                )
                return log_details

        # The class is hidden in the method to force this method to be called,