git.delta.rocks / unique-network / refs/commits / b8243dbd26e3

150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
151pub struct ApprovePermissions<AccountId> {151pub struct ApprovePermissions<AccountId> {
152    pub approved: AccountId,152    pub approved: AccountId,
153    pub amount: u64,153    pub amount: u128,
154}154}
155155
156#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]156#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
366        pub WhiteList get(fn white_list): map hasher(identity) CollectionId => Vec<T::AccountId>;366        pub WhiteList get(fn white_list): map hasher(identity) CollectionId => Vec<T::AccountId>;
367367
368        /// Balance owner per collection map368        /// Balance owner per collection map
369        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u64;369        pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;
370370
371        /// second parameter: item id + owner account id371        /// second parameter: item id + owner account id
372        pub ApprovedList get(fn approved): double_map hasher(identity) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;372        pub ApprovedList get(fn approved): double_map hasher(identity) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;
1019        ///     * Fungible Mode: Must specify transferred amount1019        ///     * Fungible Mode: Must specify transferred amount
1020        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1020        ///     * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)
1021        #[weight = T::WeightInfo::transfer()]1021        #[weight = T::WeightInfo::transfer()]
1022        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u64) -> DispatchResult {1022        pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {
10231023
1024            let sender = ensure_signed(origin)?;1024            let sender = ensure_signed(origin)?;
10251025
1119        /// 1119        /// 
1120        /// * value: Amount to transfer.1120        /// * value: Amount to transfer.
1121        #[weight = T::WeightInfo::transfer_from()]1121        #[weight = T::WeightInfo::transfer_from()]
1122        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u64 ) -> DispatchResult {1122        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {
11231123
1124            let sender = ensure_signed(origin)?;1124            let sender = ensure_signed(origin)?;
1125            let mut appoved_transfer = false;1125            let mut appoved_transfer = false;
1499            .ok_or(Error::<T>::NumOverflow)?;1499            .ok_or(Error::<T>::NumOverflow)?;
1500        let itemcopy = item.clone();1500        let itemcopy = item.clone();
1501        let owner = item.owner.clone();1501        let owner = item.owner.clone();
1502        let value = item.value as u64;
15031502
1504        Self::add_token_index(item.collection, current_index, owner.clone())?;1503        Self::add_token_index(item.collection, current_index, owner.clone())?;
15051504
1512        1511        
1513        // Update balance1512        // Update balance
1514        let new_balance = <Balance<T>>::get(item.collection, owner.clone())1513        let new_balance = <Balance<T>>::get(item.collection, owner.clone())
1515            .checked_add(value)1514            .checked_add(item.value)
1516            .ok_or(Error::<T>::NumOverflow)?;1515            .ok_or(Error::<T>::NumOverflow)?;
1517        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1516        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
15181517
1525            .ok_or(Error::<T>::NumOverflow)?;1524            .ok_or(Error::<T>::NumOverflow)?;
1526        let itemcopy = item.clone();1525        let itemcopy = item.clone();
15271526
1528        let value = item.owner.first().unwrap().fraction as u64;1527        let value = item.owner.first().unwrap().fraction;
1529        let owner = item.owner.first().unwrap().owner.clone();1528        let owner = item.owner.first().unwrap().owner.clone();
15301529
1531        Self::add_token_index(item.collection, current_index, owner.clone())?;1530        Self::add_token_index(item.collection, current_index, owner.clone())?;
15941593
1595        // update balance1594        // update balance
1596        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1595        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())
1597            .checked_sub(item.fraction as u64)1596            .checked_sub(item.fraction)
1598            .ok_or(Error::<T>::NumOverflow)?;1597            .ok_or(Error::<T>::NumOverflow)?;
1599        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1598        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);
16001599
16371636
1638        // update balance1637        // update balance
1639        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1638        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())
1640            .checked_sub(item.value as u64)1639            .checked_sub(item.value)
1641            .ok_or(Error::<T>::NumOverflow)?;1640            .ok_or(Error::<T>::NumOverflow)?;
1642        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1641        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);
16431642
1726    fn transfer_fungible(1725    fn transfer_fungible(
1727        collection_id: CollectionId,1726        collection_id: CollectionId,
1728        item_id: TokenId,1727        item_id: TokenId,
1729        value: u64,1728        value: u128,
1730        owner: T::AccountId,1729        owner: T::AccountId,
1731        new_owner: T::AccountId,1730        new_owner: T::AccountId,
1732    ) -> DispatchResult {1731    ) -> DispatchResult {
1738        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1737        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);
1739        let amount = full_item.value;1738        let amount = full_item.value;
17401739
1741        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);1740        ensure!(amount >= value, Error::<T>::TokenValueTooLow);
17421741
1743        // update balance1742        // update balance
1744        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1743        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())
1752            new_owner_account_id = new_owner_items[0];1751            new_owner_account_id = new_owner_items[0];
1753        }1752        }
1754
1755        let val64 = value.into();
17561753
1757        // transfer1754        // transfer
1758        if amount == val64 && new_owner_account_id == 0 {1755        if amount == value && new_owner_account_id == 0 {
1759            // change owner1756            // change owner
1760            // new owner do not have account1757            // new owner do not have account
1761            let mut new_full_item = full_item.clone();1758            let mut new_full_item = full_item.clone();
1772            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1769            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;
1773        } else {1770        } else {
1774            let mut new_full_item = full_item.clone();1771            let mut new_full_item = full_item.clone();
1775            new_full_item.value -= val64;1772            new_full_item.value -= value;
17761773
1777            // separate amount1774            // separate amount
1778            if new_owner_account_id > 0 {1775            if new_owner_account_id > 0 {
1779                // new owner has account1776                // new owner has account
1780                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1777                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);
1781                item.value += val64;1778                item.value += value;
17821779
1783                // update balance1780                // update balance
1784                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1781                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())
1792                let item = FungibleItemType {1789                let item = FungibleItemType {
1793                    collection: collection_id,1790                    collection: collection_id,
1794                    owner: new_owner.clone(),1791                    owner: new_owner.clone(),
1795                    value: val64,1792                    value
1796                };1793                };
17971794
1798                Self::add_fungible_item(item)?;1795                Self::add_fungible_item(item)?;
1799            }1796            }
18001797
1801            if amount == val64 {1798            if amount == value {
1802                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;1799                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;
18031800
1804                // remove approve list1801                // remove approve list
1815    fn transfer_refungible(1812    fn transfer_refungible(
1816        collection_id: CollectionId,1813        collection_id: CollectionId,
1817        item_id: TokenId,1814        item_id: TokenId,
1818        value: u64,1815        value: u128,
1819        owner: T::AccountId,1816        owner: T::AccountId,
1820        new_owner: T::AccountId,1817        new_owner: T::AccountId,
1821    ) -> DispatchResult {1818    ) -> DispatchResult {
1833            .ok_or(Error::<T>::NumOverflow)?;1830            .ok_or(Error::<T>::NumOverflow)?;
1834        let amount = item.fraction;1831        let amount = item.fraction;
18351832
1836        ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);1833        ensure!(amount >= value, Error::<T>::TokenValueTooLow);
18371834
1838        // update balance1835        // update balance
1839        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1836        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())
18481845
1849        let old_owner = item.owner.clone();1846        let old_owner = item.owner.clone();
1850        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1847        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);
1851        let val64 = value.into();
18521848
1853        // transfer1849        // transfer
1854        if amount == val64 && !new_owner_has_account {1850        if amount == value && !new_owner_has_account {
1855            // change owner1851            // change owner
1856            // new owner do not have account1852            // new owner do not have account
1857            let mut new_full_item = full_item.clone();1853            let mut new_full_item = full_item.clone();
1872                .iter_mut()1868                .iter_mut()
1873                .find(|i| i.owner == owner)1869                .find(|i| i.owner == owner)
1874                .unwrap()1870                .unwrap()
1875                .fraction -= val64;1871                .fraction -= value;
18761872
1877            // separate amount1873            // separate amount
1878            if new_owner_has_account {1874            if new_owner_has_account {
1882                    .iter_mut()1878                    .iter_mut()
1883                    .find(|i| i.owner == new_owner)1879                    .find(|i| i.owner == new_owner)
1884                    .unwrap()1880                    .unwrap()
1885                    .fraction += val64;1881                    .fraction += value;
1886            } else {1882            } else {
1887                // new owner do not have account1883                // new owner do not have account
1888                new_full_item.owner.push(Ownership {1884                new_full_item.owner.push(Ownership {
1889                    owner: new_owner.clone(),1885                    owner: new_owner.clone(),
1890                    fraction: val64,1886                    fraction: value,
1891                });1887                });
1892                Self::add_token_index(collection_id, item_id, new_owner.clone())?;1888                Self::add_token_index(collection_id, item_id, new_owner.clone())?;
1893            }1889            }
2033            .checked_add(1)2029            .checked_add(1)
2034            .unwrap();2030            .unwrap();
2035        let owner = item.owner.clone();2031        let owner = item.owner.clone();
2036        let value = item.value as u64;
20372032
2038        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();2033        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();
20392034
2040        <ItemListIndex>::insert(item.collection, current_index);2035        <ItemListIndex>::insert(item.collection, current_index);
20412036
2042        // Update balance2037        // Update balance
2043        let new_balance = <Balance<T>>::get(item.collection, owner.clone())2038        let new_balance = <Balance<T>>::get(item.collection, owner.clone())
2044            .checked_add(value)2039            .checked_add(item.value)
2045            .unwrap();2040            .unwrap();
2046        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2041        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
2047    }2042    }
2051            .checked_add(1)2046            .checked_add(1)
2052            .unwrap();2047            .unwrap();
20532048
2054        let value = item.owner.first().unwrap().fraction as u64;2049        let value = item.owner.first().unwrap().fraction;
2055        let owner = item.owner.first().unwrap().owner.clone();2050        let owner = item.owner.first().unwrap().owner.clone();
20562051
2057        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();2052        Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();