aaaaaaaaaaa #2

Author: Yakuhito

src/cli/commands.rs

@@ -992,6 +992,10 @@ enum VerificationsCliAction {
         #[arg(long)]
         request_offer: Option<String>,
 
+        /// Address to send funds from verification request offer to
+        #[arg(long)]
+        request_offer_recipient: Option<String>,
+
         /// Signatures (comma-separated list)
         #[arg(long)]
         sigs: String,
@@ -1600,6 +1604,7 @@ pub async fn run_cli() {
                 asset_id,
                 comment,
                 request_offer,
+                request_offer_recipient,
                 sigs,
                 testnet11,
                 fee,
@@ -1609,6 +1614,7 @@ pub async fn run_cli() {
                     asset_id,
                     comment,
                     request_offer,
+                    request_offer_recipient,
                     sigs,
                     testnet11,
                     fee,

src/cli/verifications/broadcast_launch.rs

@@ -1,34 +1,42 @@
 use bech32::Variant;
 use chia::{
-    protocol::{Bytes, Bytes32, SpendBundle},
+    clvm_utils::ToTreeHash,
+    protocol::{Bytes, Bytes32, Coin, SpendBundle},
     traits::Streamable,
 };
+use chia_puzzle_types::{
+    cat::CatArgs,
+    offer::{NotarizedPayment, Payment},
+};
+use chia_puzzles::{CAT_PUZZLE_HASH, SETTLEMENT_PAYMENT_HASH};
 use chia_wallet_sdk::{
-    driver::{decompress_offer_bytes, DriverError, Launcher, OfferError},
-    types::Conditions,
+    driver::{decompress_offer_bytes, Launcher, Puzzle},
+    types::{announcement_id, Condition, Conditions},
+    utils::Address,
 };
 use clvm_traits::clvm_quote;
 use clvmr::{serde::node_from_bytes, NodePtr};
 
 use crate::{
     get_constants, get_latest_data_for_asset_id, hex_string_to_bytes32,
-    multisig_broadcast_thing_finish, multisig_broadcast_thing_start, CliError, MedievalVault,
-    Verification, VerificationInfo, VerificationLauncherKVList, VerifiedData,
+    multisig_broadcast_thing_finish, multisig_broadcast_thing_start, yes_no_prompt, CliError,
+    MedievalVault, Verification, VerificationAsserter, VerificationLauncherKVList, VerifiedData,
 };
 
 pub async fn verifications_broadcast_launch(
     launcher_id_str: String,
     asset_id_str: String,
     comment: String,
     request_offer: Option<String>,
+    request_offer_recipient: Option<String>,
     signatures_str: String,
     testnet11: bool,
     fee_str: String,
 ) -> Result<(), CliError> {
     let launcher_id = hex_string_to_bytes32(&launcher_id_str)?;
     let asset_id = hex_string_to_bytes32(&asset_id_str)?;
 
-    let (signature_from_signers, pubkeys, client, mut ctx, medieval_vault) =
+    let (mut signature_from_signers, pubkeys, client, mut ctx, medieval_vault) =
         multisig_broadcast_thing_start(signatures_str, launcher_id_str, testnet11).await?;
 
     println!(
@@ -109,11 +117,112 @@ pub async fn verifications_broadcast_launch(
         }
         let spend_bundle = SpendBundle::from_bytes(&spend_bundle_bytes).unwrap();
 
-        // todo: find payment and send it to recipient
-        // todo: find verification asserter
-        // todo: spend verification asserter
+        let verification_asserter = VerificationAsserter::from(
+            launcher_id,
+            verified_data.version,
+            verified_data.asset_id.tree_hash(),
+            verified_data.data_hash.tree_hash(),
+        );
+        let verification_asserter_puzzle_hash: Bytes32 = verification_asserter.tree_hash().into();
+
+        let mut payment_sent = false;
+        let mut verification_asserter_spent = false;
+        let mut conds = Conditions::new();
+        for coin_spend in spend_bundle.coin_spends.into_iter() {
+            let recipient_puzzle_hash =
+                Address::decode(&request_offer_recipient.ok_or(CliError::Custom(
+                    "Verification offer provided but recipient not specified".to_string(),
+                ))?)?
+                .puzzle_hash;
+
+            let puzzle_ptr = ctx.alloc(&coin_spend.puzzle_reveal)?;
+            let solution_ptr = ctx.alloc(&coin_spend.solution)?;
+            let output = ctx.run(puzzle_ptr, solution_ptr)?;
+            let output = ctx.extract::<Conditions>(output)?;
+
+            let puzzle = Puzzle::parse(&ctx, puzzle_ptr);
+            match puzzle {
+                Puzzle::Curried(puzzle) => {
+                    if puzzle.mod_hash == CAT_PUZZLE_HASH.into() {
+                        let payment_cat_asset_id =
+                            ctx.extract::<CatArgs<NodePtr>>(puzzle.args)?.asset_id;
+                        let offer_puzzle_hash: Bytes32 = CatArgs::curry_tree_hash(
+                            payment_cat_asset_id,
+                            SETTLEMENT_PAYMENT_HASH.into(),
+                        )
+                        .into();
+
+                        if let Some(cc) = output.iter().find_map(|c| match c {
+                            Condition::CreateCoin(cc) => {
+                                if cc.puzzle_hash == offer_puzzle_hash {
+                                    Some(cc)
+                                } else {
+                                    None
+                                }
+                            }
+                            _ => None,
+                        }) {
+                            yes_no_prompt(format!("{} CAT mojos (asset id: {}) will be transferred to the specified recipient. Continue?", cc.amount, hex::encode(payment_cat_asset_id)).as_str())?;
+                            let notarized_payment = NotarizedPayment {
+                                nonce: coin_spend.coin.coin_id(),
+                                payments: vec![Payment::with_memos(
+                                    recipient_puzzle_hash,
+                                    cc.amount,
+                                    vec![recipient_puzzle_hash.into()],
+                                )],
+                            };
+
+                            // todo: spend CAT
+
+                            payment_sent = true;
+                            let msg: Bytes32 = notarized_payment.tree_hash().into();
+                            conds = conds.assert_puzzle_announcement(announcement_id(
+                                offer_puzzle_hash,
+                                &msg,
+                            ));
+                        }
+                    }
+                }
+                Puzzle::Raw(_puzzle) => {
+                    if let Some(cc) = output.iter().find_map(|c| match c {
+                        Condition::CreateCoin(cc) => {
+                            if cc.puzzle_hash == verification_asserter_puzzle_hash {
+                                Some(cc)
+                            } else {
+                                None
+                            }
+                        }
+                        _ => None,
+                    }) {
+                        verification_asserter.spend(
+                            &mut ctx,
+                            Coin::new(coin_spend.coin.coin_id(), cc.puzzle_hash, cc.amount),
+                            verifier_proof,
+                            0,
+                            comment,
+                        );
+                        verification_asserter_spent = true;
+                    }
+                }
+            };
+
+            ctx.insert(coin_spend);
+        }
+
+        if !payment_sent {
+            return Err(CliError::Custom(
+                "Payment in offer could not be found".to_string(),
+            ));
+        }
+        if !verification_asserter_spent {
+            return Err(CliError::Custom(
+                "Verification asserter could not be found in offer - it is likely invalid"
+                    .to_string(),
+            ));
+        }
 
-        Some(Conditions::new()) // todo
+        signature_from_signers += &spend_bundle.aggregated_signature;
+        Some(conds)
     } else {
         None
     };