Safe + whitelisting

examples/collectibles.move

@@ -3,12 +3,8 @@ module nft_protocol::suinamis {
 
     use sui::tx_context::{Self, TxContext};
 
-    use nft_protocol::collection::{MintAuthority};
-    use nft_protocol::fixed_price;
-    use nft_protocol::std_collection;
     use nft_protocol::collectible;
 
-
     struct SUINAMIS has drop {}
 
     fun init(witness: SUINAMIS, ctx: &mut TxContext) {
@@ -22,7 +18,7 @@ module nft_protocol::suinamis {
             b"SUIN", // symbol
             100, // max_supply
             @0x6c86ac4a796204ea09a87b6130db0c38263c1890, // Royalty receiver
-            tags, // tags
+            tags,
             100, // royalty_fee_bps
             true, // is_mutable
             b"Some extra data",
@@ -42,29 +38,34 @@ module nft_protocol::suinamis {
             collection_id,
             @0x6c86ac4a796204ea09a87b6130db0c38263c1890,
             false, // is_embedded
-            whitelist, prices,
+            whitelist,
+            prices,
             ctx,
         );
     }
 
-    public entry fun mint_nft<T>(
+    public entry fun prepare_mint(
         name: vector<u8>,
         description: vector<u8>,
         url: vector<u8>,
         attribute_keys: vector<vector<u8>>,
         attribute_values: vector<vector<u8>>,
         max_supply: u64,
         mint: &mut MintAuthority<SUINAMIS>,
+        sale_outlet: u64,
+        launchpad: &mut Slingshot<SUINAMIS, FixedPriceMarket>,
         ctx: &mut TxContext,
     ) {
-        collectible::mint_regulated_nft_data(
+        collectible::prepare_launchpad_mint<SUINAMIS, FixedPriceMarket>(
             name,
             description,
             url,
             attribute_keys,
             attribute_values,
             max_supply,
             mint,
+            sale_outlet,
+            launchpad,
             ctx,
         );
     }

examples/suimarines.move

@@ -5,9 +5,9 @@ module nft_protocol::suimarines {
 
     use nft_protocol::collection::{MintAuthority};
     use nft_protocol::fixed_price::{Self, FixedPriceMarket};
+    use nft_protocol::slingshot::Slingshot;
     use nft_protocol::std_collection;
     use nft_protocol::unique_nft;
-    use nft_protocol::slingshot::Slingshot;
 
     struct SUIMARINES has drop {}
 
@@ -48,25 +48,25 @@ module nft_protocol::suimarines {
         );
     }
 
-    public entry fun mint_nft(
+    public entry fun prepare_mint(
         name: vector<u8>,
         description: vector<u8>,
         url: vector<u8>,
         attribute_keys: vector<vector<u8>>,
         attribute_values: vector<vector<u8>>,
         mint_authority: &mut MintAuthority<SUIMARINES>,
-        sale_index: u64,
+        sale_outlet: u64,
         launchpad: &mut Slingshot<SUIMARINES, FixedPriceMarket>,
         ctx: &mut TxContext,
     ) {
-        unique_nft::mint_regulated_nft(
+        unique_nft::prepare_launchpad_mint<SUIMARINES, FixedPriceMarket>(
             name,
             description,
             url,
             attribute_keys,
             attribute_values,
             mint_authority,
-            sale_index,
+            sale_outlet,
             launchpad,
             ctx,
         );

gutenberg/examples/c_nft.yaml

@@ -0,0 +1,19 @@
+NftType: "CNft"
+
+Collection:
+  name: "Suricannes"
+  description: "A Unique NFT collection of Hurricanes on Sui"
+  symbol: "SURI"
+  max_supply: 100
+  receiver: "0x6c86ac4a796204ea09a87b6130db0c38263c1890"
+  tags:
+    - "Art"
+    - "PFP"
+  royalty_fee_bps: 100
+  is_mutable: true
+  data: "Some extra data"
+
+Launchpad:
+  market_type: "fixed_price"
+  prices: [1000]
+  whitelists: [false]

gutenberg/src/schema.rs

@@ -95,12 +95,8 @@ impl Schema {
         let define_market_arguments = self.write_define_market_arguments();
         let market_arguments = self.write_market_arguments();
 
-        let market_module_imports = if is_embedded {
-            format!("::{{Self, {}}}", market_type)
-        } else {
-            "".to_string()
-        }
-        .into_boxed_str();
+        let market_module_imports =
+            format!("::{{Self, {}}}", market_type).into_boxed_str();
 
         let slingshot_import = if is_embedded {
             "    use nft_protocol::slingshot::Slingshot;"

gutenberg/src/types.rs

@@ -48,78 +48,89 @@ impl NftType {
         // TODO: Need to add support for unregulated collections
         let func = match self {
             NftType::Unique => format!(
-                "public entry fun mint_nft(\n        \
+                "public entry fun prepare_mint(\n        \
                     name: vector<u8>,\n        \
                     description: vector<u8>,\n        \
                     url: vector<u8>,\n        \
                     attribute_keys: vector<vector<u8>>,\n        \
                     attribute_values: vector<vector<u8>>,\n        \
-                    mint_authority: &mut MintAuthority<{}>,\n        \
-                    sale_index: u64,\n        \
-                    launchpad: &mut Slingshot<{}, {}>,\n        \
+                    mint_authority: &mut MintAuthority<{witness}>,\n        \
+                    sale_outlet: u64,\n        \
+                    launchpad: &mut Slingshot<{witness}, {market_type}>,\n        \
                     ctx: &mut TxContext,\n    \
                 ) {{\n        \
-                    unique_nft::mint_regulated_nft(\n            \
+                    unique_nft::prepare_launchpad_mint<{witness}, {market_type}>(\n            \
                         name,\n            \
                         description,\n            \
                         url,\n            \
                         attribute_keys,\n            \
                         attribute_values,\n            \
                         mint_authority,\n            \
-                        sale_index,\n            \
+                        sale_outlet,\n            \
                         launchpad,\n            \
                         ctx,\n        \
                     );\n    \
                 }}",
-                witness, witness, market_type
+                witness = witness,
+                market_type = market_type,
             ),
             NftType::Collectible => format!(
-                "public entry fun mint_nft<T>(\n        \
+                "public entry fun prepare_mint(\n        \
                     name: vector<u8>,\n        \
                     description: vector<u8>,\n        \
                     url: vector<u8>,\n        \
                     attribute_keys: vector<vector<u8>>,\n        \
                     attribute_values: vector<vector<u8>>,\n        \
                     max_supply: u64,\n        \
-                    mint: &mut MintAuthority<{}>,\n        \
+                    mint: &mut MintAuthority<{witness}>,\n        \
+                    sale_outlet: u64,\n        \
+                    launchpad: &mut Slingshot<{witness}, {market_type}>,\n        \
                     ctx: &mut TxContext,\n    \
                 ) {{\n        \
-                    collectible::mint_regulated_nft_data(\n            \
+                    collectible::prepare_launchpad_mint<{witness}, {market_type}>(\n            \
                         name,\n            \
                         description,\n            \
                         url,\n            \
                         attribute_keys,\n            \
                         attribute_values,\n            \
                         max_supply,\n            \
                         mint,\n            \
+                        sale_outlet,\n            \
+                        launchpad,\n            \
                         ctx,\n        \
                     );\n    \
                 }}",
-                witness,
+                witness = witness,
+                market_type = market_type,
             ),
             NftType::CNft => format!(
-                "public entry fun mint_nft(\n        \
+                "public entry fun prepare_mint(\n        \
                     name: vector<u8>,\n        \
                     description: vector<u8>,\n        \
                     url: vector<u8>,\n        \
                     attribute_keys: vector<vector<u8>>,\n        \
                     attribute_values: vector<vector<u8>>,\n        \
                     max_supply: u64,\n        \
-                    mint: &mut MintAuthority<{}>,\n        \
+                    mint: &mut MintAuthority<{witness}>,\n        \
+                    sale_outlet: u64,\n        \
+                    launchpad: &mut Slingshot<{witness}, {market_type}>,\n        \
                     ctx: &mut TxContext,\n    \
                 ) {{\n        \
-                    c_nft::mint_regulated_nft_data<{}, c_nft::Data>(\n            \
+                    c_nft::prepare_launchpad_mint<{witness}, {market_type}, c_nft::Data>(\n            \
                         name,\n            \
                         description,\n            \
                         url,\n            \
                         attribute_keys,\n            \
                         attribute_values,\n            \
                         max_supply,\n            \
                         mint,\n            \
+                        sale_outlet,\n            \
+                        launchpad,\n            \
                         ctx,\n        \
                     );\n    \
                 }}",
-                witness, witness
+                witness = witness,
+                market_type = market_type,
             ),
         };
         func.into_boxed_str()

gutenberg/templates/template.move

@@ -3,9 +3,7 @@ module nft_protocol::{module_name} {{
 
     use sui::tx_context::{{Self, TxContext}};
 
-    use nft_protocol::collection::{{MintAuthority}};
     use nft_protocol::{market_module}{market_module_imports};
-    use nft_protocol::std_collection;
     use nft_protocol::{nft_type};
 {slingshot_import}
 
@@ -19,7 +17,7 @@ module nft_protocol::{module_name} {{
             b"{symbol}", // symbol
             {max_supply}, // max_supply
             @{receiver}, // Royalty receiver
-            tags, // tags
+            tags,
             {royalty_fee_bps}, // royalty_fee_bps
             {is_mutable}, // is_mutable
             b"{extra_data}",

sources/collection/collection.move

@@ -22,7 +22,6 @@
 //! frozen, in order to give creators the ability to ammend it prior to
 //! the primary sale taking place.
 //!
-//! TODO: Consider adding a function `destroy_unregulated`?
 //! TODO: Consider adding a struct object Collection Proof
 //! TODO: Verify creator in function to add creator, and function to post verify
 //! TODO: Split field `is_mutable` to `is_mutable` and `frozen` such that
@@ -121,7 +120,7 @@ module nft_protocol::collection {
 
 
     /// Initialises a `MintAuthority` and transfers it to `authority` and
-    /// initialized `Collection` object and returns it. The `MintAuthority`
+    /// initializes a `Collection` object and returns it. The `MintAuthority`
     /// object gives power to the owner to mint objects. There is only one
     /// `MintAuthority` per `Collection`. The Mint Authority object contains a
     /// `SupplyPolicy` which can be regulated or unregulated.
@@ -189,52 +188,20 @@ module nft_protocol::collection {
         }
     }
 
-    // TODO: Requires fixing
-    // /// Burn a Collection with regulated supply object and
-    // /// returns the Metadata object
-    // public entry fun burn_regulated<T, M: store>(
-    //     collection: Collection<T, M>,
-    //     mint: MintAuthority<T>,
-    // ): M {
-    //     assert!(
-    //         supply::current(supply_policy::supply(&mint.supply_policy)) == 0,
-    //         err::supply_is_not_zero()
-    //     );
-
-    //     let MintAuthority {
-    //         id,
-    //         collection_id: _,
-    //         supply_policy,
-    //     } = mint;
-
-    //     object::delete(id);
-
-    //     event::emit(
-    //         BurnEvent {
-    //             collection_id: id(&collection),
-    //         }
-    //     );
-
-    //     let Collection {
-    //         id,
-    //         name: _,
-    //         description: _,
-    //         symbol: _,
-    //         receiver: _,
-    //         tags: _,
-    //         is_mutable: _,
-    //         royalty_fee_bps: _,
-    //         creators: _,
-    //         mint_authority: _,
-    //         metadata,
-    //     } = collection;
-
-    //     supply_policy::destroy_regulated(supply_policy);
-
-    //     object::delete(id);
-
-    //     metadata
-    // }
+    /// Shares the `MintAuthority` object of a given `Collection`. For NFT
+    /// collections that require users to be the ones to mint the data, one
+    /// requires the `MintAuthority` to be shared, such that they can access the
+    /// nft mint functions.
+    ///
+    /// An example of this could be a Domain Name Service protocol, which
+    /// relies on users calling the nft mint function themselses and therefore
+    /// minting their domain name.
+    public fun share_authority<T, M: store>(
+        authority: MintAuthority<T>,
+        _collection: &Collection<T, M>,
+    ) {
+        transfer::share_object(authority);
+    }
 
     /// Make Collections immutable
     /// WARNING: this is irreversible, use with care
@@ -537,8 +504,8 @@ module nft_protocol::collection {
     /// Get the Collections's `tags`
     public fun tags<T, M: store>(
         collection: &Collection<T, M>,
-    ): Tags {
-        collection.tags
+    ): &Tags {
+        &collection.tags
     }
 
     /// Get the Collection's `is_mutable`
@@ -558,8 +525,8 @@ module nft_protocol::collection {
     /// Get the Collection's `creators`
     public fun creators<T, M: store>(
         collection: &Collection<T, M>,
-    ): vector<Creator> {
-        collection.creators
+    ): &vector<Creator> {
+        &collection.creators
     }
 
     /// Get an immutable reference to Collections's `cap`
@@ -602,6 +569,24 @@ module nft_protocol::collection {
         mint.collection_id
     }
 
+    // === Utility Function ===
+
+    public fun is_creator(
+        who: address,
+        creators: &vector<Creator>,
+    ): bool {
+        let i = 0;
+        while (i < vector::length(creators)) {
+            let creator = vector::borrow(creators, i);
+            if (creator.creator_address == who) {
+                return true
+            };
+            i = i + 1;
+        };
+
+        false
+    }
+
     // === Private Functions ===
 
     fun create_mint_authority<T>(