@flowtyio/flow-contracts 0.1.0-beta.3 → 0.1.0-beta.30

package/contracts/nft-catalog/NFTCatalog.cdc

@@ -10,10 +10,10 @@ import "MetadataViews"
 // 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 {
+access(all) contract NFTCatalog {
     // EntryAdded
     // An NFT collection has been added to the catalog
-    pub event EntryAdded(
+    access(all) event EntryAdded(
         collectionIdentifier : String,
         contractName : String,
         contractAddress : Address,
@@ -30,7 +30,7 @@ pub contract NFTCatalog {
 
     // EntryUpdated
     // An NFT Collection has been updated in the catalog
-    pub event EntryUpdated(
+    access(all) event EntryUpdated(
         collectionIdentifier : String,
         contractName : String,
         contractAddress : Address,
@@ -47,23 +47,23 @@ pub contract NFTCatalog {
 
     // EntryRemoved
     // An NFT Collection has been removed from the catalog
-    pub event EntryRemoved(collectionIdentifier : String, nftType: Type)
+    access(all) 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)
+    access(all) 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)
+    access(all) 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)
+    access(all) event ProposalEntryRemoved(proposalID : UInt64)
 
-    pub let ProposalManagerStoragePath: StoragePath
+    access(all) let ProposalManagerStoragePath: StoragePath
 
-    pub let ProposalManagerPublicPath: PublicPath
+    access(all) 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 } }
@@ -75,17 +75,17 @@ pub contract NFTCatalog {
     // NFTCatalogProposalManager
     // Used to authenticate proposals made to the catalog
 
-    pub resource interface NFTCatalogProposalManagerPublic {
-        pub fun getCurrentProposalEntry(): String?
+    access(all) resource interface NFTCatalogProposalManagerPublic {
+        access(all) fun getCurrentProposalEntry(): String?
     }
-    pub resource NFTCatalogProposalManager : NFTCatalogProposalManagerPublic {
+    access(all) resource NFTCatalogProposalManager : NFTCatalogProposalManagerPublic {
             access(self) var currentProposalEntry: String?
 
-            pub fun getCurrentProposalEntry(): String? {
+            access(all) fun getCurrentProposalEntry(): String? {
                 return self.currentProposalEntry
             }
 
-            pub fun setCurrentProposalEntry(identifier: String?) {
+            access(all) fun setCurrentProposalEntry(identifier: String?) {
                 self.currentProposalEntry = identifier
             }
 
@@ -95,19 +95,19 @@ pub contract NFTCatalog {
     }
 
 
-    pub resource Snapshot {
-        pub var catalogSnapshot: {String : NFTCatalogMetadata}
-        pub var shouldUseSnapshot: Bool
+    access(all) resource Snapshot {
+        access(all) var catalogSnapshot: {String : NFTCatalogMetadata}
+        access(all) var shouldUseSnapshot: Bool
 
-        pub fun setPartialSnapshot(_ snapshotKey: String, _ snapshotEntry: NFTCatalogMetadata) {
+        access(all) fun setPartialSnapshot(_ snapshotKey: String, _ snapshotEntry: NFTCatalogMetadata) {
             self.catalogSnapshot[snapshotKey] = snapshotEntry
         }
 
-        pub fun setShouldUseSnapshot(_ shouldUseSnapshot: Bool) {
+        access(all) fun setShouldUseSnapshot(_ shouldUseSnapshot: Bool) {
             self.shouldUseSnapshot = shouldUseSnapshot
         }
 
-        pub fun getCatalogSnapshot(): {String : NFTCatalogMetadata} {
+        access(all) fun getCatalogSnapshot(): {String : NFTCatalogMetadata} {
             return self.catalogSnapshot
         }
 
@@ -117,7 +117,7 @@ pub contract NFTCatalog {
         }
     }
 
-    pub fun createEmptySnapshot(): @Snapshot {
+    access(all) fun createEmptySnapshot(): @Snapshot {
         return <- create Snapshot()
     }
 
@@ -125,13 +125,13 @@ pub contract NFTCatalog {
     // Represents information about an NFT collection resource
     // Note: Not suing the struct from Metadata standard due to
     // inability to store functions
-    pub struct NFTCollectionData {
+    access(all) struct NFTCollectionData {
 
-        pub let storagePath : StoragePath
-        pub let publicPath : PublicPath
-        pub let privatePath: PrivatePath
-        pub let publicLinkedType: Type
-        pub let privateLinkedType: Type
+        access(all) let storagePath : StoragePath
+        access(all) let publicPath : PublicPath
+        access(all) let privatePath: PrivatePath
+        access(all) let publicLinkedType: Type
+        access(all) let privateLinkedType: Type
 
         init(
             storagePath : StoragePath,
@@ -150,12 +150,12 @@ pub contract NFTCatalog {
 
     // 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
+    access(all) struct NFTCatalogMetadata {
+        access(all) let contractName : String
+        access(all) let contractAddress : Address
+        access(all) let nftType: Type
+        access(all) let collectionData: NFTCollectionData
+        access(all) let collectionDisplay: MetadataViews.NFTCollectionDisplay
 
         init (contractName : String, contractAddress : Address, nftType: Type, collectionData : NFTCollectionData, collectionDisplay : MetadataViews.NFTCollectionDisplay) {
             self.contractName = contractName
@@ -169,13 +169,13 @@ pub contract NFTCatalog {
     // 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
+    access(all) struct NFTCatalogProposal {
+        access(all) let collectionIdentifier : String
+        access(all) let metadata : NFTCatalogMetadata
+        access(all) let message : String
+        access(all) let status : String
+        access(all) let proposer : Address
+        access(all) let createdTime : UFix64
 
         init(collectionIdentifier : String, metadata : NFTCatalogMetadata, message : String, status : String, proposer : Address) {
             self.collectionIdentifier = collectionIdentifier
@@ -192,8 +192,8 @@ pub contract NFTCatalog {
         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)
+    access(all) fun getCatalog() : {String : NFTCatalogMetadata} {
+        let snapshot = self.account.storage.borrow<&NFTCatalog.Snapshot>(from: /storage/CatalogSnapshot)
         if snapshot != nil {
             let snapshot = snapshot!
             if snapshot.shouldUseSnapshot {
@@ -206,23 +206,23 @@ pub contract NFTCatalog {
         }
     }
 
-    pub fun getCatalogKeys(): [String] {
+    access(all) fun getCatalogKeys(): [String] {
         return self.catalog.keys
     }
 
-    pub fun forEachCatalogKey(_ function: ((String): Bool)) {
+    access(all) fun forEachCatalogKey(_ function: fun (String): Bool) {
         self.catalog.forEachKey(function)
     }
 
-    pub fun getCatalogEntry(collectionIdentifier : String) : NFTCatalogMetadata? {
+    access(all) view fun getCatalogEntry(collectionIdentifier : String) : NFTCatalogMetadata? {
         return self.catalog[collectionIdentifier]
     }
 
-    pub fun getCollectionsForType(nftTypeIdentifier: String) : {String : Bool}? {
+    access(all) fun getCollectionsForType(nftTypeIdentifier: String) : {String : Bool}? {
         return self.catalogTypeData[nftTypeIdentifier]
     }
 
-    pub fun getCatalogTypeData() : {String : {String : Bool}} {
+    access(all) fun getCatalogTypeData() : {String : {String : Bool}} {
         return self.catalogTypeData
     }
 
@@ -231,12 +231,10 @@ pub contract NFTCatalog {
     // @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()!
+    access(all) fun proposeNFTMetadata(collectionIdentifier : String, metadata : NFTCatalogMetadata, message : String, proposer : Address) : UInt64 {
+        let proposerManagerRef = getAccount(proposer).capabilities.borrow<&NFTCatalogProposalManager>(
+            NFTCatalog.ProposalManagerPublicPath
+        ) ?? panic("Proposer needs to set up a manager")
 
         assert(proposerManagerRef.getCurrentProposalEntry()! == collectionIdentifier, message: "Expected proposal entry does not match entry for the proposer")
 
@@ -250,41 +248,39 @@ pub contract NFTCatalog {
 
     // Withdraw a proposal from the catalog
     // @param proposalID: The ID of proposal you want to withdraw
-    pub fun withdrawNFTProposal(proposalID : UInt64) {
+    access(all) 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()!
+        let proposerManagerRef = getAccount(proposer).capabilities.borrow<&NFTCatalogProposalManager>(
+            NFTCatalog.ProposalManagerPublicPath
+        ) ?? panic("Proposer needs to set up a manager")
 
         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} {
+    access(all) fun getCatalogProposals() : {UInt64 : NFTCatalogProposal} {
         return self.catalogProposals
     }
 
-    pub fun getCatalogProposalEntry(proposalID : UInt64) : NFTCatalogProposal? {
+    access(all) view fun getCatalogProposalEntry(proposalID : UInt64) : NFTCatalogProposal? {
         return self.catalogProposals[proposalID]
     }
 
-    pub fun getCatalogProposalKeys() : [UInt64] {
+    access(all) fun getCatalogProposalKeys() : [UInt64] {
         return self.catalogProposals.keys
     }
 
-    pub fun forEachCatalogProposalKey(_ function: ((UInt64): Bool)) {
+    access(all) fun forEachCatalogProposalKey(_ function: fun (UInt64): Bool) {
         self.catalogProposals.forEachKey(function)
     }
 
-    pub fun createNFTCatalogProposalManager(): @NFTCatalogProposalManager {
+    access(all) fun createNFTCatalogProposalManager(): @NFTCatalogProposalManager {
         return <-create NFTCatalogProposalManager()
     }
 

package/contracts/nft-catalog/NFTCatalogAdmin.cdc

@@ -6,11 +6,13 @@ import "NFTCatalog"
 // a proxy resource to receive a capability that lets you make changes to the NFT Catalog
 // and manage proposals
 
-pub contract NFTCatalogAdmin {
+access(all) contract NFTCatalogAdmin {
+
+    access(all) entitlement CatalogActions
 
     // AddProposalAccepted
     // Emitted when a proposal to add a new catalog item has been approved by an admin
-    pub event AddProposalAccepted(
+    access(all) event AddProposalAccepted(
         proposer: Address,
         collectionIdentifier : String,
         contractName : String,
@@ -20,7 +22,7 @@ pub contract NFTCatalogAdmin {
 
     // UpdateProposalAccepted
     // Emitted when a proposal to update a catalog item has been approved by an admin
-    pub event UpdateProposalAccepted(
+    access(all) event UpdateProposalAccepted(
         proposer: Address,
         collectionIdentifier : String,
         contractName : String,
@@ -30,7 +32,7 @@ pub contract NFTCatalogAdmin {
 
     // ProposalRejected
     // Emitted when a proposal to add or update a catalog item has been rejected.
-    pub event ProposalRejected(
+    access(all) event ProposalRejected(
         proposer: Address,
         collectionIdentifier : String,
         contractName : String,
@@ -38,33 +40,33 @@ pub contract NFTCatalogAdmin {
         displayName : String
     )
 
-    pub let AdminPrivatePath: PrivatePath
-    pub let AdminStoragePath: StoragePath
+    access(all) let AdminPrivatePath: PrivatePath
+    access(all) let AdminStoragePath: StoragePath
 
-    pub let AdminProxyPublicPath: PublicPath
-    pub let AdminProxyStoragePath: StoragePath
+    access(all) let AdminProxyPublicPath: PublicPath
+    access(all) let AdminProxyStoragePath: StoragePath
 
     // Admin
     // Admin resource to manage NFT Catalog
-    pub resource Admin {
+    access(all) resource Admin {
 
-        pub fun addCatalogEntry(collectionIdentifier: String, metadata : NFTCatalog.NFTCatalogMetadata) {
+        access(CatalogActions) fun addCatalogEntry(collectionIdentifier: String, metadata : NFTCatalog.NFTCatalogMetadata) {
             NFTCatalog.addCatalogEntry(collectionIdentifier: collectionIdentifier, metadata : metadata)
         }
 
-        pub fun updateCatalogEntry(collectionIdentifier : String , metadata : NFTCatalog.NFTCatalogMetadata) {
+        access(CatalogActions) fun updateCatalogEntry(collectionIdentifier : String , metadata : NFTCatalog.NFTCatalogMetadata) {
             NFTCatalog.updateCatalogEntry(collectionIdentifier: collectionIdentifier, metadata : metadata)
         }
 
-        pub fun removeCatalogEntry(collectionIdentifier : String) {
+        access(CatalogActions) fun removeCatalogEntry(collectionIdentifier : String) {
             NFTCatalog.removeCatalogEntry(collectionIdentifier : collectionIdentifier)
         }
 
-        pub fun removeCatalogEntryUnsafe(collectionIdentifier : String, nftTypeIdentifier: String) {
+        access(CatalogActions) fun removeCatalogEntryUnsafe(collectionIdentifier : String, nftTypeIdentifier: String) {
             NFTCatalog.removeCatalogEntryUnsafe(collectionIdentifier : collectionIdentifier, nftTypeIdentifier: nftTypeIdentifier)
         }
 
-        pub fun approveCatalogProposal(proposalID : UInt64) {
+        access(CatalogActions) fun approveCatalogProposal(proposalID : UInt64) {
             pre {
                 NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
                 NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!.status == "IN_REVIEW" : "Invalid Proposal"
@@ -94,7 +96,7 @@ pub contract NFTCatalogAdmin {
             }
         }
 
-        pub fun rejectCatalogProposal(proposalID : UInt64) {
+        access(CatalogActions) fun rejectCatalogProposal(proposalID : UInt64) {
             pre {
                 NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
                 NFTCatalog.getCatalogProposalEntry(proposalID : proposalID)!.status == "IN_REVIEW" : "Invalid Proposal"
@@ -111,7 +113,7 @@ pub contract NFTCatalogAdmin {
             )
         }
 
-        pub fun removeCatalogProposal(proposalID : UInt64) {
+        access(CatalogActions) fun removeCatalogProposal(proposalID : UInt64) {
             pre {
                 NFTCatalog.getCatalogProposalEntry(proposalID : proposalID) != nil : "Invalid Proposal ID"
             }
@@ -125,16 +127,16 @@ pub contract NFTCatalogAdmin {
     // 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
+    access(all) resource interface IAdminProxy {
+        access(all) fun addCapability(capability : Capability<auth(CatalogActions) &Admin>)
+        access(all) fun hasCapability() : Bool
     }
 
-    pub resource AdminProxy : IAdminProxy {
+    access(all) resource AdminProxy : IAdminProxy {
         
-        access(self) var capability : Capability<&Admin>?
+        access(self) var capability : Capability<auth(CatalogActions) &Admin>?
 
-        pub fun addCapability(capability : Capability<&Admin>) {
+        access(all) fun addCapability(capability : Capability<auth(CatalogActions) &Admin>) {
             pre {
                 capability.check() : "Invalid Admin Capability"
                 self.capability == nil : "Admin Proxy already set"
@@ -142,11 +144,11 @@ pub contract NFTCatalogAdmin {
             self.capability = capability
         }
 
-        pub fun getCapability() : Capability<&Admin>? {
+        access(all) fun getCapability() : Capability<auth(CatalogActions) &Admin>? {
             return self.capability
         }
 
-        pub fun hasCapability() : Bool {
+        access(all) fun hasCapability() : Bool {
             return self.capability != nil
         }
 
@@ -156,7 +158,7 @@ pub contract NFTCatalogAdmin {
         
     }
 
-    pub fun createAdminProxy() : @AdminProxy {
+    access(all) fun createAdminProxy() : @AdminProxy {
         return <- create AdminProxy()
     }
 
@@ -169,7 +171,6 @@ pub contract NFTCatalogAdmin {
 
         let admin    <- create Admin()
 
-        self.account.save(<-admin, to: self.AdminStoragePath)
-        self.account.link<&Admin>(self.AdminPrivatePath, target: self.AdminStoragePath)
+        self.account.storage.save(<-admin, to: self.AdminStoragePath)
     }
 }

package/flow.json

@@ -1,6 +1,7 @@
 {
   "networks": {
     "emulator": "127.0.0.1:3569",
+    "testing": "127.0.0.1:3569",
     "mainnet": "access.mainnet.nodes.onflow.org:9000",
     "sandboxnet": "access.sandboxnet.nodes.onflow.org:9000",
     "testnet": "access.devnet.nodes.onflow.org:9000"
@@ -28,6 +29,14 @@
         "mainnet": "0x1d7e57aa55817448"
       }
     },
+    "Burner": {
+      "source": "./contracts/Burner.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x9a0766d93b6608b7",
+        "mainnet": "0xf233dcee88fe0abe"
+      }
+    },
     "MetadataViews": {
       "source": "./contracts/MetadataViews.cdc",
       "aliases": {
@@ -52,6 +61,14 @@
         "mainnet": "0xf233dcee88fe0abe"
       }
     },
+    "FungibleTokenSwitchboard": {
+      "source": "./contracts/FungibleTokenSwitchboard.cdc",
+      "aliases": {
+        "emulator": "0xee82856bf20e2aa6",
+        "testnet": "0x9a0766d93b6608b7",
+        "mainnet": "0xf233dcee88fe0abe"
+      }
+    },
     "ViewResolver": {
       "source": "./contracts/ViewResolver.cdc",
       "aliases": {
@@ -132,8 +149,8 @@
         "mainnet": "0xd8a7e05a7ac670c0"
       }
     },
-    "NFTProviderAndCollectionPublicFactory": {
-      "source": "./contracts/hybrid-custody/factories/NFTProviderAndCollectionPublicFactory.cdc",
+    "NFTProviderAndCollectionFactory": {
+      "source": "./contracts/hybrid-custody/factories/NFTProviderAndCollectionFactory.cdc",
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
         "testnet": "0x294e44e1ec6993c6",
@@ -177,7 +194,7 @@
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
         "testnet": "0x8c5303eaa26202d6",
-        "mainnet": "0xf919ee77447b7497"
+        "mainnet": "0xe467b9dd11fa00df"
       }
     },
     "TokenForwarding": {
@@ -337,11 +354,166 @@
         "emulator": "0xf8d6e0586b0a20c7",
         "testing": "0x0000000000000007"
       }
+    },
+    "ContractManager": {
+      "source": "./contracts/flowty-drops/ContractManager.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractInitializer": {
+      "source": "./contracts/flowty-drops/initializers/ContractInitializer.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractBorrower": {
+      "source": "./contracts/flowty-drops/initializers/ContractBorrower.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "OpenEditionInitializer": {
+      "source": "./contracts/flowty-drops/initializers/OpenEditionInitializer.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "BaseCollection": {
+      "source": "./contracts/flowty-drops/nft/BaseCollection.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractFactoryTemplate": {
+      "source": "./contracts/flowty-drops/nft/ContractFactoryTemplate.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractFactory": {
+      "source": "./contracts/flowty-drops/nft/ContractFactory.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "OpenEditionTemplate": {
+      "source": "./contracts/flowty-drops/nft/OpenEditionTemplate.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "UniversalCollection": {
+      "source": "./contracts/flowty-drops/nft/UniversalCollection.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "BaseNFT": {
+      "source": "./contracts/flowty-drops/nft/BaseNFT.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "NFTMetadata": {
+      "source": "./contracts/flowty-drops/nft/NFTMetadata.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyDrops": {
+      "source": "./contracts/flowty-drops/FlowtyDrops.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "DropFactory": {
+      "source": "./contracts/flowty-drops/DropFactory.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtySwitchers": {
+      "source": "./contracts/flowty-drops/FlowtySwitchers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyPricers": {
+      "source": "./contracts/flowty-drops/FlowtyPricers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyAddressVerifiers": {
+      "source": "./contracts/flowty-drops/FlowtyAddressVerifiers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0xd20430774404a7e8",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "DropTypes": {
+      "source": "./contracts/flowty-drops/DropTypes.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x3d49bb33997bd91e",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "CapabilityCache": {
+      "source": "./contracts/capability-cache/CapabilityCache.cdc",
+      "aliases": {
+        "testing": "0x0000000000000007",
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x83d75469f66d2ee6",
+        "mainnet": "0xacc5081c003e24cf"
+      }
+    },
+    "FungibleTokenRouter": {
+      "source": "./contracts/fungible-token-router/FungibleTokenRouter.cdc",
+      "aliases": {
+        "testing": "0x0000000000000007",
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x83231f90a288bc35",
+        "mainnet": "0x707c0b39a8d689cb"
+      }
     }
   },
   "deployments": {
     "emulator": {
       "emulator-account": [
+        "Burner",
         "NonFungibleToken",
         "MetadataViews",
         "ViewResolver",
@@ -367,11 +539,23 @@
         "FindViews",
         "FLOAT",
         "ExampleNFT",
-        "ExampleToken"
+        "ExampleToken",
+        "HybridCustody",
+        "CapabilityFactory",
+        "CapabilityDelegator",
+        "CapabilityFilter",
+        "FTAllFactory",
+        "FTBalanceFactory",
+        "FTProviderFactory",
+        "FTReceiverFactory",
+        "NFTCollectionPublicFactory",
+        "NFTProviderAndCollectionFactory",
+        "NFTProviderFactory"
       ],
       "emulator-ft": [
         "FungibleToken",
-        "FungibleTokenMetadataViews"
+        "FungibleTokenMetadataViews",
+        "FungibleTokenSwitchboard"
       ],
       "emulator-flowtoken": [
         "FlowToken"