depolymerization

lib.rs (5885B)

---

 /*
   This file is part of TALER
   Copyright (C) 2022-2025, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 use std::str::FromStr;
 
 use bitcoin::{Address, Amount, Network, Txid, hashes::hex::FromHex};
 use rpc::{Category, Transaction};
 use rpc_utils::segwit_min_amount;
 use segwit::{decode_segwit_msg, encode_segwit_key};
 use taler_common::{api::EddsaPublicKey, config::parser::ConfigSource};
 
 use crate::{rpc::RpcApi, segwit::DecodeSegWitErr};
 
 pub mod api;
 pub mod cli;
 pub mod config;
 pub mod db;
 pub mod loops;
 pub mod payto;
 pub mod rpc;
 pub mod rpc_utils;
 pub mod segwit;
 pub mod setup;
 pub mod sql;
 pub mod taler_utils;
 
 pub const CONFIG_SOURCE: ConfigSource = ConfigSource::simple("depolymerizer-bitcoin");
 
 #[derive(Debug, thiserror::Error)]
 pub enum GetOpReturnErr {
     #[error("Missing opreturn")]
     MissingOpReturn,
     #[error(transparent)]
     RPC(#[from] rpc::Error),
 }
 
 /// An extended bitcoincore JSON-RPC api client who can send and retrieve metadata with their transaction
 #[allow(async_fn_in_trait)]
 pub trait RpcApiExtended: RpcApi {
     /// Send a transaction with a 32B key as metadata encoded using fake segwit addresses
     async fn send_segwit_key(
         &mut self,
         to: &Address,
         amount: Amount,
         metadata: &[u8; 32],
     ) -> rpc::Result<Txid> {
         let network = guess_network(to);
         let hrp = match network {
             Network::Bitcoin => bech32::hrp::BC,
             Network::Testnet | Network::Signet => bech32::hrp::TB,
             Network::Regtest => bech32::hrp::BCRT,
             _ => unimplemented!(),
         };
         let addresses = encode_segwit_key(hrp, metadata);
         let addresses = [
             Address::from_str(&addresses[0]).unwrap().assume_checked(),
             Address::from_str(&addresses[1]).unwrap().assume_checked(),
         ];
         let mut recipients = vec![(to, amount)];
         let min = segwit_min_amount();
         recipients.extend(addresses.iter().map(|addr| (addr, min)));
         self.send_many(recipients).await
     }
 
     /// Get detailed information about an in-wallet transaction and it's 32B metadata key encoded using fake segwit addresses
     async fn get_tx_segwit_key(
         &mut self,
         id: &Txid,
     ) -> Result<(Transaction, Result<EddsaPublicKey, DecodeSegWitErr>), rpc::Error> {
         let full = self.get_tx(id).await?;
 
         let addresses: Vec<String> = full
             .decoded
             .vout
             .iter()
             .filter_map(|it| {
                 it.script_pub_key
                     .address
                     .as_ref()
                     .map(|addr| addr.clone().assume_checked().to_string())
             })
             .collect();
 
         Ok((full, decode_segwit_msg(&addresses)))
     }
 
     /// Get detailed information about an in-wallet transaction and its op_return metadata
     async fn get_tx_op_return(
         &mut self,
         id: &Txid,
     ) -> Result<(Transaction, Vec<u8>), GetOpReturnErr> {
         let full = self.get_tx(id).await?;
 
         let op_return_out = full
             .decoded
             .vout
             .iter()
             .find(|it| it.script_pub_key.asm.starts_with("OP_RETURN"))
             .ok_or(GetOpReturnErr::MissingOpReturn)?;
 
         let hex = op_return_out.script_pub_key.asm.split_once(' ').unwrap().1;
         // Op return payload is always encoded in hexadecimal
         let metadata = Vec::from_hex(hex).unwrap();
 
         Ok((full, metadata))
     }
 
     /// Get the first sender address from a raw transaction
     async fn sender_address(&mut self, full: &Transaction) -> rpc::Result<Address> {
         let first = &full.decoded.vin[0];
         let tx = self.get_input_output(&first.txid.unwrap()).await?;
         Ok(tx
             .vout
             .into_iter()
             .find(|it| it.n == first.vout.unwrap())
             .unwrap()
             .script_pub_key
             .address
             .unwrap()
             .assume_checked())
     }
 
     /// Bounce a transaction bask to its sender
     ///
     /// There is no reliable way to bounce a transaction as you cannot know if the addresses
     /// used are shared or come from a third-party service. We only send back to the first input
     /// address as a best-effort gesture.
     async fn bounce(
         &mut self,
         id: &Txid,
         bounce_fee: &Amount,
         metadata: Option<&[u8]>,
     ) -> Result<Txid, rpc::Error> {
         let full = self.get_tx(id).await?;
         let detail = &full.details[0];
         assert!(detail.category == Category::Receive);
 
         let amount = detail.amount.to_unsigned().unwrap();
         let sender = self.sender_address(&full).await?;
         let bounce_amount = Amount::from_sat(amount.to_sat().saturating_sub(bounce_fee.to_sat()));
         // Send refund making recipient pay the transaction fees
         self.send(&sender, bounce_amount, metadata, true).await
     }
 }
 
 impl<T: RpcApi> RpcApiExtended for T {}
 
 pub fn guess_network(address: &Address) -> Network {
     let addr = address.as_unchecked();
     for network in [
         Network::Bitcoin,
         Network::Regtest,
         Network::Signet,
         Network::Regtest,
     ] {
         if addr.is_valid_for_network(network) {
             return network;
         }
     }
     unreachable!()
 }