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 bytecode = self
            .bytecode
            .ok_or_else(|| ClientError::MissingRequiredField("bytecode".into()))?;

        let calldata = self.calldata.unwrap_or_default();

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

        let main_contract_hash = BytecodeHash::for_bytecode(&bytecode).value();
        let execute_calldata =
            Execute::encode_deploy_params_create(Default::default(), main_contract_hash, calldata);

        let mut factory_deps = self.factory_deps.unwrap_or_default();
        factory_deps.push(bytecode.clone());

        self.wallet
            .signer
            .sign_execute_contract_for_deploy(
                CONTRACT_DEPLOYER_ADDRESS,
                execute_calldata,
                fee,
                nonce,
                vec![bytecode.clone()],
                paymaster_params,
            )
            .await
            .map_err(ClientError::SigningError)
    }
Sends the transaction, returning the handle for its awaiting.
core/tests/loadnext/src/sdk/operations/deploy_contract.rs