feat: make sure deductions are made in sellable buy logic

Author: Peartes

contracts/asset/src/execute.rs

@@ -641,12 +641,13 @@ fn test_buy() {
     use cosmwasm_std::testing::{message_info, mock_dependencies, mock_env};
     use cosmwasm_std::{Empty, coin, coins};
 
-    // successful buy transfers ownership, pays seller, removes listing, and emits attributes
+    // successful buy transfers ownership, pays seller, pays royalties, removes listing, and emits attributes
     {
         let mut deps = mock_dependencies();
         let env = mock_env();
         let seller_addr = deps.api.addr_make("seller");
         let buyer_addr = deps.api.addr_make("buyer");
+        let owner_addr = deps.api.addr_make("owner");
         let nft_info = NftInfo {
             owner: seller_addr.clone(),
             approvals: vec![],
@@ -682,7 +683,7 @@ fn test_buy() {
             &message_info(&buyer_addr, &[price.clone()]),
             "token-1".to_string(),
             None,
-            vec![(seller_addr.to_string(), coin(10 as u128, "uxion"), "marketplace_fee".to_string())],
+            vec![(owner_addr.to_string(), coin(10 as u128, "uxion"), "royalties".to_string())],
         )
         .unwrap();
 
@@ -694,7 +695,7 @@ fn test_buy() {
         assert_eq!(
             attrs,
             vec![
-                ("marketplace_fee".to_string(), "100".to_string()),
+                ("marketplace_fee".to_string(), "1".to_string()),
                 ("action".to_string(), "buy".to_string()),
                 ("id".to_string(), "token-1".to_string()),
                 ("price".to_string(), price.amount.to_string()),
@@ -715,7 +716,7 @@ fn test_buy() {
                 amount: coins(1 as u128, "uxion"),
             }),CosmosMsg::Bank(BankMsg::Send {
                 to_address: seller_addr.to_string(),
-                amount: coins(99 as u128, "uxion"),
+                amount: coins(89 as u128, "uxion"),
             })],
         );
 

contracts/asset/src/plugin.rs

@@ -20,7 +20,7 @@ use crate::{
     msg::AssetExtensionExecuteMsg,
     plugin,
     state::{AssetConfig, Reserve},
-    traits::{AssetContract, DefaultAssetContract},
+    traits::{AssetContract, DefaultAssetContract, SellableAsset},
 };
 
 /// Shared context passed through the pipeline, mutated by plugins.
@@ -438,6 +438,62 @@ where
     TNftExtensionMsg: Cw721CustomMsg,
     TNftExtensionMsg: StateFactory<TNftExtension>,
 {
+    fn execute_pluggable(
+        &self,
+        deps: DepsMut,
+        env: &Env,
+        info: &MessageInfo,
+        msg: Cw721ExecuteMsg<TNftExtensionMsg, TCollectionExtensionMsg, AssetExtensionExecuteMsg>,
+    ) -> Result<Response<Empty>, Cw721ContractError> {
+        let plugin_response: Response<Empty>;
+        let plugin_ctx_deductions: Vec<(String, Coin, String)>;
+        {
+            let mut plugin_ctx = Self::get_plugin_ctx(deps.as_ref(), env, info);
+
+            match &msg {
+                Cw721ExecuteMsg::TransferNft {
+                    recipient,
+                    token_id,
+                } => self.on_transfer_plugin(&recipient, &token_id, &mut plugin_ctx)?,
+                Cw721ExecuteMsg::UpdateExtension { msg } => {
+                    self.on_update_extension_plugin(&msg, &mut plugin_ctx)?
+                }
+                _ => true,
+            };
+            plugin_response = plugin_ctx.response;
+            plugin_ctx_deductions = plugin_ctx.deductions.clone();
+        };
+        let mut response = match &msg {
+            Cw721ExecuteMsg::UpdateExtension { msg: extension_msg } => {
+                match extension_msg {
+                    AssetExtensionExecuteMsg::Buy { token_id, recipient } => {
+                        self.buy(deps, env, info, (*token_id).clone(), (*recipient).clone(), plugin_ctx_deductions)?
+                    },
+                    _ => self.execute(deps, env, info, msg)?,
+                }
+            },
+             _ => self.execute(deps, env, info, msg)?,
+        };
+
+        response.messages.extend(plugin_response.messages);
+        response.events.extend(plugin_response.events);
+        response.attributes.extend(plugin_response.attributes);
+
+        if let Some(plugin_data) = plugin_response.data {
+            match &mut response.data {
+                Some(existing) => {
+                    let mut combined = Vec::with_capacity(existing.len() + plugin_data.len());
+                    combined.extend_from_slice(existing.as_slice());
+                    combined.extend_from_slice(plugin_data.as_slice());
+                    *existing = Binary::from(combined);
+                }
+                None => response.data = Some(plugin_data),
+            }
+        }
+
+        Ok(response)
+    }
+
     fn on_update_extension_plugin<'a>(
         &self,
         msg: &AssetExtensionExecuteMsg,

contracts/asset/src/test.rs

@@ -451,7 +451,7 @@ mod asset_pluggable_tests {
         let token_id = "token-1".to_string();
         let price = Coin::new(100u128, "uxion");
 
-        let result = contract.on_list_plugin(&token_id, &price, &None, &None,&mut ctx);
+        let result = contract.on_list_plugin(&token_id, &price, &None, &None, &mut ctx);
 
         assert_eq!(
             result.expect_err("expected min price error").to_string(),
@@ -1154,3 +1154,153 @@ mod query_test {
         }));
     }
 }
+
+#[cfg(test)]
+mod asset_pluggable_sellable_test {
+    use std::collections::HashMap;
+
+    use crate::{
+        msg::AssetExtensionExecuteMsg,
+        plugin::{PluggableAsset, Plugin},
+        state::{AssetConfig, ListingInfo},
+        traits::DefaultAssetContract,
+    };
+    use cosmwasm_std::{
+        BankMsg, Coin, CosmosMsg, Empty,
+        testing::{message_info, mock_dependencies, mock_env},
+    };
+    use cw721::{msg::Cw721ExecuteMsg, state::NftInfo};
+
+    #[test]
+    fn buy_deducts_marketplace_and_royalty_fees() {
+        let mut deps = mock_dependencies();
+        let mut contract: DefaultAssetContract<'static, Empty, Empty, Empty, Empty> =
+            Default::default();
+
+        let seller = deps.api.addr_make("seller");
+        let buyer = deps.api.addr_make("buyer");
+        let marketplace = deps.api.addr_make("marketplace");
+        let royalty_recipient = deps.api.addr_make("artist");
+
+        let price = Coin::new(1_000u128, "uxion");
+
+        let listing = ListingInfo {
+            id: "token-1".to_string(),
+            price: price.clone(),
+            seller: seller.clone(),
+            reserved: None,
+            nft_info: NftInfo {
+                owner: seller.clone(),
+                approvals: vec![],
+                token_uri: None,
+                extension: Empty::default(),
+            },
+            marketplace_fee_bps: Some(1_000),
+            marketplace_fee_recipient: Some(marketplace.clone()),
+        };
+
+        contract
+            .config
+            .listings
+            .save(deps.as_mut().storage, "token-1", &listing)
+            .unwrap();
+        contract
+            .config
+            .cw721_config
+            .nft_info
+            .save(deps.as_mut().storage, "token-1", &listing.nft_info)
+            .unwrap();
+        contract
+            .config
+            .collection_plugins
+            .save(
+                deps.as_mut().storage,
+                "Royalty",
+                &Plugin::Royalty {
+                    bps: 500,
+                    recipient: royalty_recipient.clone(),
+                    on_primary: true,
+                },
+            )
+            .unwrap();
+
+        let env = mock_env();
+        let info = message_info(&buyer, &[price.clone()]);
+
+        let res = contract
+            .execute_pluggable(
+                deps.as_mut(),
+                &env,
+                &info,
+                Cw721ExecuteMsg::UpdateExtension {
+                    msg: AssetExtensionExecuteMsg::Buy {
+                        token_id: "token-1".to_string(),
+                        recipient: None,
+                    },
+                },
+            )
+            .unwrap();
+
+        assert_eq!(res.messages.len(), 3);
+
+        let mut marketplace_paid = None;
+        let mut seller_paid = None;
+        let mut royalty_paid = None;
+
+        for msg in &res.messages {
+            match &msg.msg {
+                CosmosMsg::Bank(BankMsg::Send { to_address, amount }) => {
+                    let coin = amount
+                        .first()
+                        .cloned()
+                        .expect("send message must include funds");
+                    if *to_address == marketplace.to_string() {
+                        marketplace_paid = Some(coin);
+                    } else if *to_address == seller.to_string() {
+                        seller_paid = Some(coin);
+                    } else if *to_address == royalty_recipient.to_string() {
+                        royalty_paid = Some(coin);
+                    } else {
+                        panic!("unexpected recipient {}", to_address);
+                    }
+                }
+                other => panic!("unexpected message: {:?}", other),
+            }
+        }
+
+        assert_eq!(
+            marketplace_paid.expect("marketplace fee"),
+            Coin::new(100u128, "uxion"),
+        );
+        assert_eq!(
+            royalty_paid.expect("royalty fee"),
+            Coin::new(50u128, "uxion"),
+        );
+        assert_eq!(
+            seller_paid.expect("seller payment"),
+            Coin::new(850u128, "uxion"),
+        );
+
+        let attrs: HashMap<_, _> = res
+            .attributes
+            .iter()
+            .map(|attr| (attr.key.clone(), attr.value.clone()))
+            .collect();
+        assert_eq!(attrs.get("marketplace_fee"), Some(&"100".to_string()));
+        assert_eq!(
+            attrs.get("royalty_amount"),
+            Some(&Coin::new(50u128, "uxion").to_string()),
+        );
+        assert_eq!(
+            attrs.get("royalty_recipient"),
+            Some(&royalty_recipient.to_string()),
+        );
+
+        let stored_nft = AssetConfig::<Empty>::default()
+            .cw721_config
+            .nft_info
+            .load(deps.as_ref().storage, "token-1")
+            .unwrap();
+        assert_eq!(stored_nft.owner, buyer);
+    }
+}

contracts/asset/src/traits.rs

@@ -188,7 +188,6 @@ impl<
     TCollectionExtension,
     TCollectionExtensionMsg,
     TExtentionMsg,
-    TCustomResponseMsg,
 >
     SellableAsset<
         'a,
@@ -197,7 +196,7 @@ impl<
         TCollectionExtension,
         TCollectionExtensionMsg,
         TExtentionMsg,
-        TCustomResponseMsg,
+        Empty,
     >
     for AssetContract<
         'a,
@@ -214,7 +213,6 @@ where
     TCollectionExtension: FromAttributesState + ToAttributesState,
     TCollectionExtensionMsg: StateFactory<TCollectionExtension> + Cw721CustomMsg,
     TCollectionExtensionMsg: Default,
-    TCustomResponseMsg: CustomMsg,
 {
 }
 
@@ -224,15 +222,14 @@ impl<
     TNftExtensionMsg,
     TCollectionExtension,
     TCollectionExtensionMsg,
-    TCustomResponseMsg,
 >
     Cw721Execute<
         TNftExtension,
         TNftExtensionMsg,
         TCollectionExtension,
         TCollectionExtensionMsg,
         AssetExtensionExecuteMsg,
-        TCustomResponseMsg,
+        Empty,
     >
     for DefaultAssetContract<
         'a,
@@ -244,7 +241,6 @@ impl<
 where
     TNftExtension: Cw721State,
     TNftExtensionMsg: StateFactory<TNftExtension> + Cw721CustomMsg,
-    TCustomResponseMsg: CustomMsg,
     TCollectionExtensionMsg: StateFactory<TCollectionExtension> + Cw721CustomMsg,
     TCollectionExtension: Cw721State,
     TCollectionExtension: FromAttributesState + ToAttributesState,
@@ -256,7 +252,7 @@ where
         env: &Env,
         info: &MessageInfo,
         msg: AssetExtensionExecuteMsg,
-    ) -> Result<Response<TCustomResponseMsg>, cw721::error::Cw721ContractError> {
+    ) -> Result<Response<Empty>, cw721::error::Cw721ContractError> {
         match msg {
             AssetExtensionExecuteMsg::List {
                 token_id,