Method handle_broadcast_command

bridge/src/client/cli/client_command.rs:454–520

(&mut self, sub_matches: &ArgMatches)

    }

    pub async fn handle_broadcast_command(&mut self, sub_matches: &ArgMatches) -> io::Result<()> {
        self.client.sync().await;

        let subcommand = sub_matches.subcommand();
        let graph_id = subcommand.unwrap().1.get_one::<String>("graph_id").unwrap();

        match subcommand.unwrap().1.subcommand() {
            Some(("assert_commits", _)) => {
                let result = self
                    .client
                    .broadcast_assert_commits(graph_id, &get_proof())
                    .await;
                if let Err(e) = result {
                    println!("Failed to broadcast transaction: {e}");
                }
            }
            Some((others, _)) => {
                let result = match others {
                    "deposit" => self.client.broadcast_peg_in_deposit(graph_id).await,
                    "refund" => self.client.broadcast_peg_in_refund(graph_id).await,
                    "confirm" => self.client.broadcast_peg_in_confirm(graph_id).await,
                    "peg_out" => {
                        let input = self
                            .get_funding_utxo_input(subcommand.unwrap().1.get_one::<String>("utxo"))
                            .await?;
                        let result = self.client.broadcast_peg_out(graph_id, input).await;
                        self.client.flush().await;
                        result
                    }
                    "peg_out_confirm" => self.client.broadcast_peg_out_confirm(graph_id).await,
                    "kick_off_1" => self.client.broadcast_kick_off_1(graph_id).await,
                    "kick_off_2" => self.client.broadcast_kick_off_2(graph_id).await,
                    "start_time" => self.client.broadcast_start_time(graph_id).await,
                    "assert_initial" => self.client.broadcast_assert_initial(graph_id).await,
                    "assert_commit_1_invalid" => {
                        self.client
                            .broadcast_assert_commit_1(graph_id, &invalidate_proof(&get_proof()))
                            .await
                    }
                    "assert_commit_2_invalid" => {
                        self.client
                            .broadcast_assert_commit_2(graph_id, &invalidate_proof(&get_proof()))
                            .await
                    }
                    "assert_final" => self.client.broadcast_assert_final(graph_id).await,
                    "take_1" => self.client.broadcast_take_1(graph_id).await,
                    "take_2" => self.client.broadcast_take_2(graph_id).await,
                    "disprove" => {
                        let address = subcommand.unwrap().1.get_one::<String>("address").unwrap();
                        let reward_address = Address::from_str(address).unwrap();
                        let reward_script = reward_address.assume_checked().script_pubkey(); // TODO: verify checked/unchecked address

                        self.client
                            .broadcast_disprove(graph_id, reward_script)
                            .await
                    }
                    &_ => unreachable!(),
                };