Safe + whitelisting

sources/examples/suimarines.move

@@ -43,7 +43,7 @@ module nft_protocol::suimarines {
         );
     }
 
-    public entry fun mint_nft(
+    public entry fun mint_nft_data(
         name: vector<u8>,
         description: vector<u8>,
         url: vector<u8>,
@@ -54,15 +54,13 @@ module nft_protocol::suimarines {
         launchpad: &mut Slingshot<SUIMARINES, FixedPriceMarket>,
         ctx: &mut TxContext,
     ) {
-        unique_nft::mint_regulated_nft(
+        unique_nft::mint_regulated_nft_data(
             name,
             description,
             url,
             attribute_keys,
             attribute_values,
             mint_authority,
-            sale_index,
-            launchpad,
             ctx,
         );
     }

sources/launchpad/market/fixed_price.move

@@ -159,6 +159,7 @@ module nft_protocol::fixed_price {
         let launchpad_id = slingshot::id(slingshot);
 
         let receiver = slingshot::receiver(slingshot);
+        let collection_id = slingshot::collection_id(slingshot);
         let sale = slingshot::sale_mut(slingshot, tier_index);
 
         // Infer that sales is NOT whitelisted
@@ -179,7 +180,12 @@ module nft_protocol::fixed_price {
             ctx
         );
 
-        let certificate = sale::issue_nft_certificate(sale, launchpad_id, ctx);
+        let certificate = sale::issue_nft_certificate(
+            sale,
+            launchpad_id,
+            collection_id,
+            ctx
+        );
 
         transfer::transfer(
             certificate,
@@ -206,6 +212,7 @@ module nft_protocol::fixed_price {
         let launchpad_id = slingshot::id(slingshot);
 
         let receiver = slingshot::receiver(slingshot);
+        let collection_id = slingshot::collection_id(slingshot);
         let sale = slingshot::sale_mut(slingshot, tier_index);
 
         // Infer that sales is whitelisted
@@ -234,7 +241,12 @@ module nft_protocol::fixed_price {
 
         whitelist::burn_whitelist_token(whitelist_token);
 
-        let certificate = sale::issue_nft_certificate(sale, launchpad_id, ctx);
+        let certificate = sale::issue_nft_certificate(
+            sale,
+            launchpad_id,
+            collection_id,
+            ctx
+        );
 
         transfer::transfer(
             certificate,

sources/launchpad/sale.move

@@ -36,6 +36,7 @@ module nft_protocol::sale {
     struct NftCertificate has key, store {
         id: UID,
         launchpad_id: ID,
+        collection_id: ID,
         nft_id: ID,
     }
 
@@ -91,13 +92,15 @@ module nft_protocol::sale {
     public fun issue_nft_certificate<T, M>(
         sale: &mut Sale<T, M>,
         launchpad_id: ID,
+        collection_id: ID,
         ctx: &mut TxContext,
     ): NftCertificate {
         let nft_id = pop_nft(sale);
 
         let certificate = NftCertificate {
             id: object::new(ctx),
-            launchpad_id: launchpad_id,
+            launchpad_id,
+            collection_id,
             nft_id: nft_id,
         };
 
@@ -110,6 +113,7 @@ module nft_protocol::sale {
         let NftCertificate {
             id,
             launchpad_id: _,
+            collection_id: _,
             nft_id: _,
         } = certificate;
 
@@ -176,4 +180,10 @@ module nft_protocol::sale {
     ): bool {
         sale.whitelisted
     }
+
+    public fun collection_id(
+        certificate: &NftCertificate,
+    ): ID {
+        certificate.collection_id
+    }
 }

sources/launchpad/slingshot.move

@@ -13,7 +13,7 @@ module nft_protocol::slingshot {
     use sui::object::{Self, ID , UID};
     use sui::tx_context::{Self, TxContext};
 
-    use nft_protocol::nft::{Self, Nft};
+    use nft_protocol::nft;
     use nft_protocol::err;
     use nft_protocol::sale::{Self, Sale, NftCertificate};
 
@@ -126,20 +126,33 @@ module nft_protocol::slingshot {
     /// of the NFT. Since the slingshot is a shared object anyone can mention it
     /// in the function signature and therefore be able to mention its child
     /// objects as well, the NFTs owned by it.
-    public entry fun claim_nft_embedded<T, M: store, D: store>(
+    public entry fun claim_nft_embedded<T, M: store, D: key + store>(
         slingshot: &Slingshot<T, M>,
-        nft: Nft<T, D>,
+        // TODO: nft_data is a shared object, we should confirm that we can
+        // add it directly as a parameter since this transfers ownership to the
+        // function's scope
+        nft_data: D,
         certificate: NftCertificate,
         recipient: address,
+        ctx: &mut TxContext,
     ) {
         assert!(
-            nft::id(&nft) == sale::nft_id(&certificate),
+            object::id(&nft_data) == sale::nft_id(&certificate),
             err::certificate_does_not_correspond_to_nft_given()
         );
 
+        assert!(is_embedded(slingshot), err::nft_not_embedded());
+
+        let nft = nft::mint_nft_loose<T, D>(
+            object::id(&nft_data),
+            recipient,
+            sale::collection_id(&certificate),
+            ctx,
+        );
+
         sale::burn_certificate(certificate);
 
-        assert!(is_embedded(slingshot), err::nft_not_embedded());
+        nft::join_nft_data(&mut nft, nft_data);
 
         transfer::transfer(
             nft,
@@ -168,18 +181,20 @@ module nft_protocol::slingshot {
             err::certificate_does_not_correspond_to_nft_given()
         );
 
-        sale::burn_certificate(certificate);
-
         assert!(!is_embedded(slingshot), err::nft_not_loose());
 
         // We are currently not increasing the current supply of the NFT
         // being minted (both collectibles and cNFT implementation have a concept
         // of supply).
         let nft = nft::mint_nft_loose<T, D>(
             object::id(nft_data),
+            recipient,
+            sale::collection_id(&certificate),
             ctx,
         );
 
+        sale::burn_certificate(certificate);
+
         transfer::transfer(
             nft,
             recipient,
@@ -228,6 +243,13 @@ module nft_protocol::slingshot {
         object::uid_as_inner(&slingshot.id)
     }
 
+    /// Get the Slingshot's `collection_id`
+    public fun collection_id<T, M>(
+        slingshot: &Slingshot<T, M>,
+    ): ID {
+        slingshot.collection_id
+    }
+
     /// Get the Slingshot's `live`
     public fun live<T, M>(
         slingshot: &Slingshot<T, M>,

sources/nft/nft.move

@@ -26,13 +26,17 @@ module nft_protocol::nft {
 
     use sui::event;
     use sui::object::{Self, UID, ID};
-    use sui::tx_context::{TxContext};
+    use sui::tx_context::{Self, TxContext};
+    use sui::transfer;
 
     use nft_protocol::err;
+    use nft_protocol::transfer_whitelist::{Self, Whitelist};
 
     // NFT object with an option to hold `D`ata object
-    struct Nft<phantom T, D: store> has key, store {
+    struct Nft<phantom T, D: store> has key {
         id: UID,
+        logical_owner: address,
+        collection: ID,
         data_id: ID,
         data: Option<D>,
     }
@@ -50,6 +54,8 @@ module nft_protocol::nft {
     /// Create a loose `Nft` and returns it.
     public fun mint_nft_loose<T, D: store>(
         data_id: ID,
+        logical_owner: address,
+        collection: ID,
         ctx: &mut TxContext,
     ): Nft<T, D> {
         let nft_id = object::new(ctx);
@@ -63,6 +69,8 @@ module nft_protocol::nft {
 
         Nft {
             id: nft_id,
+            logical_owner,
+            collection,
             data_id: data_id,
             data: option::none(),
         }
@@ -71,6 +79,8 @@ module nft_protocol::nft {
     /// Create a embeded `Nft` and returns it.
     public fun mint_nft_embedded<T, D: store>(
         data_id: ID,
+        logical_owner: address,
+        collection: ID,
         data: D,
         ctx: &mut TxContext,
     ): Nft<T, D> {
@@ -85,6 +95,8 @@ module nft_protocol::nft {
 
         Nft {
             id: nft_id,
+            logical_owner,
+            collection,
             data_id: data_id,
             data: option::some(data),
         }
@@ -121,6 +133,8 @@ module nft_protocol::nft {
 
         let Nft {
             id,
+            logical_owner: _,
+            collection: _,
             data_id: _,
             data,
         } = nft;
@@ -144,6 +158,8 @@ module nft_protocol::nft {
 
         let Nft {
             id,
+            logical_owner: _,
+            collection: _,
             data_id: _,
             data,
         } = nft;
@@ -159,6 +175,60 @@ module nft_protocol::nft {
         option::is_none(&nft.data)
     }
 
+    // === Transfer Functions ===
+
+    public fun transfer<T, D: store, W>(
+        nft: Nft<T, D>,
+        target: address,
+        authority: &UID,
+        whitelist: &Whitelist<W>,
+    ) {
+        let is_ok = transfer_whitelist::can_be_transferred(
+            &nft.collection,
+            object::uid_as_inner(authority),
+            whitelist,
+        );
+        assert!(is_ok, err::authority_not_whitelisted());
+
+        transfer::transfer(nft, target);
+    }
+
+    public fun transfer_to_owner<T, D: store>(nft: Nft<T, D>) {
+        let logical_owner = nft.logical_owner;
+        transfer::transfer(nft, logical_owner);
+    }
+
+    public fun transfer_to_object<T, D: store, Target, W>(
+        nft: Nft<T, D>,
+        target: &mut Target,
+        authority: &UID,
+        whitelist: &Whitelist<W>,
+    ) {
+        let is_ok = transfer_whitelist::can_be_transferred(
+            &nft.collection,
+            object::uid_as_inner(authority),
+            whitelist,
+        );
+        assert!(is_ok, err::authority_not_whitelisted());
+
+        // TODO: move to given target
+        abort(0);
+    }
+
+    public fun priviledged_transfer_to_object<T, D: store, Target>(
+        nft: Nft<T, D>,
+        target: &mut Target,
+        ctx: &mut TxContext,
+    ) {
+        assert!(
+            nft.logical_owner == tx_context::sender(ctx),
+            err::not_nft_owner(),
+        );
+
+        // TODO: move to given target
+        abort(0);
+    }
+
     // === Getter Functions  ===
 
     public fun id<T, D: store>(

sources/nft/nfts/c_nft.move

@@ -300,6 +300,8 @@ module nft_protocol::c_nft {
 
         let nft = nft::mint_nft_loose<T, Data>(
             nft_data_id(nft_data),
+            recipient,
+            nft_data.collection_id,
             ctx,
         );
 
@@ -360,6 +362,8 @@ module nft_protocol::c_nft {
 
         let nft = nft::mint_nft_loose<T, Data>(
             object::uid_to_inner(&combo_data.id),
+            recipient,
+            combo_data.collection_id,
             ctx,
         );
 
@@ -389,15 +393,15 @@ module nft_protocol::c_nft {
     /// objects when we merge them, therefore we maintain consistency.
     public entry fun split_c_nft<T, MetaColl: store, C: store + copy>(
         nft: Nft<T, Composable<C>>,
-        c_nft_data: &mut Composable<C>,
+        combo_data: &mut Composable<C>,
         nfts_data: vector<Composable<C>>,
         ctx: &mut TxContext,
     ) {
         // Assert that nft pointer corresponds to c_nft_data
         // If so, then burn pointer and mint pointer for each nfts_data
-        assert!(nft::data_id(&nft) == id(c_nft_data), err::nft_data_mismatch());
+        assert!(nft::data_id(&nft) == id(combo_data), err::nft_data_mismatch());
 
-        supply::decrement_supply(&mut c_nft_data.supply, 1);
+        supply::decrement_supply(&mut combo_data.supply, 1);
         nft::burn_loose_nft(nft);
 
         let len = vector::length(&nfts_data);
@@ -407,6 +411,8 @@ module nft_protocol::c_nft {
 
             let nft = nft::mint_nft_loose<T, Composable<C>>(
                 id(&data),
+                tx_context::sender(ctx),
+                combo_data.collection_id,
                 ctx,
             );
 

sources/nft/nfts/collectible.move

@@ -164,6 +164,8 @@ module nft_protocol::collectible {
 
         let nft = nft::mint_nft_loose<T, Collectible>(
             nft_data_id(nft_data),
+            recipient,
+            nft_data.collection_id,
             ctx,
         );