pub async fn tx(self) -> Result<L2Tx, ClientError> {
        let paymaster_params = self.paymaster_params.clone().unwrap_or_default();

        let fee = match self.fee {
            Some(fee) => fee,
            None => self.estimate_fee(Some(paymaster_params.clone())).await?,
        };

        let contract_address = self
            .contract_address
            .ok_or_else(|| ClientError::MissingRequiredField("contract_address".into()))?;

        let calldata = self
            .calldata
            .ok_or_else(|| ClientError::MissingRequiredField("calldata".into()))?;

        let nonce = match self.nonce {
            Some(nonce) => nonce,
            None => Nonce(self.wallet.get_nonce().await?),
        };

        self.wallet
            .signer
            .sign_execute_contract(
                contract_address,
                calldata,
                fee,
                nonce,
                self.factory_deps.unwrap_or_default(),
                paymaster_params,
            )
            .await
            .map_err(ClientError::SigningError)
    }
Sends the transaction, returning the handle for its awaiting.
core/tests/loadnext/src/sdk/operations/execute_contract.rs