adtd relayer call take1 take2 disproved

Author: jackDev221

crates/client/src/client.rs

@@ -1,5 +1,7 @@
 use crate::chain::chain::Chain;
-use crate::chain::chain_adaptor::{GoatNetwork, OperatorData, PeginData, get_chain_adaptor};
+use crate::chain::chain_adaptor::{
+    BitcoinTx, GoatNetwork, OperatorData, PeginData, get_chain_adaptor,
+};
 use crate::chain::goat_adaptor::GoatInitConfig;
 use crate::esplora::get_esplora_url;
 use anyhow::format_err;
@@ -100,4 +102,74 @@ impl BitVM2Client {
     pub async fn get_operator_data(&self, graph_id: Uuid) -> anyhow::Result<OperatorData> {
         self.chain_service.adaptor.get_operator_data(graph_id).await
     }
+
+    pub async fn finish_withdraw_happy_path(
+        &self,
+        graph_id: &Uuid,
+        tx: &bitcoin::Transaction,
+    ) -> anyhow::Result<()> {
+        let raw_take1_tx = self.tx_reconstruct(tx);
+        let (_root, proof, _leaf, height, index) =
+            self.get_btc_tx_proof_info(&tx.compute_txid()).await?;
+        Ok(self
+            .chain_service
+            .adaptor
+            .finish_withdraw_happy_path(graph_id, &raw_take1_tx, height, &proof, index)
+            .await?)
+    }
+
+    pub async fn finish_withdraw_unhappy_path(
+        &self,
+        graph_id: &Uuid,
+        tx: &bitcoin::Transaction,
+    ) -> anyhow::Result<()> {
+        let raw_take2_tx = self.tx_reconstruct(tx);
+        let (_root, proof, _leaf, height, index) =
+            self.get_btc_tx_proof_info(&tx.compute_txid()).await?;
+        Ok(self
+            .chain_service
+            .adaptor
+            .finish_withdraw_unhappy_path(graph_id, &raw_take2_tx, height, &proof, index)
+            .await?)
+    }
+
+    pub async fn finish_withdraw_disproved(
+        &self,
+        graph_id: &Uuid,
+        tx: &bitcoin::Transaction,
+    ) -> anyhow::Result<()> {
+        let raw_disprove_tx = self.tx_reconstruct(tx);
+        let (_root, proof, _leaf, height, index) =
+            self.get_btc_tx_proof_info(&tx.compute_txid()).await?;
+        Ok(self
+            .chain_service
+            .adaptor
+            .finish_withdraw_disproved(graph_id, &raw_disprove_tx, height, &proof, index)
+            .await?)
+    }
+
+    pub async fn get_btc_tx_proof_info(
+        &self,
+        tx_id: &Txid,
+    ) -> anyhow::Result<([u8; 32], Vec<[u8; 32]>, [u8; 32], u64, u64)> {
+        let (root, proof_info) = self.get_bitc_merkle_proof(tx_id).await?;
+        let proof: Vec<[u8; 32]> = proof_info.merkle.iter().map(|v| v.to_byte_array()).collect();
+        let leaf = tx_id.to_byte_array();
+        Ok((
+            root.to_byte_array(),
+            proof,
+            leaf,
+            proof_info.block_height as u64,
+            proof_info.pos as u64,
+        ))
+    }
+
+    fn tx_reconstruct(&self, tx: &bitcoin::Transaction) -> BitcoinTx {
+        BitcoinTx {
+            version: tx.version.0 as u32,
+            lock_time: tx.lock_time.to_consensus_u32(),
+            input_vector: bitcoin::consensus::serialize(&tx.input),
+            output_vector: bitcoin::consensus::serialize(&tx.output),
+        }
+    }
 }

node/src/action.rs

@@ -12,6 +12,9 @@ use bitvm2_lib::types::{
 use bitvm2_lib::verifier::export_challenge_tx;
 use bitvm2_lib::{committee::*, operator::*, verifier::*};
 use client::client::BitVM2Client;
+use goat::transactions::disprove::DisproveTransaction;
+use goat::transactions::take_1::Take1Transaction;
+use goat::transactions::take_2::Take2Transaction;
 use goat::transactions::{assert::utils::COMMIT_TX_NUM, pre_signed::PreSignedTransaction};
 use libp2p::gossipsub::MessageId;
 use libp2p::{PeerId, Swarm, gossipsub};
@@ -1177,7 +1180,8 @@ pub async fn recv_and_dispatch(
             let graph = get_graph(&client, receive_data.instance_id, receive_data.graph_id).await?;
             let take1_txid = graph.take1.tx().compute_txid();
             if todo_funcs::tx_on_chain(&client, &take1_txid).await? {
-                // TODO: call L2: finishWithdrawHappyPath
+                finish_withdraw_happy_path(&client, &receive_data.graph_id, &graph.take1)
+                    .await?;
                 update_graph_status_or_ipfs_base(
                     &client,
                     receive_data.graph_id,
@@ -1191,7 +1195,8 @@ pub async fn recv_and_dispatch(
         (GOATMessageContent::Take2Sent(receive_data), Actor::Relayer) => {
             let graph = get_graph(&client, receive_data.instance_id, receive_data.graph_id).await?;
             if todo_funcs::tx_on_chain(&client, &graph.take2.tx().compute_txid()).await? {
-                // TODO: call L2: finishWithdrawUnhappyPath
+                finish_withdraw_unhappy_path(&client, &receive_data.graph_id, &graph.take2)
+                    .await?;
                 update_graph_status_or_ipfs_base(
                     &client,
                     receive_data.graph_id,
@@ -1211,7 +1216,8 @@ pub async fn recv_and_dispatch(
             )
             .await?
             {
-                // TODO: call L2: finishWithdrawDisproved
+                finish_withdraw_disproved(&client, &receive_data.graph_id, &graph.disprove)
+                    .await?;
                 update_graph_status_or_ipfs_base(
                     &client,
                     receive_data.graph_id,
@@ -1336,6 +1342,31 @@ where
     Ok(serde_json::from_str(txt.as_str())?)
 }
 
+/// l2 support
+pub async fn finish_withdraw_happy_path(
+    client: &BitVM2Client,
+    graph_id: &Uuid,
+    take1: &Take1Transaction,
+) -> Result<(), Box<dyn std::error::Error>> {
+    Ok(client.finish_withdraw_happy_path(graph_id, take1.tx()).await?)
+}
+pub async fn finish_withdraw_unhappy_path(
+    client: &BitVM2Client,
+    graph_id: &Uuid,
+    take2: &Take2Transaction,
+) -> Result<(), Box<dyn std::error::Error>> {
+    Ok(client.finish_withdraw_unhappy_path(graph_id, take2.tx()).await?)
+}
+
+pub async fn finish_withdraw_disproved(
+    client: &BitVM2Client,
+    graph_id: &Uuid,
+    disprove: &DisproveTransaction,
+) -> Result<(), Box<dyn std::error::Error>> {
+    Ok(client.finish_withdraw_disproved(graph_id, disprove.tx()).await?)
+}
+
+/// db support
 pub async fn store_committee_pub_nonces(
     client: &BitVM2Client,
     instance_id: Uuid,

node/src/rpc_service/bitvm2.rs

@@ -9,7 +9,7 @@ use std::str::FromStr;
 use store::{BridgeInStatus, GrapRpcQueryData, Graph, GraphStatus, Instance};
 use uuid::Uuid;
 
-pub const BTC_MAIN: &str = "main";
+pub const BTC_MAIN: &str = "bitcoin";
 pub const BTC_TEST_BLOCK_INTERVAL: u32 = 10;
 pub const BTC_MAIN_BLOCK_INTERVAL: u32 = 10;
 // the input to our `create_user` handler