chore: disable raw transfer if royalty is set

Author: Peartes

contracts/asset/README.md

@@ -0,0 +1,122 @@
+# Asset Contract
+
+A CosmWasm `cw721`-compatible asset contract for the XION network that layers marketplace
+functionality and a pluggable execution pipeline on top of NFT collections. The library exposes
+traits that make it easy to extend vanilla `cw721` contracts with listing, reservation, and plugin
+logic without rewriting the core token implementation.
+
+## Core Types and Traits
+
+- `AssetContract` / `DefaultAssetContract`
+  - Thin wrapper around the canonical `cw721` storage helpers (`Cw721Config`) plus marketplace
+    indices (`IndexedMap` for listings and plugin registry).
+  - `DefaultAssetContract` picks `AssetExtensionExecuteMsg` as the extension message so you get the
+    marketplace verbs (list, reserve, delist, buy) out of the box.
+
+- `SellableAsset`
+  - Trait that adds four high-level marketplace entry points: `list`, `reserve`, `delist`, and `buy`.
+  - Each method wires through the shared `AssetConfig` helpers defined in `execute.rs`, handling
+    ownership checks, price validation, and state transitions.
+  - Implemented for `AssetContract`, so adopting the trait is as simple as embedding the contract
+    struct in your project.
+
+- `PluggableAsset`
+  - Trait that wraps `cw721::Cw721Execute::execute` with a plugin pipeline (`execute_pluggable`).
+  - Hooks (`on_list_plugin`, `on_buy_plugin`, etc.) run before the base action and can mutate a
+    `PluginCtx` shared across plugins. The returned `Response` from plugins is merged back into the
+    main execution result, allowing plugins to enqueue messages, attributes, or data.
+  - `DefaultAssetContract` implements the trait using `DefaultXionAssetContext`, giving you sensible
+    defaults while still allowing custom contexts if you implement the trait yourself.
+
+## Messages and State
+
+- `AssetExtensionExecuteMsg` provides the marketplace verbs clients call via the `cw721` execute
+  route. These are automatically dispatched through `SellableAsset` when `DefaultAssetContract`
+  handles `execute_extension`.
+- `Reserve` captures an optional reservation window (`Expiration`) and address, used to gate buys.
+- `ListingInfo` stores price, seller, reserve data, and a snapshot of the NFT metadata so listings
+  remain consistent even if the token attributes change later.
+- `AssetConfig` centralizes the contract's storage maps and exposes helper constructors so you can
+  use custom storage keys when embedding the contract inside another crate.
+
+## Plugin System
+
+`plugin.rs` includes a `Plugin` enum and a default plugin module:
+
+- Price guards (`ExactPrice`, `MinimumPrice`).
+- Temporal restrictions (`NotBefore`, `NotAfter`, `TimeLock`).
+- Access control (`AllowedMarketplaces`, `RequiresProof`).
+- Currency allow-listing (`AllowedCurrencies`).
+- Royalty payouts (`Royalty`).
+
+The provided `default_plugins` module contains ready-to-use helpers that enforce the relevant rules
+and can enqueue `BankMsg::Send` payouts (e.g., royalties) or raise errors to abort the action.
+Register plugins per collection with `AssetConfig::collection_plugins` and they will be invoked by
+`execute_pluggable` automatically.
+
+## Using the Library
+
+1. **Instantiate `cw721` normally**
+   ```rust
+   pub type InstantiateMsg = asset::msg::InstantiateMsg<MyCollectionExtension>;
+   ```
+   Use the standard `cw721` instantiate flow; the asset contract reuses `Cw721InstantiateMsg`.
+
+2. **Embed the contract**
+   ```rust
+   use asset::traits::{AssetContract, DefaultAssetContract};
+
+   pub struct AppContract {
+       asset: DefaultAssetContract<'static, MyNftExtension, MyNftMsg, MyCollectionExtension, MyCollectionMsg>,
+   }
+
+   impl Default for AppContract {
+       fn default() -> Self {
+           Self { asset: AssetContract::default() }
+       }
+   }
+   ```
+
+3. **Expose execute entry points**
+   ```rust
+   use asset::traits::{PluggableAsset, SellableAsset};
+
+   pub fn execute(
+       deps: DepsMut,
+       env: Env,
+       info: MessageInfo,
+       msg: asset::msg::ExecuteMsg<MyNftMsg, MyCollectionMsg, asset::msg::AssetExtensionExecuteMsg>,
+   ) -> Result<Response, ContractError> {
+       Ok(APP_CONTRACT.asset.execute_pluggable(deps, &env, &info, msg)?)
+   }
+   ```
+   The `PluggableAsset` trait forwards marketplace operations to the relevant hooks and finally to
+   the base `cw721` implementation.
+
+4. **Dispatch marketplace operations**
+   ```rust
+   use asset::msg::AssetExtensionExecuteMsg;
+   use cosmwasm_std::{Coin, to_json_binary, CosmosMsg};
+
+   let list = CosmosMsg::Wasm(WasmMsg::Execute {
+       contract_addr: collection_addr.into(),
+       funds: vec![],
+       msg: to_json_binary(&AssetExtensionExecuteMsg::List {
+           token_id: "token-1".into(),
+           price: Coin::new(1_000_000u128, "uxion"),
+           reservation: None,
+       })?,
+   });
+   ```
+   Similar patterns apply for `Reserve`, `Buy` (attach payment funds), and `Delist` messages.
+
+## Feature Flags
+
+- `asset_base` (default): ships the standard marketplace + plugin behavior.
+- `crossmint`: alternative configuration for cross-minting scenarios (mutually exclusive with
+  `asset_base`). Ensure only one of these is enabled at a time.
+
+## Testing
+
+`src/test.rs` demonstrates how to wire mocks for the `SellableAsset` entry points and validate
+plugin flows. Use it as a reference when building integration tests around custom plugin behavior.

contracts/asset/src/contracts/Readme.md

@@ -31,12 +31,34 @@ where
     pub env: Env,
     pub info: MessageInfo,
 
+    // royalty info
+    pub royalty: RoyaltyInfo,
+
     /// The response being built up by the plugins.
     pub response: Response<TCustomResponseMsg>,
 
     pub data: Context,
 }
 
+pub struct RoyaltyInfo {
+    pub collection_royalty_bps: Option<u16>,
+    pub collection_royalty_recipient: Option<Addr>,
+    pub collection_royalty_on_primary: Option<bool>,
+
+    pub primary_complete: bool,
+}
+
+impl Default for RoyaltyInfo {
+    fn default() -> Self {
+        RoyaltyInfo {
+            collection_royalty_bps: None,
+            collection_royalty_recipient: None,
+            collection_royalty_on_primary: None,
+            primary_complete: false,
+        }
+    }
+}
+
 pub struct DefaultXionAssetContext {
     pub token_id: String,
     pub seller: Option<Addr>,
@@ -50,16 +72,6 @@ pub struct DefaultXionAssetContext {
     pub reservation: Option<Reserve>,
     pub time_lock: Option<Duration>,
 
-    pub collection_royalty_bps: Option<u16>,
-    pub collection_royalty_recipient: Option<Addr>,
-    pub collection_royalty_on_primary: Option<bool>,
-
-    pub nft_royalty_bps: Option<u16>,
-    pub nft_royalty_recipient: Option<Addr>,
-    pub nft_royalty_on_primary: Option<bool>,
-
-    pub primary_complete: bool,
-
     pub allowed_marketplaces: Option<Vec<Addr>>,
     pub allowed_currencies: Option<Vec<Coin>>,
 }
@@ -75,13 +87,6 @@ impl Default for DefaultXionAssetContext {
             not_before: Expiration::Never {},
             not_after: Expiration::Never {},
             reservation: None,
-            collection_royalty_bps: None,
-            collection_royalty_recipient: None,
-            collection_royalty_on_primary: None,
-            nft_royalty_bps: None,
-            nft_royalty_recipient: None,
-            nft_royalty_on_primary: None,
-            primary_complete: false,
             allowed_marketplaces: None,
             allowed_currencies: None,
             time_lock: None,
@@ -155,9 +160,9 @@ impl Plugin {
                 recipient,
                 on_primary,
             } => {
-                ctx.data.collection_royalty_bps = Some(*bps);
-                ctx.data.collection_royalty_recipient = Some((*recipient).clone());
-                ctx.data.collection_royalty_on_primary = Some(*on_primary);
+                ctx.royalty.collection_royalty_bps = Some(*bps);
+                ctx.royalty.collection_royalty_recipient = Some((*recipient).clone());
+                ctx.royalty.collection_royalty_on_primary = Some(*on_primary);
                 default_plugins::royalty_plugin(ctx)?;
             }
             Plugin::AllowedMarketplaces { marketplaces } => {
@@ -175,6 +180,23 @@ impl Plugin {
         }
         Ok(true)
     }
+
+    pub fn run_raw_transfer_plugin<T, U: CustomMsg>(&self, ctx: &mut PluginCtx<T, U>) -> StdResult<bool> {
+        match self {
+            Plugin::Royalty {
+                bps,
+                recipient,
+                on_primary,
+            } => {
+                ctx.royalty.collection_royalty_bps = Some(*bps);
+                ctx.royalty.collection_royalty_recipient = Some((*recipient).clone());
+                ctx.royalty.collection_royalty_on_primary = Some(*on_primary);
+                default_plugins::is_transfer_enabled_plugin(ctx)?;
+            }
+            _ => {}
+        }
+        Ok(true)
+    }
 }
 
 /// The concept of a plugin is to be able to hook into the execution flow when a certain action
@@ -263,8 +285,15 @@ pub trait PluggableAsset<
         &self,
         _recipient: &String,
         _token_id: &String,
-        _ctx: &mut PluginCtx<Context, TCustomResponseMsg>,
+        ctx: &mut PluginCtx<Context, TCustomResponseMsg>,
     ) -> StdResult<bool> {
+        // for transfers we run the royalty plugin if set
+        let royalty_plugin = AssetConfig::<TNftExtension>::default()
+            .collection_plugins
+            .may_load(ctx.deps.storage, "Royalty")?;
+        if let Some(plugin) = royalty_plugin {
+            plugin.run_raw_transfer_plugin(ctx)?;
+        }
         Ok(true)
     }
 
@@ -343,25 +372,6 @@ where
     TNftExtensionMsg: Cw721CustomMsg,
     TNftExtensionMsg: StateFactory<TNftExtension>,
 {
-    fn on_transfer_plugin(
-        &self,
-        recipient: &String,
-        token_id: &String,
-        ctx: &mut DefaultPluginCtx,
-    ) -> StdResult<bool> {
-        // for transfers we run the royalty plugin if set
-        let royalty_plugin = AssetConfig::<TNftExtension>::default()
-            .collection_plugins
-            .may_load(ctx.deps.storage, "Royalty")?;
-        ctx.data.token_id = token_id.to_string();
-        ctx.data.buyer = Some(ctx.deps.api.addr_validate(&recipient)?);
-        ctx.data.seller = Some(ctx.info.sender.clone());
-        if let Some(plugin) = royalty_plugin {
-            plugin.run_asset_plugin(ctx)?;
-        }
-        Ok(true)
-    }
-
     fn on_update_extension_plugin<'a>(
         &self,
         msg: &AssetExtensionExecuteMsg,
@@ -509,6 +519,7 @@ where
             env: env.clone(),
             info: info.clone(),
             response: Response::default(),
+            royalty: RoyaltyInfo::default(),
             data: DefaultXionAssetContext::default(),
         }
     }
@@ -626,33 +637,35 @@ pub mod default_plugins {
 
     pub fn royalty_plugin(ctx: &mut PluginCtx<DefaultXionAssetContext, Empty>) -> StdResult<bool> {
         let (recipient, bps, on_primary) = match (
-            ctx.data.nft_royalty_recipient.clone(),
-            ctx.data.nft_royalty_bps,
-            ctx.data.nft_royalty_on_primary,
+            ctx.royalty.collection_royalty_recipient.clone(),
+            ctx.royalty.collection_royalty_bps,
+            ctx.royalty.collection_royalty_on_primary,
         ) {
             (Some(recipient), Some(bps), on_primary) => (recipient, bps, on_primary),
-            _ => match (
-                ctx.data.collection_royalty_recipient.clone(),
-                ctx.data.collection_royalty_bps,
-                ctx.data.collection_royalty_on_primary,
-            ) {
-                (Some(recipient), Some(bps), on_primary) => (recipient, bps, on_primary),
-                _ => return Ok(true),
-            },
+            _ => return Ok(true),
         };
 
         if bps == 0 {
             return Ok(true);
         }
 
-        let is_primary_sale = !ctx.data.primary_complete;
+        let is_primary_sale = !ctx.royalty.primary_complete;
         let collect_on_primary = on_primary.unwrap_or(false);
         let should_collect = !is_primary_sale || collect_on_primary;
 
         if !should_collect {
             return Ok(true);
         }
 
+        if let Some(ask_price) = &ctx.data.ask_price {
+            if ask_price.amount.is_zero() {
+                return Ok(true);
+            }
+        } else {
+            return Err(cosmwasm_std::StdError::generic_err(
+                "No ask price set for royalty calculation".to_string(),
+            ))?;
+        }
         let fund = ctx
             .info
             .funds
@@ -754,6 +767,18 @@ pub mod default_plugins {
                 )));
             }
         }
+        Ok(true)
+    }
+    /// This plugin checks that raw transfers are enabled. If royalty info is set,
+    /// transfers are disabled and all transfers must go through the buy flow.
+    pub fn is_transfer_enabled_plugin<T, U: CustomMsg>(ctx: &mut PluginCtx<T, U>) -> StdResult<bool> {
+        if ctx.royalty.collection_royalty_bps.is_some()
+            && ctx.royalty.collection_royalty_recipient.is_some()
+        {
+            return Err(cosmwasm_std::StdError::generic_err(
+                "raw transfers are disabled when royalty info is set",
+            ));
+        }
 
         Ok(true)
     }