Merge pull request #712 from xch-dev/clawback-finalize

Add support for finalizing clawbacks

Author: Rigidity

crates/sage-api/endpoints.json

@@ -58,6 +58,7 @@
   "mint_option": true,
   "transfer_options": true,
   "exercise_options": true,
+  "finalize_clawback": true,
   "sign_coin_spends": true,
   "view_coin_spends": true,
   "submit_transaction": true,

crates/sage-api/src/requests/transactions.rs

@@ -696,6 +696,29 @@ pub struct TransferOptions {
     pub auto_submit: bool,
 }
 
+/// Send CAT tokens to an address
+#[cfg_attr(
+    feature = "openapi",
+    crate::openapi_attr(
+        tag = "XCH Transactions",
+        description = "Finalize the clawback for a set of coins.",
+        response_type = "TransactionResponse"
+    )
+)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "tauri", derive(specta::Type))]
+#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+pub struct FinalizeClawback {
+    /// The coins to finalize the clawback for
+    pub coin_ids: Vec<String>,
+    /// Transaction fee
+    pub fee: Amount,
+    /// Whether to automatically submit the transaction
+    #[serde(default)]
+    #[cfg_attr(feature = "openapi", schema(default = false))]
+    pub auto_submit: bool,
+}
+
 /// Sign coin spends to create a transaction
 #[cfg_attr(
     feature = "openapi",
@@ -807,3 +830,4 @@ pub type TransferDidsResponse = TransactionResponse;
 pub type NormalizeDidsResponse = TransactionResponse;
 pub type TransferOptionsResponse = TransactionResponse;
 pub type ExerciseOptionsResponse = TransactionResponse;
+pub type FinalizeClawbackResponse = TransactionResponse;

crates/sage-database/src/tables/p2_puzzles.rs

@@ -25,7 +25,7 @@ pub enum P2Puzzle {
 
 #[derive(Debug, Clone, Copy)]
 pub struct Clawback {
-    pub public_key: PublicKey,
+    pub public_key: Option<PublicKey>,
     pub sender_puzzle_hash: Bytes32,
     pub receiver_puzzle_hash: Bytes32,
     pub seconds: u64,
@@ -490,10 +490,10 @@ async fn clawback(conn: impl SqliteExecutor<'_>, p2_puzzle_hash: Bytes32) -> Res
 
     let row = query!(
         "
-        SELECT key, sender_puzzle_hash, receiver_puzzle_hash, expiration_seconds
+        SELECT key AS 'key?', sender_puzzle_hash, receiver_puzzle_hash, expiration_seconds
         FROM p2_puzzles
         INNER JOIN clawbacks ON clawbacks.p2_puzzle_id = p2_puzzles.id
-        INNER JOIN public_keys ON public_keys.p2_puzzle_id IN (
+        LEFT JOIN public_keys ON public_keys.p2_puzzle_id IN (
             SELECT id FROM p2_puzzles
             WHERE (hash = sender_puzzle_hash AND unixepoch() < expiration_seconds)
             OR (hash = receiver_puzzle_hash AND unixepoch() >= expiration_seconds)

crates/sage-wallet/src/error.rs

@@ -117,6 +117,12 @@ pub enum WalletError {
     #[error("Unsupported underlying coin kind: {0:?}")]
     UnsupportedUnderlyingCoinKind(CoinKind),
 
+    #[error("Unsupported clawback coin kind: {0:?}")]
+    UnsupportedClawbackCoinKind(CoinKind),
+
+    #[error("Cannot find clawback info for coin with id {0}")]
+    MissingClawbackInfo(Bytes32),
+
     #[error("Try from int error: {0}")]
     TryFromInt(#[from] TryFromIntError),
 }

crates/sage-wallet/src/wallet.rs

@@ -309,7 +309,11 @@ impl Wallet {
                         P2Puzzle::PublicKey(public_key) => StandardLayer::new(*public_key)
                             .spend_with_conditions(ctx, spend.finish()),
                         P2Puzzle::Clawback(clawback) => {
-                            let custody = StandardLayer::new(clawback.public_key);
+                            let Some(public_key) = clawback.public_key else {
+                                return Err(DriverError::MissingKey);
+                            };
+
+                            let custody = StandardLayer::new(public_key);
                             let spend = custody.spend_with_conditions(ctx, spend.finish())?;
 
                             let clawback = ClawbackV2::new(

crates/sage-wallet/src/wallet/xch.rs

@@ -2,7 +2,11 @@ use chia::{
     clvm_utils::ToTreeHash,
     protocol::{Bytes, Bytes32, CoinSpend},
 };
-use chia_wallet_sdk::driver::{Action, ClawbackV2, Id, SpendContext};
+use chia_wallet_sdk::{
+    driver::{Action, Cat, CatSpend, ClawbackV2, Id, SpendContext},
+    prelude::AssertConcurrentSpend,
+};
+use sage_database::{CoinKind, P2Puzzle};
 
 use crate::{
     wallet::memos::{calculate_memos, Hint},
@@ -53,6 +57,86 @@ impl Wallet {
 
         Ok(ctx.take())
     }
+
+    pub async fn finalize_clawback(
+        &self,
+        coin_ids: Vec<Bytes32>,
+        fee: u64,
+    ) -> Result<Vec<CoinSpend>, WalletError> {
+        let mut ctx = SpendContext::new();
+
+        for &coin_id in &coin_ids {
+            let Some(coin_kind) = self.db.coin_kind(coin_id).await? else {
+                return Err(WalletError::MissingCoin(coin_id));
+            };
+
+            match coin_kind {
+                CoinKind::Xch => {
+                    let Some(coin) = self.db.xch_coin(coin_id).await? else {
+                        return Err(WalletError::MissingXchCoin(coin_id));
+                    };
+
+                    let P2Puzzle::Clawback(clawback) = self.db.p2_puzzle(coin.puzzle_hash).await?
+                    else {
+                        return Err(WalletError::MissingClawbackInfo(coin_id));
+                    };
+
+                    let clawback = ClawbackV2::new(
+                        clawback.sender_puzzle_hash,
+                        clawback.receiver_puzzle_hash,
+                        clawback.seconds,
+                        coin.amount,
+                        false,
+                    );
+
+                    clawback.push_through_coin_spend(&mut ctx, coin)?;
+                }
+                CoinKind::Cat => {
+                    let Some(cat) = self.db.cat_coin(coin_id).await? else {
+                        return Err(WalletError::MissingCatCoin(coin_id));
+                    };
+
+                    let P2Puzzle::Clawback(clawback) =
+                        self.db.p2_puzzle(cat.info.p2_puzzle_hash).await?
+                    else {
+                        return Err(WalletError::MissingClawbackInfo(coin_id));
+                    };
+
+                    let clawback = ClawbackV2::new(
+                        clawback.sender_puzzle_hash,
+                        clawback.receiver_puzzle_hash,
+                        clawback.seconds,
+                        cat.coin.amount,
+                        true,
+                    );
+
+                    let spend = clawback.push_through_spend(&mut ctx)?;
+                    Cat::spend_all(&mut ctx, &[CatSpend::new(cat, spend)])?;
+                }
+                _ => {
+                    return Err(WalletError::UnsupportedClawbackCoinKind(coin_kind));
+                }
+            }
+        }
+
+        if fee > 0 {
+            let actions = [Action::fee(fee)];
+
+            let mut spends = self.prepare_spends(&mut ctx, vec![], &actions).await?;
+
+            for &coin_id in &coin_ids {
+                spends
+                    .conditions
+                    .required
+                    .push(AssertConcurrentSpend::new(coin_id));
+            }
+
+            let deltas = spends.apply(&mut ctx, &actions)?;
+            self.complete_spends(&mut ctx, &deltas, spends).await?;
+        }
+
+        Ok(ctx.take())
+    }
 }
 
 #[cfg(test)]

crates/sage/src/endpoints/transactions.rs

@@ -13,10 +13,11 @@ use itertools::Itertools;
 use sage_api::{
     AddNftUri, AssignNftsToDid, AutoCombineCat, AutoCombineCatResponse, AutoCombineXch,
     AutoCombineXchResponse, BulkMintNfts, BulkMintNftsResponse, BulkSendCat, BulkSendXch, Combine,
-    CreateDid, ExerciseOptions, IssueCat, MintOption, MintOptionResponse, MultiSend, NftUriKind,
-    NormalizeDids, OptionAsset, SendCat, SendXch, SignCoinSpends, SignCoinSpendsResponse, Split,
-    SubmitTransaction, SubmitTransactionResponse, TransactionResponse, TransferDids, TransferNfts,
-    TransferOptions, ViewCoinSpends, ViewCoinSpendsResponse,
+    CreateDid, ExerciseOptions, FinalizeClawback, IssueCat, MintOption, MintOptionResponse,
+    MultiSend, NftUriKind, NormalizeDids, OptionAsset, SendCat, SendXch, SignCoinSpends,
+    SignCoinSpendsResponse, Split, SubmitTransaction, SubmitTransactionResponse,
+    TransactionResponse, TransferDids, TransferNfts, TransferOptions, ViewCoinSpends,
+    ViewCoinSpendsResponse,
 };
 use sage_assets::fetch_uris_without_hash;
 use sage_database::{Asset, AssetKind};
@@ -552,6 +553,15 @@ impl Sage {
         self.transact(coin_spends, req.auto_submit).await
     }
 
+    pub async fn finalize_clawback(&self, req: FinalizeClawback) -> Result<TransactionResponse> {
+        let wallet = self.wallet()?;
+        let coin_ids = parse_coin_ids(req.coin_ids)?;
+        let fee = parse_amount(req.fee)?;
+
+        let coin_spends = wallet.finalize_clawback(coin_ids, fee).await?;
+        self.transact(coin_spends, req.auto_submit).await
+    }
+
     pub async fn sign_coin_spends(&self, req: SignCoinSpends) -> Result<SignCoinSpendsResponse> {
         let coin_spends = req
             .coin_spends

migrations/0005_clawback_coin_fix.sql

@@ -0,0 +1,8 @@
+DROP VIEW clawback_coins;
+
+CREATE VIEW clawback_coins AS
+SELECT *
+FROM wallet_coins
+WHERE 1=1
+  AND spent_height IS NULL
+  AND clawback_expiration_seconds IS NOT NULL;

src-tauri/src/lib.rs

@@ -55,6 +55,7 @@ pub fn run() {
             commands::exercise_options,
             commands::add_nft_uri,
             commands::assign_nfts_to_did,
+            commands::finalize_clawback,
             commands::sign_coin_spends,
             commands::view_coin_spends,
             commands::submit_transaction,

src/bindings.ts

@@ -101,6 +101,9 @@ async addNftUri(req: AddNftUri) : Promise<TransactionResponse> {
 async assignNftsToDid(req: AssignNftsToDid) : Promise<TransactionResponse> {
     return await TAURI_INVOKE("assign_nfts_to_did", { req });
 },
+async finalizeClawback(req: FinalizeClawback) : Promise<TransactionResponse> {
+    return await TAURI_INVOKE("finalize_clawback", { req });
+},
 async signCoinSpends(req: SignCoinSpends) : Promise<SignCoinSpendsResponse> {
     return await TAURI_INVOKE("sign_coin_spends", { req });
 },
@@ -817,6 +820,22 @@ export type FilterUnlockedCoinsResponse = {
  * List of unlocked coin IDs
  */
 coin_ids: string[] }
+/**
+ * Send CAT tokens to an address
+ */
+export type FinalizeClawback = { 
+/**
+ * The coins to finalize the clawback for
+ */
+coin_ids: string[]; 
+/**
+ * Transaction fee
+ */
+fee: Amount; 
+/**
+ * Whether to automatically submit the transaction
+ */
+auto_submit?: boolean }
 /**
  * Generate a new mnemonic phrase for wallet creation
  */