@flowtyio/flow-contracts 0.0.10 → 0.0.14

package/contracts/lost-and-found/LostAndFoundHelper.cdc

@@ -0,0 +1,42 @@
+import "LostAndFound"
+
+pub contract LostAndFoundHelper {
+
+    pub struct Ticket {
+
+        // An optional message to attach to this item.
+        pub let memo: String?
+        // The address that it allowed to withdraw the item fromt this ticket
+        pub let redeemer: Address
+        //The type of the resource (non-optional) so that bins can represent the true type of an item
+        pub let type: Type
+        pub let typeIdentifier: String
+        // State maintained by LostAndFound
+        pub let redeemed: Bool
+        pub let name : String?
+        pub let description : String?
+        pub let thumbnail : String?
+        pub let ticketID : UInt64?
+
+        init(_ ticket: &LostAndFound.Ticket, id: UInt64?) {
+            self.memo = ticket.memo 
+            self.redeemer = ticket.redeemer 
+            self.type = ticket.type 
+            self.typeIdentifier = ticket.type.identifier
+            self.redeemed = ticket.redeemed 
+            self.name = ticket.display?.name
+            self.description = ticket.display?.description
+            self.thumbnail = ticket.display?.thumbnail?.uri()
+            self.ticketID = id
+        }
+
+    }
+
+    pub fun constructResult(_ ticket: &LostAndFound.Ticket?, id:UInt64?) : LostAndFoundHelper.Ticket? {
+        if ticket != nil {
+            return LostAndFoundHelper.Ticket(ticket!, id: id)
+        }
+        return nil
+    }
+
+}

package/contracts/nft-catalog/NFTCatalog.cdc

@@ -0,0 +1,422 @@
+import "MetadataViews"
+
+// NFTCatalog
+//
+// A general purpose NFT registry for Flow NonFungibleTokens.
+//
+// Each catalog entry stores data about the NFT including
+// its collection identifier, nft type, storage and public paths, etc.
+//
+// To make an addition to the catalog you can propose an NFT and provide its metadata.
+// An Admin can approve a proposal which would add the NFT to the catalog
+
+pub contract NFTCatalog {
+    // EntryAdded
+    // An NFT collection has been added to the catalog
+    pub event EntryAdded(
+        collectionIdentifier : String,
+        contractName : String,
+        contractAddress : Address,
+        nftType : Type,
+        storagePath: StoragePath,
+        publicPath: PublicPath,
+        privatePath: PrivatePath,
+        publicLinkedType : Type,
+        privateLinkedType : Type,
+        displayName : String,
+        description: String,
+        externalURL : String
+    )
+
+    // EntryUpdated
+    // An NFT Collection has been updated in the catalog
+    pub event EntryUpdated(
+        collectionIdentifier : String,
+        contractName : String,
+        contractAddress : Address,
+        nftType : Type,
+        storagePath: StoragePath,
+        publicPath: PublicPath,
+        privatePath: PrivatePath,
+        publicLinkedType : Type,
+        privateLinkedType : Type,
+        displayName : String,
+        description: String,
+        externalURL : String
+    )
+
+    // EntryRemoved
+    // An NFT Collection has been removed from the catalog
+    pub event EntryRemoved(collectionIdentifier : String, nftType: Type)
+
+    // ProposalEntryAdded
+    // A new proposal to make an addtion to the catalog has been made
+    pub event ProposalEntryAdded(proposalID : UInt64, collectionIdentifier : String, message: String, status: String, proposer : Address)
+
+    // ProposalEntryUpdated
+    // A proposal has been updated
+    pub event ProposalEntryUpdated(proposalID : UInt64, collectionIdentifier : String, message: String, status: String, proposer : Address)
+
+    // ProposalEntryRemoved
+    // A proposal has been removed from storage
+    pub event ProposalEntryRemoved(proposalID : UInt64)
+
+    pub let ProposalManagerStoragePath: StoragePath
+
+    pub let ProposalManagerPublicPath: PublicPath
+
+    access(self) let catalog: {String : NFTCatalog.NFTCatalogMetadata} // { collectionIdentifier -> Metadata }
+    access(self) let catalogTypeData: {String : {String : Bool}} // Additional view to go from { NFT Type Identifier -> {Collection Identifier : Bool } }
+
+    access(self) let catalogProposals : {UInt64 : NFTCatalogProposal} // { ProposalID : Metadata }
+
+    access(self) var totalProposals : UInt64
+
+    // NFTCatalogProposalManager
+    // Used to authenticate proposals made to the catalog
+
+    pub resource interface NFTCatalogProposalManagerPublic {
+        pub fun getCurrentProposalEntry(): String?
+    }
+    pub resource NFTCatalogProposalManager : NFTCatalogProposalManagerPublic {
+            access(self) var currentProposalEntry: String?
+
+            pub fun getCurrentProposalEntry(): String? {
+                return self.currentProposalEntry
+            }
+
+            pub fun setCurrentProposalEntry(identifier: String?) {
+                self.currentProposalEntry = identifier
+            }
+
+            init () {
+                self.currentProposalEntry = nil
+            }
+    }
+
+
+    pub resource Snapshot {
+        pub var catalogSnapshot: {String : NFTCatalogMetadata}
+        pub var shouldUseSnapshot: Bool
+
+        pub fun setPartialSnapshot(_ snapshotKey: String, _ snapshotEntry: NFTCatalogMetadata) {
+            self.catalogSnapshot[snapshotKey] = snapshotEntry
+        }
+
+        pub fun setShouldUseSnapshot(_ shouldUseSnapshot: Bool) {
+            self.shouldUseSnapshot = shouldUseSnapshot
+        }
+
+        pub fun getCatalogSnapshot(): {String : NFTCatalogMetadata} {
+            return self.catalogSnapshot
+        }
+
+        init() {
+            self.shouldUseSnapshot = false
+            self.catalogSnapshot = {}
+        }
+    }
+
+    pub fun createEmptySnapshot(): @Snapshot {
+        return <- create Snapshot()
+    }
+
+    // NFTCollectionData
+    // Represents information about an NFT collection resource
+    // Note: Not suing the struct from Metadata standard due to
+    // inability to store functions
+    pub struct NFTCollectionData {
+
+        pub let storagePath : StoragePath
+        pub let publicPath : PublicPath
+        pub let privatePath: PrivatePath
+        pub let publicLinkedType: Type
+        pub let privateLinkedType: Type
+
+        init(
+            storagePath : StoragePath,
+            publicPath : PublicPath,
+            privatePath : PrivatePath,
+            publicLinkedType : Type,
+            privateLinkedType : Type
+        ) {
+            self.storagePath = storagePath
+            self.publicPath = publicPath
+            self.privatePath = privatePath
+            self.publicLinkedType = publicLinkedType
+            self.privateLinkedType = privateLinkedType
+        }
+    }
+
+    // NFTCatalogMetadata
+    // Represents data about an NFT
+    pub struct NFTCatalogMetadata {
+        pub let contractName : String
+        pub let contractAddress : Address
+        pub let nftType: Type
+        pub let collectionData: NFTCollectionData
+        pub let collectionDisplay: MetadataViews.NFTCollectionDisplay
+
+        init (contractName : String, contractAddress : Address, nftType: Type, collectionData : NFTCollectionData, collectionDisplay : MetadataViews.NFTCollectionDisplay) {
+            self.contractName = contractName
+            self.contractAddress = contractAddress
+            self.nftType = nftType
+            self.collectionData = collectionData
+            self.collectionDisplay = collectionDisplay
+        }
+    }
+
+    // NFTCatalogProposal
+    // Represents a proposal to the catalog
+    // Includes data about an NFT
+    pub struct NFTCatalogProposal {
+        pub let collectionIdentifier : String
+        pub let metadata : NFTCatalogMetadata
+        pub let message : String
+        pub let status : String
+        pub let proposer : Address
+        pub let createdTime : UFix64
+
+        init(collectionIdentifier : String, metadata : NFTCatalogMetadata, message : String, status : String, proposer : Address) {
+            self.collectionIdentifier = collectionIdentifier
+            self.metadata = metadata
+            self.message = message
+            self.status = status
+            self.proposer = proposer
+            self.createdTime = getCurrentBlock().timestamp
+        }
+    }
+
+    /*
+        DEPRECATED
+        If obtaining all elements from the catalog is essential, please
+        use the getCatalogKeys and forEachCatalogKey methods instead.
+     */
+    pub fun getCatalog() : {String : NFTCatalogMetadata} {
+        let snapshot = self.account.borrow<&NFTCatalog.Snapshot>(from: /storage/CatalogSnapshot)
+        if snapshot != nil {
+            let snapshot = snapshot!
+            if snapshot.shouldUseSnapshot {
+                return snapshot.getCatalogSnapshot()
+            } else {
+                return self.catalog
+            }
+        } else {
+            return self.catalog
+        }
+    }
+
+    pub fun getCatalogKeys(): [String] {
+        return self.catalog.keys
+    }
+
+    pub fun forEachCatalogKey(_ function: ((String): Bool)) {
+        self.catalog.forEachKey(function)
+    }
+
+    pub fun getCatalogEntry(collectionIdentifier : String) : NFTCatalogMetadata? {
+        return self.catalog[collectionIdentifier]
+    }
+
+    pub fun getCollectionsForType(nftTypeIdentifier: String) : {String : Bool}? {
+        return self.catalogTypeData[nftTypeIdentifier]
+    }
+
+    pub fun getCatalogTypeData() : {String : {String : Bool}} {
+        return self.catalogTypeData
+    }
+
+    // Propose an NFT collection to the catalog
+    // @param collectionIdentifier: The unique name assinged to this nft collection
+    // @param metadata: The Metadata for the NFT collection that will be stored in the catalog
+    // @param message: A message to the catalog owners
+    // @param proposer: Who is making the proposition(the address needs to be verified)
+    pub fun proposeNFTMetadata(collectionIdentifier : String, metadata : NFTCatalogMetadata, message : String, proposer : Address) : UInt64 {
+        let proposerManagerCap = getAccount(proposer).getCapability<&NFTCatalogProposalManager{NFTCatalog.NFTCatalogProposalManagerPublic}>(NFTCatalog.ProposalManagerPublicPath)
+
+        assert(proposerManagerCap.check(), message : "Proposer needs to set up a manager")
+
+        let proposerManagerRef = proposerManagerCap.borrow()!
+
+        assert(proposerManagerRef.getCurrentProposalEntry()! == collectionIdentifier, message: "Expected proposal entry does not match entry for the proposer")
+
+        let catalogProposal = NFTCatalogProposal(collectionIdentifier : collectionIdentifier, metadata : metadata, message : message, status: "IN_REVIEW", proposer: proposer)
+        self.totalProposals = self.totalProposals + 1
+        self.catalogProposals[self.totalProposals] = catalogProposal
+
+        emit ProposalEntryAdded(proposalID : self.totalProposals, collectionIdentifier : collectionIdentifier, message: catalogProposal.message, status: catalogProposal.status, proposer: catalogProposal.proposer)
+        return self.totalProposals
+    }
+
+    // Withdraw a proposal from the catalog
+    // @param proposalID: The ID of proposal you want to withdraw
+    pub fun withdrawNFTProposal(proposalID : UInt64) {
+        pre {
+            self.catalogProposals[proposalID] != nil : "Invalid Proposal ID"
+        }
+        let proposal = self.catalogProposals[proposalID]!
+        let proposer = proposal.proposer
+
+        let proposerManagerCap = getAccount(proposer).getCapability<&NFTCatalogProposalManager{NFTCatalog.NFTCatalogProposalManagerPublic}>(NFTCatalog.ProposalManagerPublicPath)
+
+        assert(proposerManagerCap.check(), message : "Proposer needs to set up a manager")
+
+        let proposerManagerRef = proposerManagerCap.borrow()!
+
+        assert(proposerManagerRef.getCurrentProposalEntry()! == proposal.collectionIdentifier, message: "Expected proposal entry does not match entry for the proposer")
+
+        self.removeCatalogProposal(proposalID : proposalID)
+    }
+
+    pub fun getCatalogProposals() : {UInt64 : NFTCatalogProposal} {
+        return self.catalogProposals
+    }
+
+    pub fun getCatalogProposalEntry(proposalID : UInt64) : NFTCatalogProposal? {
+        return self.catalogProposals[proposalID]
+    }
+
+    pub fun getCatalogProposalKeys() : [UInt64] {
+        return self.catalogProposals.keys
+    }
+
+    pub fun forEachCatalogProposalKey(_ function: ((UInt64): Bool)) {
+        self.catalogProposals.forEachKey(function)
+    }
+
+    pub fun createNFTCatalogProposalManager(): @NFTCatalogProposalManager {
+        return <-create NFTCatalogProposalManager()
+    }
+
+    access(account) fun addCatalogEntry(collectionIdentifier : String, metadata: NFTCatalogMetadata) {
+        pre {
+            self.catalog[collectionIdentifier] == nil : "The nft name has already been added to the catalog"
+        }
+
+        self.addCatalogTypeEntry(collectionIdentifier : collectionIdentifier , metadata: metadata)
+
+        self.catalog[collectionIdentifier] = metadata
+
+        emit EntryAdded(
+            collectionIdentifier : collectionIdentifier,
+            contractName : metadata.contractName,
+            contractAddress : metadata.contractAddress,
+            nftType: metadata.nftType,
+            storagePath: metadata.collectionData.storagePath,
+            publicPath: metadata.collectionData.publicPath,
+            privatePath: metadata.collectionData.privatePath,
+            publicLinkedType : metadata.collectionData.publicLinkedType,
+            privateLinkedType : metadata.collectionData.privateLinkedType,
+            displayName : metadata.collectionDisplay.name,
+            description: metadata.collectionDisplay.description,
+            externalURL : metadata.collectionDisplay.externalURL.url
+        )
+    }
+
+    access(account) fun updateCatalogEntry(collectionIdentifier : String , metadata: NFTCatalogMetadata) {
+        pre {
+            self.catalog[collectionIdentifier] != nil : "Invalid collection identifier"
+        }
+        // remove previous nft type entry
+        self.removeCatalogTypeEntry(collectionIdentifier : collectionIdentifier , metadata: metadata)
+        // add updated nft type entry
+        self.addCatalogTypeEntry(collectionIdentifier : collectionIdentifier , metadata: metadata)
+
+        self.catalog[collectionIdentifier] = metadata
+
+        let nftType = metadata.nftType
+
+        emit EntryUpdated(
+            collectionIdentifier : collectionIdentifier,
+            contractName : metadata.contractName,
+            contractAddress : metadata.contractAddress,
+            nftType: metadata.nftType,
+            storagePath: metadata.collectionData.storagePath,
+            publicPath: metadata.collectionData.publicPath,
+            privatePath: metadata.collectionData.privatePath,
+            publicLinkedType : metadata.collectionData.publicLinkedType,
+            privateLinkedType : metadata.collectionData.privateLinkedType,
+            displayName : metadata.collectionDisplay.name,
+            description: metadata.collectionDisplay.description,
+            externalURL : metadata.collectionDisplay.externalURL.url
+        )
+    }
+
+    access(account) fun removeCatalogEntry(collectionIdentifier : String) {
+        pre {
+            self.catalog[collectionIdentifier] != nil : "Invalid collection identifier"
+        }
+
+        let removedType = self.removeCatalogTypeEntry(collectionIdentifier : collectionIdentifier , metadata: self.catalog[collectionIdentifier]!)
+        self.catalog.remove(key: collectionIdentifier)
+
+        emit EntryRemoved(collectionIdentifier : collectionIdentifier, nftType: removedType)
+    }
+
+    // This function is not preferred, and was used for the following issue:
+    // https://github.com/onflow/cadence/issues/2649
+    // If a contract's type is no longer resolvable in cadence and crashing,
+    // this function can be used to remove it from the catalog.
+    access(account) fun removeCatalogEntryUnsafe(collectionIdentifier: String, nftTypeIdentifier: String) {
+        // Remove the catalog entry
+        self.catalog.remove(key: collectionIdentifier)
+
+        // Remove the type entry
+        if (self.catalogTypeData[nftTypeIdentifier]!.keys.length == 1) {
+            self.catalogTypeData.remove(key: nftTypeIdentifier)
+        } else {
+            self.catalogTypeData[nftTypeIdentifier]!.remove(key: collectionIdentifier)
+        }
+    }
+
+    access(account) fun updateCatalogProposal(proposalID: UInt64, proposalMetadata : NFTCatalogProposal) {
+        self.catalogProposals[proposalID] = proposalMetadata
+
+        emit ProposalEntryUpdated(proposalID : proposalID, collectionIdentifier : proposalMetadata.collectionIdentifier, message: proposalMetadata.message, status: proposalMetadata.status, proposer: proposalMetadata.proposer)
+    }
+
+    access(account) fun removeCatalogProposal(proposalID : UInt64) {
+        self.catalogProposals.remove(key : proposalID)
+
+        emit ProposalEntryRemoved(proposalID : proposalID)
+    }
+
+    access(contract) fun addCatalogTypeEntry(collectionIdentifier : String , metadata: NFTCatalogMetadata) {
+        if self.catalogTypeData[metadata.nftType.identifier] != nil {
+            let typeData : {String : Bool} = self.catalogTypeData[metadata.nftType.identifier]!
+            assert(self.catalogTypeData[metadata.nftType.identifier]![collectionIdentifier] == nil, message : "The nft name has already been added to the catalog")
+            typeData[collectionIdentifier] = true
+            self.catalogTypeData[metadata.nftType.identifier] = typeData
+        } else {
+            let typeData : {String : Bool} = {}
+            typeData[collectionIdentifier] = true
+            self.catalogTypeData[metadata.nftType.identifier] = typeData
+        }
+    }
+
+    access(contract) fun removeCatalogTypeEntry(collectionIdentifier : String , metadata: NFTCatalogMetadata): Type {
+        let prevMetadata = self.catalog[collectionIdentifier]!
+        let prevCollectionsForType = self.catalogTypeData[prevMetadata.nftType.identifier]!
+        prevCollectionsForType.remove(key : collectionIdentifier)
+        if prevCollectionsForType.length == 0 {
+            self.catalogTypeData.remove(key: prevMetadata.nftType.identifier)
+        } else {
+            self.catalogTypeData[prevMetadata.nftType.identifier] = prevCollectionsForType
+        }
+
+        return metadata.nftType
+    }
+
+    init() {
+        self.ProposalManagerStoragePath = /storage/nftCatalogProposalManager
+        self.ProposalManagerPublicPath = /public/nftCatalogProposalManager
+
+        self.totalProposals = 0
+        self.catalog = {}
+        self.catalogTypeData = {}
+
+        self.catalogProposals = {}
+    }
+
+}
+ 

package/contracts/nft-catalog/NFTCatalogAdmin.cdc

@@ -0,0 +1,175 @@
+import "NFTCatalog"
+
+// NFTCatalogAdmin
+//
+// An admin contract that defines an    admin resource and
+// a proxy resource to receive a capability that lets you make changes to the NFT Catalog
+// and manage proposals
+
+pub contract NFTCatalogAdmin {
+
+    // AddProposalAccepted
+    // Emitted when a proposal to add a new catalog item has been approved by an admin
+    pub event AddProposalAccepted(
+        proposer: Address,
+        collectionIdentifier : String,
+        contractName : String,
+        contractAddress : Address,
+        displayName : String
+    )
+
+    // UpdateProposalAccepted
+    // Emitted when a proposal to update a catalog item has been approved by an admin
+    pub event UpdateProposalAccepted(
+        proposer: Address,
+        collectionIdentifier : String,
+        contractName : String,
+        contractAddress : Address,
+        displayName : String
+    )
+
+    // ProposalRejected
+    // Emitted when a proposal to add or update a catalog item has been rejected.
+    pub event ProposalRejected(
+        proposer: Address,
+        collectionIdentifier : String,
+        contractName : String,
+        contractAddress : Address,
+        displayName : String
+    )
+
+    pub let AdminPrivatePath: PrivatePath
+    pub let AdminStoragePath: StoragePath
+
+    pub let AdminProxyPublicPath: PublicPath
+    pub let AdminProxyStoragePath: StoragePath
+
+    // Admin
+    // Admin resource to manage NFT Catalog
+    pub resource Admin {
+
+        pub fun addCatalogEntry(collectionIdentifier: String, metadata : NFTCatalog.NFTCatalogMetadata) {
+            NFTCatalog.addCatalogEntry(collectionIdentifier: collectionIdentifier, metadata : metadata)
+        }
+
+        pub fun updateCatalogEntry(collectionIdentifier : String , metadata : NFTCatalog.NFTCatalogMetadata) {
+            NFTCatalog.updateCatalogEntry(collectionIdentifier: collectionIdentifier, metadata : metadata)
+        }
+
+        pub fun removeCatalogEntry(collectionIdentifier : String) {
+            NFTCatalog.removeCatalogEntry(collectionIdentifier : collectionIdentifier)
+        }
+
+        pub fun removeCatalogEntryUnsafe(collectionIdentifier : String, nftTypeIdentifier: String) {
+            NFTCatalog.removeCatalogEntryUnsafe(collectionIdentifier : collectionIdentifier, nftTypeIdentifier: nftTypeIdentifier)
+        }
+
+        pub fun approveCatalogProposal(proposalID : UInt64) {
+            pre {
+                NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
+                NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!.status == "IN_REVIEW" : "Invalid Proposal"
+            }
+            let catalogProposalEntry = NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!
+            let newCatalogProposalEntry = NFTCatalog.NFTCatalogProposal(collectionIdentifier : catalogProposalEntry.collectionIdentifier, metadata : catalogProposalEntry.metadata, message : catalogProposalEntry.message, status: "APPROVED", proposer: catalogProposalEntry.proposer)
+            NFTCatalog.updateCatalogProposal(proposalID : proposalID, proposalMetadata : newCatalogProposalEntry)
+
+            if NFTCatalog.getCatalogEntry(collectionIdentifier : NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!.collectionIdentifier) == nil {
+                NFTCatalog.addCatalogEntry(collectionIdentifier: newCatalogProposalEntry.collectionIdentifier, metadata : newCatalogProposalEntry.metadata)
+                emit AddProposalAccepted(
+                    proposer: newCatalogProposalEntry.proposer,
+                    collectionIdentifier : newCatalogProposalEntry.collectionIdentifier,
+                    contractName : newCatalogProposalEntry.metadata.contractName,
+                    contractAddress : newCatalogProposalEntry.metadata.contractAddress,
+                    displayName : newCatalogProposalEntry.metadata.collectionDisplay.name
+                )
+            } else {
+                NFTCatalog.updateCatalogEntry(collectionIdentifier: newCatalogProposalEntry.collectionIdentifier, metadata: newCatalogProposalEntry.metadata)
+                emit UpdateProposalAccepted(
+                    proposer: newCatalogProposalEntry.proposer,
+                    collectionIdentifier : newCatalogProposalEntry.collectionIdentifier,
+                    contractName : newCatalogProposalEntry.metadata.contractName,
+                    contractAddress : newCatalogProposalEntry.metadata.contractAddress,
+                    displayName : newCatalogProposalEntry.metadata.collectionDisplay.name
+                )
+            }
+        }
+
+        pub fun rejectCatalogProposal(proposalID : UInt64) {
+            pre {
+                NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
+                NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!.status == "IN_REVIEW" : "Invalid Proposal"
+            }
+            let catalogProposalEntry = NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!
+            let newCatalogProposalEntry = NFTCatalog.NFTCatalogProposal(collectionIdentifier : catalogProposalEntry.collectionIdentifier, metadata : catalogProposalEntry.metadata, message : catalogProposalEntry.message, status: "REJECTED", proposer: catalogProposalEntry.proposer)
+            NFTCatalog.updateCatalogProposal(proposalID : proposalID, proposalMetadata : newCatalogProposalEntry)
+            emit ProposalRejected(
+                proposer: newCatalogProposalEntry.proposer,
+                collectionIdentifier : newCatalogProposalEntry.collectionIdentifier,
+                contractName : newCatalogProposalEntry.metadata.contractName,
+                contractAddress : newCatalogProposalEntry.metadata.contractAddress,
+                displayName : newCatalogProposalEntry.metadata.collectionDisplay.name
+            )
+        }
+
+        pub fun removeCatalogProposal(proposalID : UInt64) {
+            pre {
+                NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
+            }
+            NFTCatalog.removeCatalogProposal(proposalID : proposalID)
+        }
+
+        init () {}
+
+    }
+
+    // AdminProxy
+    // A proxy resource that can store
+    // a capability to admin controls
+    pub resource interface IAdminProxy {
+        pub fun addCapability(capability : Capability<&Admin>)
+        pub fun hasCapability() : Bool
+    }
+
+    pub resource AdminProxy : IAdminProxy {
+        
+        access(self) var capability : Capability<&Admin>?
+
+        pub fun addCapability(capability : Capability<&Admin>) {
+            pre {
+                capability.check() : "Invalid Admin Capability"
+                self.capability == nil : "Admin Proxy already set"
+            }
+            self.capability = capability
+        }
+
+        pub fun getCapability() : Capability<&Admin>? {
+            return self.capability
+        }
+
+        pub fun hasCapability() : Bool {
+            return self.capability != nil
+        }
+
+        init() {
+            self.capability = nil
+        }
+        
+    }
+
+    pub fun createAdminProxy() : @AdminProxy {
+        return <- create AdminProxy()
+    }
+
+    init () {
+        self.AdminProxyPublicPath = /public/nftCatalogAdminProxy
+        self.AdminProxyStoragePath = /storage/nftCatalogAdminProxy
+        
+        self.AdminPrivatePath = /private/nftCatalogAdmin
+        self.AdminStoragePath = /storage/nftCatalogAdmin
+
+        let admin    <- create Admin()
+
+        self.account.save(<-admin, to: self.AdminStoragePath)
+        self.account.link<&Admin>(self.AdminPrivatePath, target: self.AdminStoragePath)
+    }
+}