`a6efdbed0a1f`

3 files changed

modifiedpallets/nft/src/eth/mod.rsdiff before after both

117			let recipient = T::CrossAccountId::from_eth(recipient);117			let recipient = T::CrossAccountId::from_eth(recipient);
118118
119			<Module<T>>::transfer_internal(119			<Module<T>>::transfer_internal(
120				sender,120				&sender,
121				recipient,121				&recipient,
122				&collection,122				&collection,
123				1,123				1,
124				amount,124				amount,
143			let spender = T::CrossAccountId::from_eth(spender);143			let spender = T::CrossAccountId::from_eth(spender);
144144
145			<Module<T>>::approve_internal(145			<Module<T>>::approve_internal(
146				sender,146				&sender,
147				spender,147				&spender,
148				&collection,148				&collection,
149				1,149				1,
150				amount,150				amount,
160			let token_id = token_id.try_into().map_err(|_| "bad token id")?;160			let token_id = token_id.try_into().map_err(|_| "bad token id")?;
161161
162			<Module<T>>::approve_internal(162			<Module<T>>::approve_internal(
163				sender,163				&sender,
164				approved,164				&approved,
165				&collection,165				&collection,
166				token_id,166				token_id,
167				1,167				1,
176			let recipient = T::CrossAccountId::from_eth(recipient);176			let recipient = T::CrossAccountId::from_eth(recipient);
177177
178			<Module<T>>::transfer_from_internal(178			<Module<T>>::transfer_from_internal(
179				sender,179				&sender,
180				from,180				&from,
181				recipient,181				&recipient,
182				&collection,182				&collection,
183				1,183				1,
184				amount,184				amount,
195			let token_id = token_id.try_into().map_err(|_| "bad token id")?;195			let token_id = token_id.try_into().map_err(|_| "bad token id")?;
196196
197			<Module<T>>::transfer_from_internal(197			<Module<T>>::transfer_from_internal(
198				sender,198				&sender,
199				from,199				&from,
200				recipient,200				&recipient,
201				&collection,201				&collection,
202				token_id,202				token_id,
203				1,203				1,

modifiedpallets/nft/src/lib.rsdiff before after both

871            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);871            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
872            let collection = Self::get_collection(collection_id)?;872            let collection = Self::get_collection(collection_id)?;
873
873            Self::check_owner_or_admin_permissions(&collection, &sender)?;874            Self::toggle_white_list_internal(
874875                &sender,
876                &collection,
875            <WhiteList<T>>::insert(collection_id, address.as_sub(), true);877                &address,
876            878                true,
879            )?;
880
877            Ok(())881            Ok(())
878        }882        }
896            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
897            let collection = Self::get_collection(collection_id)?;901            let collection = Self::get_collection(collection_id)?;
902
898            Self::check_owner_or_admin_permissions(&collection, &sender)?;903            Self::toggle_white_list_internal(
899904                &sender,
900            <WhiteList<T>>::remove(collection_id, address.as_sub());905                &collection,
906                &address,
907                false,
908            )?;
901909
902            Ok(())910            Ok(())
1140
1141            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1148            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1142
1143            let target_collection = Self::get_collection(collection_id)?;1149            let collection = Self::get_collection(collection_id)?;
11441150
1145            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1151            Self::create_item_internal(&sender, &collection, &owner, data);
1146            Self::validate_create_item_args(&target_collection, &data)?;
1147            Self::create_item_no_validation(&target_collection, owner, data)?;
11481152
1149            Self::submit_logs(target_collection)?;1153            Self::submit_logs(collection)?;
1150            Ok(())1154            Ok(())
1151        }1155        }
11521156
1178            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1182            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1179            let collection = Self::get_collection(collection_id)?;1183            let collection = Self::get_collection(collection_id)?;
11801184
1181            Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;1185            Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;
11821186
1183            Self::submit_logs(collection)?;1187            Self::submit_logs(collection)?;
1184            Ok(())1188            Ok(())
1239            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1243            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1240            let collection = Self::get_collection(collection_id)?;1244            let collection = Self::get_collection(collection_id)?;
12411245
1242            Self::transfer_internal(sender, recipient, &collection, item_id, value)?;1246            Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;
12431247
1244            Self::submit_logs(collection)?;1248            Self::submit_logs(collection)?;
1245            Ok(())1249            Ok(())
1267            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1270            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1268            let collection = Self::get_collection(collection_id)?;1271            let collection = Self::get_collection(collection_id)?;
12691272
1270            Self::approve_internal(sender, spender, &collection, item_id, amount)?;1273            Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;
12711274
1272            Self::submit_logs(collection)?;1275            Self::submit_logs(collection)?;
1273            Ok(())1276            Ok(())
1299            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1301            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1300            let collection = Self::get_collection(collection_id)?;1302            let collection = Self::get_collection(collection_id)?;
13011303
1302            Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;1304            Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;
13031305
1304            Self::submit_logs(collection)?;1306            Self::submit_logs(collection)?;
1305            Ok(())1307            Ok(())
1306        }1308        }
1307
1308        // #[weight = 0]1309        // #[weight = 0]
1309        // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {
1310
1311        //     // let no_perm_mes = "You do not have permissions to modify this collection";1310        //     // let no_perm_mes = "You do not have permissions to modify this collection";
1312        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1311        //     // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);
1342        ) -> DispatchResult {1341        ) -> DispatchResult {
1343            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1342            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1344            1343            
1345            let target_collection = Self::get_collection(collection_id)?;1344            let collection = Self::get_collection(collection_id)?;
1345
1346            Self::set_variable_meta_data_internal(sender, &target_collection, item_id, data)?;1346            Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;
13471347
1348            Ok(())1348            Ok(())
1349        }1349        }
1679}1679}
16801680
1681impl<T: Config> Module<T> {1681impl<T: Config> Module<T> {
1682    pub fn create_item_internal(sender: &T::CrossAccountId, collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {
1683        Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;
1684        Self::validate_create_item_args(&collection, &data)?;
1685        Self::create_item_no_validation(&collection, owner, data)?;
1686
1687        Ok(())
1688    }
16821689
1683    pub fn transfer_internal(sender: T::CrossAccountId, recipient: T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1690    pub fn transfer_internal(sender: &T::CrossAccountId, recipient: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {
1684        // Limits check1691        // Limits check
1685        Self::is_correct_transfer(target_collection, &recipient)?;1692        Self::is_correct_transfer(target_collection, &recipient)?;
16861693
1702            _ => ()1709            _ => ()
1703        };1710        };
17041711
1705        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));1712        Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender.clone(), recipient.clone(), value));
17061713
1707        Ok(())1714        Ok(())
1708    }1715    }
17091716
1710	pub fn approve_internal(1717	pub fn approve_internal(
1711		sender: T::CrossAccountId,1718		sender: &T::CrossAccountId,
1712		spender: T::CrossAccountId,1719		spender: &T::CrossAccountId,
1713		collection: &CollectionHandle<T>,1720		collection: &CollectionHandle<T>,
1714		item_id: TokenId,1721		item_id: TokenId,
1715		amount: u1281722		amount: u128
1772			);1779			);
1773		}1780		}
17741781
1775		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1782		Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender.clone(), spender.clone(), allowance));
1776		Ok(())1783		Ok(())
1777	}1784	}
17781785
1779	pub fn transfer_from_internal(1786	pub fn transfer_from_internal(
1780		sender: T::CrossAccountId,1787		sender: &T::CrossAccountId,
1781		from: T::CrossAccountId,1788		from: &T::CrossAccountId,
1782		recipient: T::CrossAccountId,1789		recipient: &T::CrossAccountId,
1783		collection: &CollectionHandle<T>,1790		collection: &CollectionHandle<T>,
1784		item_id: TokenId,1791		item_id: TokenId,
1785		amount: u128,1792		amount: u128,
1841	}1848	}
18421849
1843    pub fn set_variable_meta_data_internal(1850    pub fn set_variable_meta_data_internal(
1844        sender: T::CrossAccountId,1851        sender: &T::CrossAccountId,
1845        collection: &CollectionHandle<T>, 1852        collection: &CollectionHandle<T>, 
1846        item_id: TokenId,1853        item_id: TokenId,
1847        data: Vec<u8>,1854        data: Vec<u8>,
1867    }1874    }
18681875
1869    pub fn create_multiple_items_internal(1876    pub fn create_multiple_items_internal(
1870        sender: T::CrossAccountId,1877        sender: &T::CrossAccountId,
1871        collection: &CollectionHandle<T>,1878        collection: &CollectionHandle<T>,
1872        owner: T::CrossAccountId,1879        owner: &T::CrossAccountId,
1873        items_data: Vec<CreateItemData>,1880        items_data: Vec<CreateItemData>,
1874    ) -> DispatchResult {1881    ) -> DispatchResult {
1875        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;1882        Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;
1878            Self::validate_create_item_args(&collection, data)?;1885            Self::validate_create_item_args(&collection, data)?;
1879        }1886        }
1880        for data in &items_data {1887        for data in &items_data {
1881            Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1888            Self::create_item_no_validation(&collection, owner, data.clone())?;
1882        }1889        }
18831890
1884        Ok(())1891        Ok(())
1914        Ok(())1921        Ok(())
1915    }1922    }
1923
1924    pub fn toggle_white_list_internal(
1925        sender: &T::CrossAccountId,
1926        collection: &CollectionHandle<T>,
1927        address: &T::CrossAccountId,
1928        whitelisted: bool,
1929    ) -> DispatchResult {
1930        Self::check_owner_or_admin_permissions(&collection, &sender)?;
1931
1932        if whitelisted {
1933            <WhiteList<T>>::insert(collection.id, address.as_sub(), true);
1934        } else {
1935            <WhiteList<T>>::remove(collection.id, address.as_sub());
1936        }
1937
1938        Ok(())
1939    }
19161940
1917    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1941    fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {
1918        let collection_id = collection.id;1942        let collection_id = collection.id;
1984        Ok(())2008        Ok(())
1985    }2009    }
19862010
1987    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {2011    fn create_item_no_validation(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {
1988        match data2012        match data
1989        {2013        {
1990            CreateItemData::NFT(data) => {2014            CreateItemData::NFT(data) => {

modifiedruntime/src/chain_extension.rsdiff before after both

1717
18extern crate pallet_nft;18extern crate pallet_nft;
19pub use pallet_nft::*;19pub use pallet_nft::*;
20use crate::Runtime;20use pallet_nft::CrossAccountId;
21use sp_runtime::AccountId32;
22use crate::Vec;21use crate::Vec;
22
23/// Create item parameters
24#[derive(Debug, PartialEq, Encode, Decode)]
25pub struct NFTExtCreateItem<E: Ext> {
26    pub owner: <E::T as SysConfig>::AccountId,
27    pub collection_id: u32,
28    pub data: CreateItemData,
29}
2330
24/// Transfer parameters31/// Transfer parameters
25#[derive(Debug, PartialEq, Encode, Decode)]32#[derive(Debug, PartialEq, Encode, Decode)]
30    pub amount: u128,37    pub amount: u128,
31}38}
39
40#[derive(Debug, PartialEq, Encode, Decode)]
41pub struct NFTExtCreateMultipleItems<E: Ext> {
42    pub owner: <E::T as SysConfig>::AccountId,
43    pub collection_id: u32,
44    pub data: Vec<CreateItemData>,
45}
46
47#[derive(Debug, PartialEq, Encode, Decode)]
48pub struct NFTExtApprove<E: Ext> {
49    pub spender: <E::T as SysConfig>::AccountId,
50    pub collection_id: u32,
51    pub item_id: u32,
52    pub amount: u128,
53}
54
55#[derive(Debug, PartialEq, Encode, Decode)]
56pub struct NFTExtTransferFrom<E: Ext> {
57    pub owner: <E::T as SysConfig>::AccountId,
58    pub recipient: <E::T as SysConfig>::AccountId,
59    pub collection_id: u32,
60    pub item_id: u32,
61    pub amount: u128,
62}
63
64#[derive(Debug, PartialEq, Encode, Decode)]
65pub struct NFTExtSetVariableMetaData {
66    pub collection_id: u32,
67    pub item_id: u32,
68    pub data: Vec<u8>,   
69}
70
71#[derive(Debug, PartialEq, Encode, Decode)]
72pub struct NFTExtToggleWhiteList<E: Ext> {
73    pub collection_id: u32,
74    pub address: <E::T as SysConfig>::AccountId,
75    pub whitelisted: bool,
76}
3277
33/// The chain Extension of NFT pallet78/// The chain Extension of NFT pallet
34pub struct NFTExtension;79pub struct NFTExtension;
3580
36impl<C: Config> ChainExtension<C> for NFTExtension {81impl<C: Config> ChainExtension<C> for NFTExtension {
37    fn call<E: Ext>(func_id: u32, env: Environment<E, InitState>) -> Result<RetVal, DispatchError>82    fn call<E: Ext>(func_id: u32, env: Environment<E, InitState>) -> Result<RetVal, DispatchError>
38    where83    where
84        E: Ext<T = C>,
39        <E::T as SysConfig>::AccountId: UncheckedFrom<<E::T as SysConfig>::Hash> + AsRef<[u8]>,85        <E::T as SysConfig>::AccountId: UncheckedFrom<<E::T as SysConfig>::Hash> + AsRef<[u8]>,
40    {86    {
41        // The memory of the vm stores buf in scale-codec87        // The memory of the vm stores buf in scale-codec
44                let mut env = env.buf_in_buf_out();90                let mut env = env.buf_in_buf_out();
45                let input: NFTExtTransfer<E> = env.read_as()?;91                let input: NFTExtTransfer<E> = env.read_as()?;
46
47                // Sender to AccountId32
48                let mut bytes_sender: [u8; 32] = [0; 32];
49                let addr_vec_sender: Vec<u8> = env.ext().caller().encode();
50                for i in 0..32 {
51                    bytes_sender[i] = addr_vec_sender[i];
52                }
53                let sender = AccountId32::from(bytes_sender);
54
55                // Recipient to AccountId32
56                let mut bytes_rec: [u8; 32] = [0; 32];
57                let addr_vec_rec: Vec<u8> = input.recipient.encode();
58                for i in 0..32 {
59                    bytes_rec[i] = addr_vec_rec[i];
60                }
61                let recipient = AccountId32::from(bytes_rec);
6292
63                let collection = pallet_nft::Module::<Runtime>::get_collection(input.collection_id)?;93                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
6494
65                match pallet_nft::Module::<Runtime>::transfer_internal(95                match pallet_nft::Module::<C>::transfer_internal(
66                    <Runtime as Config>::CrossAccountId::from_sub(sender),96                    &C::CrossAccountId::from_sub(env.ext().caller().clone()),
67                    <Runtime as Config>::CrossAccountId::from_sub(recipient),97                    &C::CrossAccountId::from_sub(input.recipient),
68                    &collection,98                    &collection,
69                    input.token_id,99                    input.token_id,
70                    input.amount,100                    input.amount,
73                    _ => Err(DispatchError::Other("Transfer error"))103                    _ => Err(DispatchError::Other("Transfer error"))
74                }104                }
75            },105            },
106            1 => {
107                // Create Item
108                let mut env = env.buf_in_buf_out();
109                let input: NFTExtCreateItem<E> = env.read_as()?;
110
111                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
112
113                match pallet_nft::Module::<C>::create_item_internal(
114                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
115                    &collection,
116                    &C::CrossAccountId::from_sub(input.owner),
117                    input.data,
118                ) {
119                    Ok(_) => Ok(RetVal::Converging(func_id)),
120                    _ => Err(DispatchError::Other("CreateItem error"))
121                }
122            },
123            2 => {
124                // Create multiple items
125                let mut env = env.buf_in_buf_out();
126                let input: NFTExtCreateMultipleItems<E> = env.read_as()?;
127
128                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
129
130                match pallet_nft::Module::<C>::create_multiple_items_internal(
131                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
132                    &collection,
133                    &C::CrossAccountId::from_sub(input.owner),
134                    input.data,
135                ) {
136                    Ok(_) => Ok(RetVal::Converging(func_id)),
137                    _ => Err(DispatchError::Other("CreateMultipleItems error"))
138                }
139            },
140            3 => {
141                // Approve
142                let mut env = env.buf_in_buf_out();
143                let input: NFTExtApprove<E> = env.read_as()?;
144
145                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
146
147                pallet_nft::Module::<C>::approve_internal(
148                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
149                    &C::CrossAccountId::from_sub(input.spender),
150                    &collection,
151                    input.item_id,
152                    input.amount,
153                )?;
154                Ok(RetVal::Converging(func_id))
155            },
156            4 => {
157                // Transfer from
158                let mut env = env.buf_in_buf_out();
159                let input: NFTExtTransferFrom<E> = env.read_as()?;
160
161                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
162
163                pallet_nft::Module::<C>::transfer_from_internal(
164                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
165                    &C::CrossAccountId::from_sub(input.owner),
166                    &C::CrossAccountId::from_sub(input.recipient),
167                    &collection,
168                    input.item_id,
169                    input.amount
170                )?;
171                Ok(RetVal::Converging(func_id))
172            },
173            5 => {
174                // Set variable metadata
175                let mut env = env.buf_in_buf_out();
176                let input: NFTExtSetVariableMetaData = env.read_as()?;
177
178                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
179
180                pallet_nft::Module::<C>::set_variable_meta_data_internal(
181                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
182                    &collection,
183                    input.item_id,
184                    input.data,
185                )?;
186                Ok(RetVal::Converging(func_id))
187            },
188            6 => {
189                // Toggle whitelist
190                let mut env = env.buf_in_buf_out();
191                let input: NFTExtToggleWhiteList<E> = env.read_as()?;
192
193                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
194
195                pallet_nft::Module::<C>::toggle_white_list_internal(
196                    &C::CrossAccountId::from_sub(env.ext().address().clone()),
197                    &collection,
198                    &C::CrossAccountId::from_sub(input.address),
199                    input.whitelisted,
200                )?;
201                Ok(RetVal::Converging(func_id))
202            }
76			_ => {203            _ => {
77				panic!("Passed unknown func_id to test chain extension: {}", func_id);204                panic!("Passed unknown func_id to test chain extension: {}", func_id);
78            }205            }