Burn to Mint

Cargo.toml

@@ -56,6 +56,7 @@ open-edition-minter  = { version = "3.1.0", path = "contracts/minters/open-editi
 whitelist-immutable  = { version = "3.1.0", path = "contracts/whitelists/whitelist-immutable" }
 sg-whitelist-flex    = { version = "3.1.0", path = "contracts/whitelists/whitelist-flex" }
 ethereum-verify      = { version = "3.1.0", path = "packages/ethereum-verify" }
+burn-to-mint         = { version = "3.1.0", path = "packages/burn-to-mint" }
 sg-eth-airdrop       = { version = "3.1.0", path = "contracts/sg-eth-airdrop" }
 test-suite           = { version = "3.1.0", path = "test-suite" }
 semver               = "1"

contracts/collections/sg721-base/src/contract.rs

@@ -1,9 +1,11 @@
 use cw721_base::state::TokenInfo;
+use cw721_base::MinterResponse;
+
 use url::Url;
 
 use cosmwasm_std::{
-    to_binary, Addr, Binary, ContractInfoResponse, Decimal, Deps, DepsMut, Empty, Env, Event,
-    MessageInfo, StdError, StdResult, Storage, Timestamp, WasmQuery,
+    from_binary, to_binary, Addr, Binary, ContractInfoResponse, Decimal, Deps, DepsMut, Empty, Env,
+    Event, MessageInfo, StdError, StdResult, Storage, Timestamp, WasmQuery,
 };
 
 use cw721::{ContractInfoResponse as CW721ContractInfoResponse, Cw721Execute};
@@ -16,7 +18,7 @@
 };
 use sg_std::Response;
 
-use crate::msg::{CollectionInfoResponse, NftParams, QueryMsg};
+use crate::msg::{self, CollectionInfoResponse, NftParams, QueryMsg};
 use crate::{ContractError, Sg721Contract};
 
 use crate::entry::{CONTRACT_NAME, CONTRACT_VERSION};
@@ -322,7 +324,6 @@
                 extension,
             } => (token_id, owner, token_uri, extension),
         };
-
         // create the token
         let token = TokenInfo {
             owner: deps.api.addr_validate(&owner)?,
@@ -336,7 +337,6 @@
                 Some(_) => Err(ContractError::Claimed {}),
                 None => Ok(token),
             })?;
-
         self.parent.increment_tokens(deps.storage)?;
 
         let mut res = Response::new()
@@ -416,6 +416,12 @@
 
         Ok(response)
     }
+
+    pub fn get_minter_owner_parent(&self, deps: Deps, env: Env) -> StdResult<MinterResponse> {
+        let msg = msg::QueryMsg::Minter {};
+        let minter: MinterResponse = from_binary(&self.parent.query(deps, env, msg.into())?)?;
+        Ok(minter)
+    }
 }
 
 pub fn share_validate(share: Decimal) -> Result<Decimal, ContractError> {
@@ -428,14 +434,6 @@
     Ok(share)
 }
 
-pub fn get_owner_minter(storage: &mut dyn Storage) -> Result<Addr, ContractError> {
-    let ownership = cw_ownable::get_ownership(storage)?;
-    match ownership.owner {
-        Some(owner_value) => Ok(owner_value),
-        None => Err(ContractError::MinterNotFound {}),
-    }
-}
-
 pub fn assert_minter_owner(storage: &mut dyn Storage, sender: &Addr) -> Result<(), ContractError> {
     let res = cw_ownable::assert_owner(storage, sender);
     match res {

contracts/collections/sg721-base/src/error.rs

@@ -55,4 +55,10 @@ pub enum ContractError {
 
     #[error("Error while migrating: ({0}) ")]
     MigrationError(String),
+
+    #[error("Contract ownership has been renounced")]
+    NoOwner,
+
+    #[error("Caller is not the contract's current owner")]
+    NotOwner,
 }

contracts/factories/base-factory/Cargo.toml

@@ -35,5 +35,7 @@ schemars        = { workspace = true }
 serde           = { workspace = true }
 sg1             = { workspace = true }
 sg2             = { workspace = true }
+cw721-base = { workspace = true, features = ["library"] }
+sg721-base      = { workspace = true, features = ["library"]} 
 sg-std          = { workspace = true }
 thiserror       = { workspace = true }

contracts/factories/base-factory/src/contract.rs

@@ -17,7 +17,6 @@
     ParamsResponse, SudoMsg,
 };
 use crate::state::SUDO_PARAMS;
-
 // version info for migration info
 const CONTRACT_NAME: &str = "crates.io:sg-base-factory";
 const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -123,7 +122,7 @@
 ) -> Result<Response, ContractError> {
     let mut params = SUDO_PARAMS.load(deps.storage)?;
 
-    update_params(&mut params, param_msg)?;
+    update_params(&mut params, param_msg, deps.as_ref())?;
 
     SUDO_PARAMS.save(deps.storage, &params)?;
 
@@ -134,6 +133,7 @@
 pub fn update_params<T, C>(
     params: &mut MinterParams<C>,
     param_msg: UpdateMinterParamsMsg<T>,
+    deps: Deps,
 ) -> Result<(), ContractError> {
     params.code_id = param_msg.code_id.unwrap_or(params.code_id);
 
@@ -149,13 +149,27 @@
         );
         params.creation_fee = creation_fee;
     }
-
     if let Some(min_mint_price) = param_msg.min_mint_price {
-        ensure_eq!(
-            &min_mint_price.denom,
-            &NATIVE_DENOM,
-            ContractError::InvalidDenom {}
-        );
+        match min_mint_price.clone() {
+            sg2::Token::Fungible(mint_price) => {
+                ensure_eq!(
+                    &mint_price.denom,
+                    &NATIVE_DENOM,
+                    ContractError::InvalidDenom {}
+                );
+            }
+            sg2::Token::NonFungible(collection) => {
+                let minter_response: Result<
+                    cw721_base::msg::MinterResponse,
+                    cosmwasm_std::StdError,
+                > = deps
+                    .querier
+                    .query_wasm_smart(collection, &sg721_base::QueryMsg::Minter {});
+                if minter_response.is_err() {
+                    return Err(ContractError::InvalidCollectionAddress {});
+                }
+            }
+        }
         params.min_mint_price = min_mint_price;
     }
 

contracts/factories/base-factory/src/error.rs

@@ -28,4 +28,10 @@ pub enum ContractError {
 
     #[error("InvalidCollectionCodeId {code_id}")]
     InvalidCollectionCodeId { code_id: u64 },
+
+    #[error("InvalidCollectionAddress")]
+    InvalidCollectionAddress {},
+
+    #[error("NoMinterForNonfungibleToken")]
+    NoMinterForNonfungibleToken {},
 }

contracts/factories/open-edition-factory/schema/instantiate_msg.json

@@ -70,7 +70,7 @@
           "minimum": 0.0
         },
         "min_mint_price": {
-          "$ref": "#/definitions/Coin"
+          "$ref": "#/definitions/Token"
         },
         "mint_fee_bps": {
           "type": "integer",
@@ -108,6 +108,34 @@
       },
       "additionalProperties": false
     },
+    "Token": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": [
+            "fungible"
+          ],
+          "properties": {
+            "fungible": {
+              "$ref": "#/definitions/Coin"
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "object",
+          "required": [
+            "non_fungible"
+          ],
+          "properties": {
+            "non_fungible": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
     "Uint128": {
       "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
       "type": "string"

contracts/factories/open-edition-factory/src/contract.rs

@@ -34,17 +34,14 @@
 ) -> Result<Response, ContractError> {
     set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
     let params = msg.params;
-
     ensure!(
-        params.extension.airdrop_mint_price.denom == params.min_mint_price.denom,
+        params.extension.airdrop_mint_price.denom == params.clone().min_mint_price.denom()?,
         BaseContractError::InvalidDenom {}
     );
-
     ensure!(
         params.creation_fee.denom == NATIVE_DENOM,
         BaseContractError::InvalidDenom {}
     );
-
     SUDO_PARAMS.save(deps.storage, &params)?;
 
     Ok(Response::new())
@@ -85,19 +82,31 @@
         deps.as_ref(),
         &params,
     )?;
-
     ensure!(
-        params.min_mint_price.denom == msg.init_msg.mint_price.denom,
+        params.min_mint_price.clone().denom()? == msg.init_msg.mint_price.denom,
         BaseContractError::InvalidDenom {}
     );
-
-    ensure!(
-        params.min_mint_price.amount <= msg.init_msg.mint_price.amount,
-        ContractError::InsufficientMintPrice {
-            expected: params.min_mint_price.amount.u128(),
+    let min_mint_price = params.min_mint_price.amount()?;
+    if min_mint_price > msg.init_msg.mint_price.amount {
+        return Err(ContractError::InsufficientMintPrice {
+            expected: min_mint_price.into(),
             got: msg.init_msg.mint_price.amount.into(),
-        }
-    );
+        });
+    }
+    // =======
+    //     ensure!(
+    //         params.min_mint_price.denom == msg.init_msg.mint_price.denom,
+    //         BaseContractError::InvalidDenom {}
+    //     );
+
+    //     ensure!(
+    //         params.min_mint_price.amount <= msg.init_msg.mint_price.amount,
+    //         ContractError::InsufficientMintPrice {
+    //             expected: params.min_mint_price.amount.u128(),
+    // >>>>>>> main
+    //             got: msg.init_msg.mint_price.amount.into(),
+    //         }
+    // );
 
     let wasm_msg = WasmMsg::Instantiate {
         admin: Some(info.sender.to_string()),
@@ -127,7 +136,7 @@
 ) -> Result<Response, ContractError> {
     let mut params = SUDO_PARAMS.load(deps.storage)?;
 
-    update_params(&mut params, param_msg.clone())?;
+    update_params(&mut params, param_msg.clone(), deps.as_ref())?;
 
     params.extension.dev_fee_address = param_msg
         .extension

contracts/factories/open-edition-factory/src/msg.rs

@@ -58,7 +58,8 @@ impl OpenEditionMinterInitMsgExtension {
             ));
         }
 
-        if init_msg.mint_price.amount < params.min_mint_price.amount {
+        let min_mint_price = params.min_mint_price.clone().amount()?;
+        if init_msg.mint_price.amount < min_mint_price {
             return Err(ContractError::InvalidMintPrice {});
         }