WIP options

Cargo.toml

@@ -73,9 +73,9 @@ specta-typescript = "0.0.7"
 tauri-specta = "2.0.0-rc.20"
 
 # Chia
-chia = { git = "https://github.com/Chia-Network/chia_rs", rev = "cb4f521fe32675a0238453a7c850083405f2952a", version = "0.16.0" }
+chia = "0.17.0"
 clvmr = "0.10.0"
-chia-wallet-sdk = { features = ["rustls"], git = "https://github.com/xch-dev/chia-wallet-sdk", rev = "1a2d2320050263f7f36cbf33a1424e6185d906f5" }
+chia-wallet-sdk = { features = ["rustls", "offers"], path = "../wallet-sdk" }
 bip39 = "2.0.0"
 bech32 = "0.9.1"
 

crates/sage-api/src/requests.rs

@@ -2,13 +2,15 @@ mod actions;
 mod data;
 mod keys;
 mod offers;
+mod options;
 mod settings;
 mod transactions;
 
 pub use actions::*;
 pub use data::*;
 pub use keys::*;
 pub use offers::*;
+pub use options::*;
 pub use settings::*;
 pub use transactions::*;
 

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

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+use crate::{Amount, CoinSpendJson, TransactionSummary};
+
+use super::Assets;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MintOption {
+    pub requested_assets: Assets,
+    pub offered_assets: Assets,
+    pub fee: Amount,
+    pub expires_at_second: u64,
+    pub did_id: String,
+    #[serde(default)]
+    pub auto_submit: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type)]
+pub struct MintOptionResponse {
+    pub summary: TransactionSummary,
+    pub coin_spends: Vec<CoinSpendJson>,
+}

crates/sage-wallet/src/child_kind.rs

@@ -3,7 +3,9 @@ use chia::{
     protocol::{Bytes32, Coin, Program},
     puzzles::{nft::NftMetadata, singleton::SINGLETON_LAUNCHER_PUZZLE_HASH, LineageProof, Proof},
 };
-use chia_wallet_sdk::{run_puzzle, Cat, Condition, Did, DidInfo, HashedPtr, Nft, NftInfo, Puzzle};
+use chia_wallet_sdk::{
+    run_puzzle, Cat, Condition, Did, DidInfo, HashedPtr, Memos, Nft, NftInfo, Puzzle,
+};
 use clvmr::{Allocator, NodePtr};
 use tracing::{debug_span, warn};
 
@@ -77,23 +79,22 @@ impl ChildKind {
             return Ok(Self::Launcher);
         }
 
-        let Some(mut create_coin) = conditions
+        let Some(create_coin) = conditions
             .into_iter()
             .filter_map(Condition::into_create_coin)
-            .find(|cond| {
-                cond.puzzle_hash == coin.puzzle_hash
-                    && cond.amount == coin.amount
-                    && !cond.memos.is_empty()
-                    && cond.memos[0].len() == 32
-            })
+            .find(|cond| cond.puzzle_hash == coin.puzzle_hash && cond.amount == coin.amount)
         else {
             return Ok(Self::Unknown { hint: None });
         };
 
-        let hint = Bytes32::try_from(create_coin.memos.remove(0).into_inner())
-            .expect("the hint is always 32 bytes, as checked above");
+        let hint = if let Some(memos) = create_coin.memos {
+            let memos = Memos::<(Bytes32, NodePtr)>::from_clvm(allocator, memos.value).ok();
+            memos.map(|memos| memos.value.0)
+        } else {
+            None
+        };
 
-        let unknown = Self::Unknown { hint: Some(hint) };
+        let unknown = Self::Unknown { hint };
 
         match Cat::parse_children(allocator, parent_coin, parent_puzzle, parent_solution) {
             // If there was an error parsing the CAT, we can exit early.

crates/sage-wallet/src/wallet.rs

@@ -10,13 +10,15 @@ mod did_assign;
 mod dids;
 mod nfts;
 mod offer;
+mod option;
 mod p2_coin_management;
 mod p2_send;
 mod p2_spends;
 mod signing;
 
 pub use nfts::WalletNftMint;
 pub use offer::*;
+pub use option::*;
 
 #[derive(Debug)]
 pub struct Wallet {

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

@@ -31,32 +31,35 @@ impl Wallet {
         }
 
         if fee_change > 0 {
-            fee_conditions = fee_conditions.create_coin(p2_puzzle_hash, fee_change, Vec::new());
+            fee_conditions = fee_conditions.create_coin(p2_puzzle_hash, fee_change, None);
         }
 
         let mut ctx = SpendContext::new();
 
         self.spend_p2_coins(&mut ctx, fee_coins, fee_conditions)
             .await?;
 
-        self.spend_cat_coins(
-            &mut ctx,
-            cats.into_iter().enumerate().map(|(i, cat)| {
-                if i == 0 {
-                    (
-                        cat,
-                        Conditions::new().create_coin(
-                            p2_puzzle_hash,
-                            cat_total.try_into().expect("output amount overflow"),
-                            vec![p2_puzzle_hash.into()],
-                        ),
-                    )
-                } else {
-                    (cat, Conditions::new())
-                }
-            }),
-        )
-        .await?;
+        let mut cat_spends = Vec::new();
+
+        let hint = ctx.hint(p2_puzzle_hash)?;
+
+        for (i, cat) in cats.into_iter().enumerate() {
+            cat_spends.push(if i == 0 {
+                (
+                    cat,
+                    Conditions::new().create_coin(
+                        p2_puzzle_hash,
+                        cat_total.try_into().expect("output amount overflow"),
+                        Some(hint),
+                    ),
+                )
+            } else {
+                (cat, Conditions::new())
+            });
+        }
+
+        self.spend_cat_coins(&mut ctx, cat_spends.into_iter())
+            .await?;
 
         Ok(ctx.take())
     }
@@ -104,39 +107,40 @@ impl Wallet {
         }
 
         if fee_change > 0 {
-            fee_conditions = fee_conditions.create_coin(derivations[0], fee_change, Vec::new());
+            fee_conditions = fee_conditions.create_coin(derivations[0], fee_change, None);
         }
 
         self.spend_p2_coins(&mut ctx, fee_coins, fee_conditions)
             .await?;
 
-        self.spend_cat_coins(
-            &mut ctx,
-            cats.into_iter().map(|cat| {
-                let mut conditions = Conditions::new();
+        let mut cat_spends = Vec::new();
+
+        for cat in cats {
+            let mut conditions = Conditions::new();
 
-                for &derivation in &derivations {
-                    if remaining_count == 0 {
-                        break;
-                    }
+            for &derivation in &derivations {
+                if remaining_count == 0 {
+                    break;
+                }
 
-                    let amount: u64 = (max_individual_amount as u128)
-                        .min(remaining_amount)
-                        .try_into()
-                        .expect("output amount overflow");
+                let amount: u64 = (max_individual_amount as u128)
+                    .min(remaining_amount)
+                    .try_into()
+                    .expect("output amount overflow");
 
-                    remaining_amount -= amount as u128;
+                remaining_amount -= amount as u128;
 
-                    conditions =
-                        conditions.create_coin(derivation, amount, vec![derivation.into()]);
+                let hint = ctx.hint(derivation)?;
+                conditions = conditions.create_coin(derivation, amount, Some(hint));
 
-                    remaining_count -= 1;
-                }
+                remaining_count -= 1;
+            }
 
-                (cat, conditions)
-            }),
-        )
-        .await?;
+            cat_spends.push((cat, conditions));
+        }
+
+        self.spend_cat_coins(&mut ctx, cat_spends.into_iter())
+            .await?;
 
         Ok(ctx.take())
     }

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

@@ -31,11 +31,9 @@ impl Wallet {
 
         let mut ctx = SpendContext::new();
 
-        let eve_conditions = Conditions::new().create_coin(
-            p2_puzzle_hash,
-            amount,
-            vec![p2_puzzle_hash.to_vec().into()],
-        );
+        let hint = ctx.hint(p2_puzzle_hash)?;
+
+        let eve_conditions = Conditions::new().create_coin(p2_puzzle_hash, amount, Some(hint));
 
         let (mut conditions, eve) = match multi_issuance_key {
             Some(pk) => {
@@ -49,7 +47,7 @@ impl Wallet {
         }
 
         if change > 0 {
-            conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+            conditions = conditions.create_coin(p2_puzzle_hash, change, None);
         }
 
         self.spend_p2_coins(&mut ctx, coins, conditions).await?;
@@ -95,7 +93,7 @@ impl Wallet {
             conditions = conditions.reserve_fee(fee);
 
             if fee_change > 0 {
-                conditions = conditions.create_coin(change_puzzle_hash, fee_change, Vec::new());
+                conditions = conditions.create_coin(change_puzzle_hash, fee_change, None);
             }
         }
 
@@ -106,25 +104,22 @@ impl Wallet {
                 .await?;
         }
 
+        let hint = ctx.hint(puzzle_hash)?;
+        let change_hint = ctx.hint(change_puzzle_hash)?;
+
         self.spend_cat_coins(
             &mut ctx,
             cats.into_iter().enumerate().map(|(i, cat)| {
                 if i != 0 {
                     return (cat, Conditions::new());
                 }
 
-                let mut conditions = mem::take(&mut conditions).create_coin(
-                    puzzle_hash,
-                    amount,
-                    vec![puzzle_hash.into()],
-                );
+                let mut conditions =
+                    mem::take(&mut conditions).create_coin(puzzle_hash, amount, Some(hint));
 
                 if cat_change > 0 {
-                    conditions = conditions.create_coin(
-                        change_puzzle_hash,
-                        cat_change,
-                        vec![change_puzzle_hash.into()],
-                    );
+                    conditions =
+                        conditions.create_coin(change_puzzle_hash, cat_change, Some(change_hint));
                 }
 
                 (cat, conditions)

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

@@ -113,7 +113,7 @@ impl Wallet {
                 .reserve_fee(fee);
 
             if change > 0 {
-                conditions = conditions.create_coin(change_puzzle_hash, change, Vec::new());
+                conditions = conditions.create_coin(change_puzzle_hash, change, None);
             }
 
             if let Some(did_coin_id) = did_coin_id {

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

@@ -34,7 +34,7 @@ impl Wallet {
         }
 
         if change > 0 {
-            conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+            conditions = conditions.create_coin(p2_puzzle_hash, change, None);
         }
 
         self.spend_p2_coins(&mut ctx, coins, conditions).await?;
@@ -112,7 +112,7 @@ impl Wallet {
                 .reserve_fee(fee);
 
             if change > 0 {
-                conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+                conditions = conditions.create_coin(p2_puzzle_hash, change, None);
             }
 
             self.spend_p2_coins(&mut ctx, coins, conditions).await?;

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

@@ -79,7 +79,7 @@ impl Wallet {
         }
 
         if change > 0 {
-            conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+            conditions = conditions.create_coin(p2_puzzle_hash, change, None);
         }
 
         self.spend_p2_coins(&mut ctx, coins, conditions).await?;
@@ -159,7 +159,7 @@ impl Wallet {
                 .reserve_fee(fee);
 
             if change > 0 {
-                conditions = conditions.create_coin(change_puzzle_hash, change, Vec::new());
+                conditions = conditions.create_coin(change_puzzle_hash, change, None);
             }
 
             self.spend_p2_coins(&mut ctx, coins, conditions).await?;
@@ -216,7 +216,7 @@ impl Wallet {
                 .reserve_fee(fee);
 
             if change > 0 {
-                conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+                conditions = conditions.create_coin(p2_puzzle_hash, change, None);
             }
 
             self.spend_p2_coins(&mut ctx, coins, conditions).await?;

crates/sage-wallet/src/wallet/offer/lock_assets.rs

@@ -3,8 +3,7 @@ use std::{collections::HashMap, mem};
 use chia::{
     protocol::{Bytes32, Coin},
     puzzles::offer::{
-        Memos, NotarizedPayment, Payment, SettlementPaymentsSolution,
-        SETTLEMENT_PAYMENTS_PUZZLE_HASH,
+        NotarizedPayment, Payment, SettlementPaymentsSolution, SETTLEMENT_PAYMENTS_PUZZLE_HASH,
     },
 };
 use chia_wallet_sdk::{
@@ -79,7 +78,7 @@ impl Wallet {
                 conditions = conditions.create_coin(
                     SETTLEMENT_PAYMENTS_PUZZLE_HASH.into(),
                     amounts.xch,
-                    Vec::new(),
+                    None,
                 );
 
                 locked.xch.push(Coin::new(
@@ -96,7 +95,7 @@ impl Wallet {
                 conditions = conditions.create_coin(
                     SETTLEMENT_PAYMENTS_PUZZLE_HASH.into(),
                     royalty_amount,
-                    Vec::new(),
+                    None,
                 );
 
                 let royalty_coin = Coin::new(
@@ -117,7 +116,7 @@ impl Wallet {
                                 payments: vec![Payment::with_memos(
                                     royalty.p2_puzzle_hash,
                                     royalty.amount,
-                                    Memos(vec![royalty.p2_puzzle_hash.into()]),
+                                    vec![royalty.p2_puzzle_hash.into()],
                                 )],
                             })
                             .collect(),
@@ -131,7 +130,7 @@ impl Wallet {
             let change = total_amount - amounts.xch - fee - royalties.xch_amount();
 
             if change > 0 {
-                conditions = conditions.create_coin(change_puzzle_hash, change, Vec::new());
+                conditions = conditions.create_coin(change_puzzle_hash, change, None);
             }
 
             if fee > 0 {
@@ -151,13 +150,15 @@ impl Wallet {
             let total_amount = cat_coins.iter().map(|cat| cat.coin.amount).sum::<u64>();
             let change = total_amount - amount - royalties.cat_amount(asset_id);
 
+            let settlement_hint = ctx.hint(SETTLEMENT_PAYMENTS_PUZZLE_HASH.into())?;
+
             let mut conditions = primary_conditions
                 .remove(&primary_cat.coin.coin_id())
                 .unwrap_or_default()
                 .create_coin(
                     SETTLEMENT_PAYMENTS_PUZZLE_HASH.into(),
                     amount,
-                    vec![Bytes32::from(SETTLEMENT_PAYMENTS_PUZZLE_HASH).into()],
+                    Some(settlement_hint),
                 );
 
             locked
@@ -167,11 +168,9 @@ impl Wallet {
                 .push(primary_cat.wrapped_child(SETTLEMENT_PAYMENTS_PUZZLE_HASH.into(), amount));
 
             if change > 0 {
-                conditions = conditions.create_coin(
-                    change_puzzle_hash,
-                    change,
-                    vec![change_puzzle_hash.into()],
-                );
+                let change_hint = ctx.hint(change_puzzle_hash)?;
+
+                conditions = conditions.create_coin(change_puzzle_hash, change, Some(change_hint));
             }
 
             // Handle royalties.
@@ -181,7 +180,7 @@ impl Wallet {
                 conditions = conditions.create_coin(
                     SETTLEMENT_PAYMENTS_PUZZLE_HASH.into(),
                     royalty_amount,
-                    vec![Bytes32::from(SETTLEMENT_PAYMENTS_PUZZLE_HASH).into()],
+                    Some(settlement_hint),
                 );
 
                 let royalty_cat = primary_cat
@@ -197,7 +196,7 @@ impl Wallet {
                                 payments: vec![Payment::with_memos(
                                     royalty.p2_puzzle_hash,
                                     royalty.amount,
-                                    Memos(vec![royalty.p2_puzzle_hash.into()]),
+                                    vec![royalty.p2_puzzle_hash.into()],
                                 )],
                             })
                             .collect(),

crates/sage-wallet/src/wallet/offer/make_offer.rs

@@ -1,9 +1,8 @@
 use chia::{
-    clvm_utils::CurriedProgram,
     protocol::{Bytes32, CoinSpend, Program},
     puzzles::{
         cat::CatArgs,
-        offer::{Memos, Payment, SETTLEMENT_PAYMENTS_PUZZLE_HASH},
+        offer::{Payment, SETTLEMENT_PAYMENTS_PUZZLE_HASH},
     },
 };
 use chia_wallet_sdk::{Conditions, Layer, NftInfo, OfferBuilder, Partial, SpendContext};
@@ -87,7 +86,6 @@ impl Wallet {
         let mut builder = OfferBuilder::new(maker_coins.nonce());
         let mut ctx = SpendContext::new();
         let settlement = ctx.settlement_payments_puzzle()?;
-        let cat = ctx.cat_puzzle()?;
 
         // Add requested XCH payments.
         if taker.xch > 0 {
@@ -97,23 +95,21 @@ impl Wallet {
                 vec![Payment::with_memos(
                     p2_puzzle_hash,
                     taker.xch,
-                    Memos(vec![p2_puzzle_hash.into()]),
+                    vec![p2_puzzle_hash.into()],
                 )],
             )?;
         }
 
         // Add requested CAT payments.
         for (&asset_id, &amount) in &taker.cats {
+            let cat_puzzle = ctx.curry(CatArgs::new(asset_id, settlement))?;
             builder = builder.request(
                 &mut ctx,
-                &CurriedProgram {
-                    program: cat,
-                    args: CatArgs::new(asset_id, settlement),
-                },
+                &cat_puzzle,
                 vec![Payment::with_memos(
                     p2_puzzle_hash,
                     amount,
-                    Memos(vec![p2_puzzle_hash.into()]),
+                    vec![p2_puzzle_hash.into()],
                 )],
             )?;
         }
@@ -138,7 +134,7 @@ impl Wallet {
                 vec![Payment::with_memos(
                     p2_puzzle_hash,
                     1,
-                    Memos(vec![p2_puzzle_hash.into()]),
+                    vec![p2_puzzle_hash.into()],
                 )],
             )?;
         }

crates/sage-wallet/src/wallet/offer/royalties.rs

@@ -2,7 +2,7 @@ use chia::{
     protocol::Bytes32,
     puzzles::{
         cat::CatArgs,
-        offer::{Memos, NotarizedPayment, Payment, SETTLEMENT_PAYMENTS_PUZZLE_HASH},
+        offer::{NotarizedPayment, Payment, SETTLEMENT_PAYMENTS_PUZZLE_HASH},
     },
 };
 use chia_wallet_sdk::{
@@ -82,7 +82,7 @@ impl RoyaltyPayment {
             payments: vec![Payment::with_memos(
                 self.p2_puzzle_hash,
                 self.amount,
-                Memos(vec![self.p2_puzzle_hash.into()]),
+                vec![self.p2_puzzle_hash.into()],
             )],
         }
     }

crates/sage-wallet/src/wallet/offer/unlock_assets.rs

@@ -2,7 +2,7 @@ use std::mem;
 
 use chia::{
     protocol::Bytes32,
-    puzzles::offer::{Memos, NotarizedPayment, Payment, SettlementPaymentsSolution},
+    puzzles::offer::{NotarizedPayment, Payment, SettlementPaymentsSolution},
 };
 use chia_wallet_sdk::{
     payment_assertion, AssertPuzzleAnnouncement, Cat, CatSpend, Layer, SettlementLayer,
@@ -27,7 +27,7 @@ pub fn unlock_assets(
             payments: vec![Payment::with_memos(
                 p2_puzzle_hash,
                 coin.amount,
-                Memos(vec![p2_puzzle_hash.into()]),
+                vec![p2_puzzle_hash.into()],
             )],
         };
 
@@ -51,7 +51,7 @@ pub fn unlock_assets(
                 payments: vec![Payment::with_memos(
                     p2_puzzle_hash,
                     cat.coin.amount,
-                    Memos(vec![p2_puzzle_hash.into()]),
+                    vec![p2_puzzle_hash.into()],
                 )],
             };
 
@@ -74,7 +74,7 @@ pub fn unlock_assets(
             payments: vec![Payment::with_memos(
                 p2_puzzle_hash,
                 nft.coin.amount,
-                Memos(vec![p2_puzzle_hash.into()]),
+                vec![p2_puzzle_hash.into()],
             )],
         };
 

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

@@ -0,0 +1,3 @@
+mod mint_option;
+
+pub use mint_option::*;

crates/sage-wallet/src/wallet/option/mint_option.rs

@@ -0,0 +1,231 @@
+use std::{collections::HashMap, mem};
+
+use chia::{
+    protocol::{Bytes32, CoinSpend},
+    puzzles::nft::{NftMetadata, NFT_METADATA_UPDATER_PUZZLE_HASH},
+};
+use chia_wallet_sdk::{
+    Conditions, DidOwner, HashedPtr, Launcher, Mod, NftMint, OptionContract, SpendContext,
+    StandardLayer,
+};
+use indexmap::IndexMap;
+
+use crate::{
+    calculate_royalties, MakerSide, NftRoyaltyInfo, OfferAmounts, TakerSide, Wallet, WalletError,
+};
+
+#[derive(Debug, Clone)]
+pub struct Option {
+    pub did_id: Bytes32,
+    pub maker: MakerSide,
+    pub taker: TakerSide,
+    pub nft_metadata: NftMetadata,
+    pub expiration_seconds: u64,
+}
+
+impl Wallet {
+    pub async fn mint_option(
+        &self,
+        Option {
+            did_id,
+            maker,
+            taker,
+            nft_metadata,
+            expiration_seconds,
+        }: Option,
+        hardened: bool,
+        reuse: bool,
+    ) -> Result<Vec<CoinSpend>, WalletError> {
+        let ctx = &mut SpendContext::new();
+
+        let Some(did) = self.db.spendable_did(did_id).await? else {
+            return Err(WalletError::MissingDid(did_id));
+        };
+
+        let p2_puzzle_hash = self.p2_puzzle_hash(hardened, reuse).await?;
+
+        let did_metadata_ptr = ctx.alloc(&did.info.metadata)?;
+        let did = did.with_metadata(HashedPtr::from_ptr(&ctx.allocator, did_metadata_ptr));
+
+        let synthetic_key = self.db.synthetic_key(did.info.p2_puzzle_hash).await?;
+        let did_p2 = StandardLayer::new(synthetic_key);
+
+        let nft_mint = NftMint {
+            metadata: nft_metadata,
+            metadata_updater_puzzle_hash: NFT_METADATA_UPDATER_PUZZLE_HASH.into(),
+            royalty_puzzle_hash: p2_puzzle_hash,
+            royalty_ten_thousandths: 0,
+            p2_puzzle_hash,
+            owner: Some(DidOwner::from_did_info(&did.info)),
+        };
+
+        let (mint_nft, nft) = Launcher::new(did.coin.coin_id(), 0)
+            .with_singleton_amount(1)
+            .mint_nft(ctx, nft_mint)?;
+        let _new_did = did.update(ctx, &did_p2, mint_nft)?;
+
+        // TODO: SPLIT THIS APART, BUT HERE BEGINS THE OFFER CODE
+        let maker_amounts = OfferAmounts {
+            xch: maker.xch,
+            cats: maker.cats.clone(),
+        };
+
+        let maker_royalties = calculate_royalties(
+            &maker_amounts,
+            &taker
+                .nfts
+                .iter()
+                .map(|(nft_id, requested_nft)| NftRoyaltyInfo {
+                    launcher_id: *nft_id,
+                    royalty_puzzle_hash: requested_nft.royalty_puzzle_hash,
+                    royalty_ten_thousandths: requested_nft.royalty_ten_thousandths,
+                })
+                .collect::<Vec<_>>(),
+        )?;
+
+        let total_amounts = maker_amounts.clone()
+            + maker_royalties.amounts()
+            + OfferAmounts {
+                xch: maker.fee + 1,
+                cats: IndexMap::new(),
+            };
+
+        let coins = self
+            .fetch_offer_coins(&total_amounts, maker.nfts.clone())
+            .await?;
+
+        let option_contract = OptionContract {
+            nft_info: nft.info,
+            p2_puzzle_hash,
+            expiration_seconds,
+        };
+
+        let assertions = Conditions::<HashedPtr>::default();
+
+        let mut extra_conditions = Conditions::new();
+
+        let primary_coins = coins.primary_coin_ids();
+
+        // Calculate conditions for each primary coin.
+        let mut primary_conditions = HashMap::new();
+
+        if primary_coins.len() == 1 {
+            primary_conditions.insert(primary_coins[0], extra_conditions);
+        } else {
+            for (i, &coin_id) in primary_coins.iter().enumerate() {
+                let relation = if i == 0 {
+                    *primary_coins.last().expect("empty primary coins")
+                } else {
+                    primary_coins[i - 1]
+                };
+
+                primary_conditions.insert(
+                    coin_id,
+                    mem::take(&mut extra_conditions).assert_concurrent_spend(relation),
+                );
+            }
+        }
+
+        // TODO: Keep track of the coins that are locked?
+
+        // Spend the XCH.
+        if let Some(primary_xch_coin) = coins.xch.first().copied() {
+            let offered_amount = maker_amounts.xch + maker_royalties.xch_amount();
+
+            let mut conditions = primary_conditions
+                .remove(&primary_xch_coin.coin_id())
+                .unwrap_or_default();
+
+            if offered_amount > 0 {
+                let p2_option_puzzle = option_contract.p2_option_puzzle(
+                    ctx,
+                    offered_amount,
+                    assertions.clone(),
+                    false,
+                )?;
+
+                conditions = conditions.create_coin(
+                    p2_option_puzzle.curry_tree_hash().into(),
+                    offered_amount,
+                    None,
+                );
+            }
+
+            let total_amount = coins.xch.iter().map(|coin| coin.amount).sum::<u64>();
+            let change = total_amount - offered_amount - maker.fee;
+
+            if change > 0 {
+                conditions = conditions.create_coin(p2_puzzle_hash, change, None);
+            }
+
+            if maker.fee > 0 {
+                conditions = conditions.reserve_fee(maker.fee);
+            }
+
+            self.spend_p2_coins(ctx, coins.xch, conditions).await?;
+        }
+
+        // Spend the CATs.
+        for (asset_id, cat_coins) in coins.cats {
+            let Some(primary_cat) = cat_coins.first().copied() else {
+                continue;
+            };
+
+            let offered_amount = maker.cats.get(&asset_id).copied().unwrap_or(0)
+                + maker_royalties.cat_amount(asset_id);
+            let total_amount = cat_coins.iter().map(|cat| cat.coin.amount).sum::<u64>();
+            let change = total_amount - offered_amount;
+
+            let p2_option_puzzle =
+                option_contract.p2_option_puzzle(ctx, offered_amount, assertions.clone(), true)?;
+
+            let mut conditions = primary_conditions
+                .remove(&primary_cat.coin.coin_id())
+                .unwrap_or_default()
+                .create_coin(
+                    p2_option_puzzle.curry_tree_hash().into(),
+                    offered_amount,
+                    None,
+                );
+
+            if change > 0 {
+                let change_hint = ctx.hint(p2_puzzle_hash)?;
+
+                conditions = conditions.create_coin(p2_puzzle_hash, change, Some(change_hint));
+            }
+
+            self.spend_cat_coins(
+                ctx,
+                cat_coins
+                    .into_iter()
+                    .map(|cat| (cat, mem::take(&mut conditions))),
+            )
+            .await?;
+        }
+
+        // Spend the NFTs.
+        for nft in coins.nfts.into_values() {
+            let metadata_ptr = ctx.alloc(&nft.info.metadata)?;
+            let nft = nft.with_metadata(HashedPtr::from_ptr(&ctx.allocator, metadata_ptr));
+
+            let synthetic_key = self.db.synthetic_key(nft.info.p2_puzzle_hash).await?;
+            let p2 = StandardLayer::new(synthetic_key);
+
+            let p2_option_puzzle =
+                option_contract.p2_option_puzzle(ctx, nft.coin.amount, assertions.clone(), true)?;
+
+            let conditions = primary_conditions
+                .remove(&nft.coin.coin_id())
+                .unwrap_or_default();
+
+            let _nft = nft.transfer(
+                ctx,
+                &p2,
+                p2_option_puzzle.curry_tree_hash().into(),
+                conditions,
+            )?;
+        }
+
+        Ok(ctx.take())
+    }
+}

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

@@ -35,7 +35,7 @@ impl Wallet {
         }
 
         if change > 0 {
-            conditions = conditions.create_coin(p2_puzzle_hash, change, Vec::new());
+            conditions = conditions.create_coin(p2_puzzle_hash, change, None);
         }
 
         let mut ctx = SpendContext::new();
@@ -106,7 +106,7 @@ impl Wallet {
 
                     remaining_amount -= amount as u128;
 
-                    conditions = conditions.create_coin(derivation, amount, Vec::new());
+                    conditions = conditions.create_coin(derivation, amount, None);
 
                     remaining_count -= 1;
                 }
@@ -144,17 +144,13 @@ impl Wallet {
 
                     // If there is excess amount in this coin after the fee is paid, create a new output.
                     if consumed < coin.amount {
-                        Conditions::new().create_coin(
-                            puzzle_hash,
-                            coin.amount - consumed,
-                            Vec::new(),
-                        )
+                        Conditions::new().create_coin(puzzle_hash, coin.amount - consumed, None)
                     } else {
                         Conditions::new()
                     }
                 } else {
                     // Otherwise, just create a new output coin at the given puzzle hash.
-                    Conditions::new().create_coin(puzzle_hash, coin.amount, Vec::new())
+                    Conditions::new().create_coin(puzzle_hash, coin.amount, None)
                 };
 
                 // Ensure that there is a ring of assertions for all of the coins.

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

@@ -1,5 +1,5 @@
 use chia::protocol::{Bytes, Bytes32, CoinSpend};
-use chia_wallet_sdk::{Conditions, SpendContext};
+use chia_wallet_sdk::{Conditions, Memos, SpendContext};
 
 use crate::WalletError;
 
@@ -26,18 +26,22 @@ impl Wallet {
             .try_into()
             .expect("change amount overflow");
 
-        let mut conditions = Conditions::new().create_coin(puzzle_hash, amount, memos);
+        let mut ctx = SpendContext::new();
+
+        let mut conditions = Conditions::new().create_coin(
+            puzzle_hash,
+            amount,
+            Some(Memos::new(ctx.alloc(&memos)?)),
+        );
 
         if fee > 0 {
             conditions = conditions.reserve_fee(fee);
         }
 
         if change > 0 {
-            conditions = conditions.create_coin(change_puzzle_hash, change, Vec::new());
+            conditions = conditions.create_coin(change_puzzle_hash, change, None);
         }
 
-        let mut ctx = SpendContext::new();
-
         self.spend_p2_coins(&mut ctx, coins, conditions).await?;
 
         Ok(ctx.take())

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

@@ -69,7 +69,11 @@ impl Wallet {
         let mut indices = HashMap::new();
 
         for required in &required_signatures {
-            let pk = required.public_key();
+            let RequiredSignature::Bls(required) = required else {
+                return Err(WalletError::UnknownPublicKey);
+            };
+
+            let pk = required.public_key;
             let Some(index) = self.db.synthetic_key_index(pk).await? else {
                 if partial {
                     continue;
@@ -92,8 +96,12 @@ impl Wallet {
         let mut aggregated_signature = Signature::default();
 
         for required in required_signatures {
-            let sk = secret_keys[&required.public_key()].clone();
-            aggregated_signature += &sign(&sk, required.final_message());
+            let RequiredSignature::Bls(required) = required else {
+                return Err(WalletError::UnknownPublicKey);
+            };
+
+            let sk = secret_keys[&required.public_key].clone();
+            aggregated_signature += &sign(&sk, required.message());
         }
 
         Ok(SpendBundle::new(coin_spends, aggregated_signature))

crates/sage/src/endpoints.rs

@@ -2,6 +2,7 @@ mod actions;
 mod data;
 mod keys;
 mod offers;
+mod options;
 mod settings;
 mod transactions;
 mod wallet_connect;

crates/sage/src/endpoints/options.rs

@@ -0,0 +1,88 @@
+use chia::{bls::Signature, protocol::SpendBundle, puzzles::nft::NftMetadata};
+use chia_wallet_sdk::Offer;
+use indexmap::IndexMap;
+use sage_api::{CatAmount, MintOption, TransactionResponse};
+use sage_wallet::{fetch_nft_offer_details, MakerSide, Option, TakerSide};
+use tracing::debug;
+
+use crate::{parse_asset_id, parse_cat_amount, parse_did_id, parse_nft_id, Error, Result, Sage};
+
+impl Sage {
+    pub async fn mint_option(&self, req: MintOption) -> Result<TransactionResponse> {
+        let wallet = self.wallet()?;
+
+        let offered_xch = self.parse_amount(req.offered_assets.xch)?;
+
+        let mut offered_cats = IndexMap::new();
+
+        for CatAmount { asset_id, amount } in req.offered_assets.cats {
+            offered_cats.insert(parse_asset_id(asset_id)?, parse_cat_amount(amount)?);
+        }
+
+        let mut offered_nfts = Vec::new();
+
+        for nft_id in req.offered_assets.nfts {
+            offered_nfts.push(parse_nft_id(nft_id)?);
+        }
+
+        let requested_xch = self.parse_amount(req.requested_assets.xch)?;
+
+        let mut requested_cats = IndexMap::new();
+
+        for CatAmount { asset_id, amount } in req.requested_assets.cats {
+            requested_cats.insert(parse_asset_id(asset_id)?, parse_cat_amount(amount)?);
+        }
+
+        let mut requested_nfts = IndexMap::new();
+        let mut peer = None;
+
+        for nft_id in req.requested_assets.nfts {
+            if peer.is_none() {
+                peer = self.peer_state.lock().await.acquire_peer();
+            }
+
+            let peer = peer.as_ref().ok_or(Error::NoPeers)?;
+
+            let nft_id = parse_nft_id(nft_id)?;
+
+            let Some(offer_details) = fetch_nft_offer_details(peer, nft_id).await? else {
+                return Err(Error::CouldNotFetchNft(nft_id));
+            };
+
+            requested_nfts.insert(nft_id, offer_details);
+        }
+
+        let fee = self.parse_amount(req.fee)?;
+        let did_id = parse_did_id(req.did_id)?;
+
+        let coin_spends = wallet
+            .mint_option(
+                Option {
+                    maker: MakerSide {
+                        xch: offered_xch,
+                        cats: offered_cats,
+                        nfts: offered_nfts,
+                        fee,
+                    },
+                    taker: TakerSide {
+                        xch: requested_xch,
+                        cats: requested_cats,
+                        nfts: requested_nfts,
+                    },
+                    expiration_seconds: req.expires_at_second,
+                    nft_metadata: NftMetadata::default(),
+                    did_id,
+                },
+                false,
+                true,
+            )
+            .await?;
+
+        debug!(
+            "coin_spends: {:?}",
+            Offer::from(SpendBundle::new(coin_spends.clone(), Signature::default())).encode()?
+        );
+
+        self.transact(coin_spends, req.auto_submit).await
+    }
+}

crates/sage/src/endpoints/transactions.rs

@@ -319,7 +319,7 @@ impl Sage {
         Ok(SubmitTransactionResponse {})
     }
 
-    async fn transact(
+    pub(crate) async fn transact(
         &self,
         coin_spends: Vec<CoinSpend>,
         auto_submit: bool,

crates/sage/src/endpoints/wallet_connect.rs

@@ -1,6 +1,6 @@
 use chia::{
     bls::{master_to_wallet_unhardened, sign},
-    clvm_utils::{CurriedProgram, ToTreeHash},
+    clvm_utils::ToTreeHash,
     protocol::{Bytes, Coin, CoinSpend, SpendBundle},
     puzzles::{cat::CatArgs, standard::StandardArgs, DeriveSynthetic, Proof},
 };
@@ -87,14 +87,8 @@ impl Sage {
                         let synthetic_key = wallet.db.synthetic_key(cat.p2_puzzle_hash).await?;
 
                         let mut ctx = SpendContext::new();
-                        let p2_puzzle = CurriedProgram {
-                            program: ctx.standard_puzzle()?,
-                            args: StandardArgs::new(synthetic_key),
-                        };
-                        let cat_puzzle = CurriedProgram {
-                            program: ctx.cat_puzzle()?,
-                            args: CatArgs::new(cat.asset_id, p2_puzzle),
-                        };
+                        let p2_puzzle = ctx.curry(StandardArgs::new(synthetic_key))?;
+                        let cat_puzzle = ctx.curry(CatArgs::new(cat.asset_id, p2_puzzle))?;
 
                         items.push(SpendableCoin {
                             coin: wallet_connect::Coin {
@@ -167,10 +161,7 @@ impl Sage {
                             wallet.db.synthetic_key(did.info.p2_puzzle_hash).await?;
 
                         let mut ctx = SpendContext::new();
-                        let p2_puzzle = CurriedProgram {
-                            program: ctx.standard_puzzle()?,
-                            args: StandardArgs::new(synthetic_key),
-                        };
+                        let p2_puzzle = ctx.curry(StandardArgs::new(synthetic_key))?;
                         let did_puzzle =
                             did.info.into_layers(p2_puzzle).construct_puzzle(&mut ctx)?;
 
@@ -252,10 +243,7 @@ impl Sage {
                             wallet.db.synthetic_key(nft.info.p2_puzzle_hash).await?;
 
                         let mut ctx = SpendContext::new();
-                        let p2_puzzle = CurriedProgram {
-                            program: ctx.standard_puzzle()?,
-                            args: StandardArgs::new(synthetic_key),
-                        };
+                        let p2_puzzle = ctx.curry(StandardArgs::new(synthetic_key))?;
                         let nft_puzzle =
                             nft.info.into_layers(p2_puzzle).construct_puzzle(&mut ctx)?;
 
@@ -315,10 +303,7 @@ impl Sage {
                 let synthetic_key = wallet.db.synthetic_key(cs.coin.puzzle_hash).await?;
 
                 let mut ctx = SpendContext::new();
-                let puzzle = CurriedProgram {
-                    program: ctx.standard_puzzle()?,
-                    args: StandardArgs::new(synthetic_key),
-                };
+                let puzzle = ctx.curry(StandardArgs::new(synthetic_key))?;
 
                 items.push(SpendableCoin {
                     coin: wallet_connect::Coin {

src-tauri/src/commands.rs

@@ -286,6 +286,15 @@ pub async fn delete_offer(
     Ok(state.lock().await.delete_offer(req).await?)
 }
 
+#[command]
+#[specta]
+pub async fn mint_option(
+    state: State<'_, AppState>,
+    req: MintOption,
+) -> Result<TransactionResponse> {
+    Ok(state.lock().await.mint_option(req).await?)
+}
+
 #[command]
 #[specta]
 pub async fn get_sync_status(

src-tauri/src/lib.rs

@@ -65,6 +65,7 @@ pub fn run() {
             commands::get_offers,
             commands::get_offer,
             commands::delete_offer,
+            commands::mint_option,
             commands::network_config,
             commands::set_discover_peers,
             commands::set_target_peers,

src/bindings.ts

@@ -149,6 +149,9 @@ async getOffer(req: GetOffer) : Promise<GetOfferResponse> {
 async deleteOffer(req: DeleteOffer) : Promise<DeleteOfferResponse> {
     return await TAURI_INVOKE("delete_offer", { req });
 },
+async mintOption(req: MintOption) : Promise<TransactionResponse> {
+    return await TAURI_INVOKE("mint_option", { req });
+},
 async networkConfig() : Promise<NetworkConfig> {
     return await TAURI_INVOKE("network_config");
 },
@@ -308,6 +311,7 @@ export type Logout = Record<string, never>
 export type LogoutResponse = Record<string, never>
 export type MakeOffer = { requested_assets: Assets; offered_assets: Assets; fee: Amount; expires_at_second: number | null }
 export type MakeOfferResponse = { offer: string; offer_id: string }
+export type MintOption = { requested_assets: Assets; offered_assets: Assets; fee: Amount; expires_at_second: number; did_id: string; auto_submit?: boolean }
 export type Network = { default_port: number; ticker: string; address_prefix: string; precision: number; genesis_challenge: string; agg_sig_me: string; dns_introducers: string[] }
 export type NetworkConfig = { network_id: string; target_peers: number; discover_peers: boolean }
 export type NftCollectionRecord = { collection_id: string; did_id: string; metadata_collection_id: string; visible: boolean; name: string | null; icon: string | null; nfts: number; visible_nfts: number }

src/pages/MakeOffer.tsx

@@ -1,4 +1,5 @@
-import { Assets, commands } from '@/bindings';
+import { Amount, Assets, commands, TransactionResponse } from '@/bindings';
+import ConfirmationDialog from '@/components/ConfirmationDialog';
 import Container from '@/components/Container';
 import { CopyBox } from '@/components/CopyBox';
 import Header from '@/components/Header';
@@ -15,7 +16,15 @@ import {
 import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
 import { TokenAmountInput } from '@/components/ui/masked-input';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
 import { Switch } from '@/components/ui/switch';
+import { useDids } from '@/hooks/useDids';
 import { useErrors } from '@/hooks/useErrors';
 import { toMojos } from '@/lib/utils';
 import { clearOffer, useOfferState, useWalletState } from '@/state';
@@ -35,50 +44,80 @@ export function MakeOffer() {
   const navigate = useNavigate();
 
   const { addError } = useErrors();
+  const { dids } = useDids();
 
   const [offer, setOffer] = useState('');
+  const [response, setResponse] = useState<TransactionResponse | null>(null);
+
+  const offeredAssets = (): Assets => {
+    return {
+      xch: toMojos(
+        (state.offered.xch || '0').toString(),
+        walletState.sync.unit.decimals,
+      ),
+      cats: state.offered.cats.map((cat) => ({
+        asset_id: cat.asset_id,
+        amount: toMojos((cat.amount || '0').toString(), 3),
+      })),
+      nfts: state.offered.nfts,
+    };
+  };
+
+  const requestedAssets = (): Assets => {
+    return {
+      xch: toMojos(
+        (state.requested.xch || '0').toString(),
+        walletState.sync.unit.decimals,
+      ),
+      cats: state.requested.cats.map((cat) => ({
+        asset_id: cat.asset_id,
+        amount: toMojos((cat.amount || '0').toString(), 3),
+      })),
+      nfts: state.requested.nfts,
+    };
+  };
+
+  const calculateFee = (): Amount => {
+    return toMojos(
+      (state.fee || '0').toString(),
+      walletState.sync.unit.decimals,
+    );
+  };
+
+  const expiration = () => {
+    return state.expiration === null
+      ? null
+      : Math.ceil(Date.now() / 1000) +
+          Number(state.expiration.days || '0') * 24 * 60 * 60 +
+          Number(state.expiration.hours || '0') * 60 * 60 +
+          Number(state.expiration.minutes || '0') * 60;
+  };
 
   const make = () => {
     commands
       .makeOffer({
-        offered_assets: {
-          xch: toMojos(
-            (state.offered.xch || '0').toString(),
-            walletState.sync.unit.decimals,
-          ),
-          cats: state.offered.cats.map((cat) => ({
-            asset_id: cat.asset_id,
-            amount: toMojos((cat.amount || '0').toString(), 3),
-          })),
-          nfts: state.offered.nfts,
-        },
-        requested_assets: {
-          xch: toMojos(
-            (state.requested.xch || '0').toString(),
-            walletState.sync.unit.decimals,
-          ),
-          cats: state.requested.cats.map((cat) => ({
-            asset_id: cat.asset_id,
-            amount: toMojos((cat.amount || '0').toString(), 3),
-          })),
-          nfts: state.requested.nfts,
-        },
-        fee: toMojos(
-          (state.fee || '0').toString(),
-          walletState.sync.unit.decimals,
-        ),
-        expires_at_second:
-          state.expiration === null
-            ? null
-            : Math.ceil(Date.now() / 1000) +
-              Number(state.expiration.days || '0') * 24 * 60 * 60 +
-              Number(state.expiration.hours || '0') * 60 * 60 +
-              Number(state.expiration.minutes || '0') * 60,
+        offered_assets: offeredAssets(),
+        requested_assets: requestedAssets(),
+        fee: calculateFee(),
+        expires_at_second: expiration(),
       })
       .then((data) => setOffer(data.offer))
       .catch(addError);
   };
 
+  const mintOption = () => {
+    commands
+      .mintOption({
+        offered_assets: offeredAssets(),
+        requested_assets: requestedAssets(),
+        fee: calculateFee(),
+        expires_at_second: expiration()!,
+        did_id: state.did,
+      })
+      .then((data) => setResponse(data))
+      .catch(addError);
+  };
+
   const invalid =
     state.expiration !== null &&
     (isNaN(Number(state.expiration.days)) ||
@@ -160,7 +199,65 @@ export function MakeOffer() {
 
             <div className='flex flex-col gap-2'>
               <div className='flex items-center gap-2'>
-                <label htmlFor='expiring'>Expiring offer</label>
+                <label htmlFor='expiring'>
+                  Mint option contract instead of offer
+                </label>
+                <Switch
+                  id='option'
+                  checked={state.option}
+                  onCheckedChange={(value) => {
+                    if (value) {
+                      useOfferState.setState({
+                        option: true,
+                        expiration: {
+                          days: '7',
+                          hours: '',
+                          minutes: '',
+                        },
+                      });
+                    } else {
+                      useOfferState.setState({
+                        option: false,
+                      });
+                    }
+                  }}
+                />
+              </div>
+            </div>
+
+            {state.option && (
+              <Select
+                value={state.did}
+                onValueChange={(value) =>
+                  useOfferState.setState({ did: value })
+                }
+              >
+                <SelectTrigger id='profile' aria-label='Select profile'>
+                  <SelectValue placeholder='Select profile' />
+                </SelectTrigger>
+                <SelectContent>
+                  {dids
+                    .filter((did) => did.visible)
+                    .map((did) => {
+                      return (
+                        <SelectItem
+                          key={did.launcher_id}
+                          value={did.launcher_id}
+                        >
+                          {did.name ??
+                            `${did.launcher_id.slice(0, 14)}...${did.launcher_id.slice(-4)}`}
+                        </SelectItem>
+                      );
+                    })}
+                </SelectContent>
+              </Select>
+            )}
+
+            <div className='flex flex-col gap-2'>
+              <div className='flex items-center gap-2'>
+                <label htmlFor='expiring'>
+                  {state.option ? 'Option expires in' : 'Offer expires in'}
+                </label>
                 <Switch
                   id='expiring'
                   checked={state.expiration !== null}
@@ -262,9 +359,16 @@ export function MakeOffer() {
           >
             Cancel Offer
           </Button>
-          <Button onClick={make} disabled={invalid}>
-            Create Offer
-          </Button>
+
+          {state.option ? (
+            <Button onClick={mintOption} disabled={invalid}>
+              Mint Option
+            </Button>
+          ) : (
+            <Button onClick={make} disabled={invalid}>
+              Make Offer
+            </Button>
+          )}
         </div>
 
         <Dialog open={!!offer} onOpenChange={() => setOffer('')}>
@@ -296,6 +400,12 @@ export function MakeOffer() {
           </DialogContent>
         </Dialog>
       </Container>
+
+      <ConfirmationDialog
+        response={response}
+        close={() => setResponse(null)}
+        onConfirm={() => navigate('/nfts')}
+      />
     </>
   );
 }

src/pages/Offers.tsx

@@ -117,11 +117,11 @@ export function Offers() {
               <div className='flex gap-2'>
                 <DialogTrigger asChild>
                   <Button variant='outline' className='flex items-center gap-1'>
-                    View offer
+                    View Offer
                   </Button>
                 </DialogTrigger>
                 <Link to='/offers/make' replace={true}>
-                  <Button>Create offer</Button>
+                  <Button>Make Offer</Button>
                 </Link>
               </div>
             </div>

src/state.ts

@@ -19,6 +19,8 @@ export interface OfferState {
   requested: Assets;
   fee: string;
   expiration: OfferExpiration | null;
+  option: boolean;
+  did: string;
 }
 
 export interface OfferExpiration {
@@ -135,6 +137,8 @@ export function defaultOffer(): OfferState {
     },
     fee: '',
     expiration: null,
+    option: false,
+    did: '',
   };
 }