@flowtyio/flow-contracts 0.1.0-beta.4 → 0.1.0-beta.6

package/contracts/example/ExampleNFT.cdc

@@ -143,6 +143,10 @@ access(all) contract ExampleNFT: ViewResolver {
             }
             return nil
         }
+
+        access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
+            return <- ExampleNFT.createEmptyCollection()
+        }
     }
 
     access(all) resource interface ExampleNFTCollectionPublic: NonFungibleToken.Collection {
@@ -185,6 +189,14 @@ access(all) contract ExampleNFT: ViewResolver {
             }
         }
 
+        access(all) view fun getIDs(): [UInt64] {
+            return self.ownedNFTs.keys
+        }
+
+        access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
+            return &self.ownedNFTs[id]
+        }
+
         access(all) view fun isSupportedNFTType(type: Type): Bool {
             return type == Type<@ExampleNFT.NFT>()
         }
@@ -194,10 +206,10 @@ access(all) contract ExampleNFT: ViewResolver {
         }
 
         // withdraw removes an NFT from the collection and moves it to the caller
-        access(NonFungibleToken.Withdrawable) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT")
 
-            emit Withdraw(id: token.getID(), from: self.owner?.address)
+            emit Withdraw(id: token.id, from: self.owner?.address)
 
             return <-token
         }
@@ -216,17 +228,6 @@ access(all) contract ExampleNFT: ViewResolver {
 
             destroy oldToken
         }
-
-        // getIDs returns an array of the IDs that are in the collection
-        access(all) view fun getIDs(): [UInt64] {
-            return self.ownedNFTs.keys
-        }
-
-        // borrowNFT gets a reference to an NFT in the collection
-        // so that the caller can read its metadata and call its methods
-        access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
-            return &self.ownedNFTs[id]
-        }
  
         access(all) fun borrowExampleNFT(id: UInt64): &ExampleNFT.NFT? {
             if self.ownedNFTs[id] != nil {
@@ -343,16 +344,14 @@ access(all) contract ExampleNFT: ViewResolver {
     /// @param view: The Type of the desired view.
     /// @return A structure representing the requested view.
     ///
-    access(all) view fun resolveView(_ view: Type): AnyStruct? {
-        switch view {
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
             case Type<MetadataViews.NFTCollectionData>():
                 return MetadataViews.NFTCollectionData(
                         storagePath: ExampleNFT.CollectionStoragePath,
                         publicPath: ExampleNFT.CollectionPublicPath,
-                        providerPath: /private/exampleNFTCollection,
                         publicCollection: Type<&ExampleNFT.Collection>(),
                         publicLinkedType: Type<&ExampleNFT.Collection>(),
-                        providerLinkedType: Type<auth(NonFungibleToken.Withdrawable) &ExampleNFT.Collection>(),
                         createEmptyCollectionFunction: (fun (): @{NonFungibleToken.Collection} {
                             return <-ExampleNFT.createEmptyCollection()
                         })
@@ -383,7 +382,7 @@ access(all) contract ExampleNFT: ViewResolver {
     /// @return An array of Types defining the implemented views. This value will be used by
     ///         developers to know which parameter to pass to the resolveView() method.
     ///
-    access(all) view fun getViews(): [Type] {
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
         return [
             Type<MetadataViews.NFTCollectionData>(),
             Type<MetadataViews.NFTCollectionDisplay>()

package/contracts/example/ExampleToken.cdc

@@ -1,4 +1,6 @@
 import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "MetadataViews"
 
 
 // THIS CONTRACT IS FOR TESTING PURPOSES ONLY!
@@ -80,6 +82,20 @@ access(all) contract ExampleToken {
             return /public/exampleTokenPublic
         }
 
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.balance >= amount
+        }
+
+        /// Same as getViews above, but on a specific NFT instead of a contract
+        access(all) view fun getViews(): [Type] {
+            return ExampleToken.getContractViews(resourceType: nil)
+        }
+
+        /// Same as resolveView above, but on a specific NFT instead of a contract
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return ExampleToken.resolveContractView(resourceType: nil, viewType: view)
+        }
+
         /// withdraw
         ///
         /// Function that takes an amount as an argument
@@ -90,7 +106,7 @@ access(all) contract ExampleToken {
         /// created Vault to the context that called so it can be deposited
         /// elsewhere.
         ///
-        access(FungibleToken.Withdrawable) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             self.balance = self.balance - amount
             emit TokensWithdrawn(amount: amount, from: self.owner?.address)
             return <-create Vault(balance: amount)
@@ -211,6 +227,57 @@ access(all) contract ExampleToken {
         }
     }
 
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
+        return [Type<FungibleTokenMetadataViews.FTView>(),
+                Type<FungibleTokenMetadataViews.FTDisplay>(),
+                Type<FungibleTokenMetadataViews.FTVaultData>(),
+                Type<FungibleTokenMetadataViews.TotalSupply>()]
+    }
+
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
+            case Type<FungibleTokenMetadataViews.FTView>():
+                return FungibleTokenMetadataViews.FTView(
+                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
+                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+                )
+            case Type<FungibleTokenMetadataViews.FTDisplay>():
+                let media = MetadataViews.Media(
+                        file: MetadataViews.HTTPFile(
+                        url: "https://example.com"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "Example Token",
+                    symbol: "EXAMPLE",
+                    description: "",
+                    externalURL: MetadataViews.ExternalURL("https://flow.com"),
+                    logos: medias,
+                    socials: {
+                        "twitter": MetadataViews.ExternalURL("https://twitter.com/flow_blockchain")
+                    }
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = ExampleToken.account.storage.borrow<auth(FungibleToken.Withdraw) &ExampleToken.Vault>(from: /storage/exampleTokenVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/exampleTokenVault,
+                    receiverPath: /public/exampleTokenReceiver,
+                    metadataPath: /public/exampleTokenBalance,
+                    receiverLinkedType: Type<&{FungibleToken.Receiver, FungibleToken.Vault}>(),
+                    metadataLinkedType: Type<&{FungibleToken.Balance, FungibleToken.Vault}>(),
+                    createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
+                        return <-vaultRef.createEmptyVault()
+                    })
+                )
+            case Type<FungibleTokenMetadataViews.TotalSupply>():
+                return FungibleTokenMetadataViews.TotalSupply(totalSupply: ExampleToken.totalSupply)
+        }
+        return nil
+    }
+
     init() {
         self.totalSupply = 1000.0
 

package/contracts/flow-utils/AddressUtils.cdc

@@ -1,8 +1,5 @@
-import "StringUtils"
-
-pub contract AddressUtils {
-
-    pub fun withoutPrefix(_ input: String): String {
+access(all) contract AddressUtils {
+    access(all) fun withoutPrefix(_ input: String): String {
         var address = input
 
         // get rid of 0x
@@ -17,7 +14,7 @@ pub contract AddressUtils {
         return address
     }
 
-    pub fun parseUInt64(_ input: AnyStruct): UInt64? {
+    access(all) fun parseUInt64(_ input: AnyStruct): UInt64? {
         var stringValue = ""
 
         if let string = input as? String {
@@ -25,7 +22,7 @@ pub contract AddressUtils {
         } else if let address = input as? Address {
             stringValue = address.toString()
         } else if let type = input as? Type {
-            let parts = StringUtils.split(type.identifier, ".")
+            let parts = type.identifier.split(separator: ".")
             if parts.length == 1 {
                 return nil
             }
@@ -45,14 +42,14 @@ pub contract AddressUtils {
         return r
     }
 
-    pub fun parseAddress(_ input: AnyStruct): Address? {
+    access(all) fun parseAddress(_ input: AnyStruct): Address? {
         if let parsed = self.parseUInt64(input) {
             return Address(parsed)
         }
         return nil
     }
 
-    pub fun isValidAddress(_ input: AnyStruct, forNetwork: String): Bool {
+    access(all) fun isValidAddress(_ input: AnyStruct, forNetwork: String): Bool {
         let address = self.parseUInt64(input)
         if address == nil {
             return false
@@ -61,18 +58,19 @@ pub contract AddressUtils {
         let codeWords: {String: UInt64} = {
             "MAINNET" : 0,
             "TESTNET" : 0x6834ba37b3980209,
+            "CRESCENDO" : 0x6834ba37b3980209,
             "EMULATOR": 0x1cb159857af02018
         }
 
         let parityCheckMatrixColumns: [UInt64] = [
-            0x00001, 0x00002, 0x00004, 0x00008, 0x00010, 0x00020, 0x00040, 0x00080,
-            0x00100, 0x00200, 0x00400, 0x00800, 0x01000, 0x02000, 0x04000, 0x08000,
-            0x10000, 0x20000, 0x40000, 0x7328d, 0x6689a, 0x6112f, 0x6084b, 0x433fd,
-            0x42aab, 0x41951, 0x233ce, 0x22a81, 0x21948, 0x1ef60, 0x1deca, 0x1c639,
-            0x1bdd8, 0x1a535, 0x194ac, 0x18c46, 0x1632b, 0x1529b, 0x14a43, 0x13184,
-            0x12942, 0x118c1, 0x0f812, 0x0e027, 0x0d00e, 0x0c83c, 0x0b01d, 0x0a831,
-            0x0982b, 0x07034, 0x0682a, 0x05819, 0x03807, 0x007d2, 0x00727, 0x0068e,
-            0x0067c, 0x0059d, 0x004eb, 0x003b4, 0x0036a, 0x002d9, 0x001c7, 0x0003f
+        0x00001, 0x00002, 0x00004, 0x00008, 0x00010, 0x00020, 0x00040, 0x00080,
+        0x00100, 0x00200, 0x00400, 0x00800, 0x01000, 0x02000, 0x04000, 0x08000,
+        0x10000, 0x20000, 0x40000, 0x7328d, 0x6689a, 0x6112f, 0x6084b, 0x433fd,
+        0x42aab, 0x41951, 0x233ce, 0x22a81, 0x21948, 0x1ef60, 0x1deca, 0x1c639,
+        0x1bdd8, 0x1a535, 0x194ac, 0x18c46, 0x1632b, 0x1529b, 0x14a43, 0x13184,
+        0x12942, 0x118c1, 0x0f812, 0x0e027, 0x0d00e, 0x0c83c, 0x0b01d, 0x0a831,
+        0x0982b, 0x07034, 0x0682a, 0x05819, 0x03807, 0x007d2, 0x00727, 0x0068e,
+        0x0067c, 0x0059d, 0x004eb, 0x003b4, 0x0036a, 0x002d9, 0x001c7, 0x0003f
         ]
 
         var parity: UInt64 = 0
@@ -93,8 +91,8 @@ pub contract AddressUtils {
         return parity == 0 && codeWord == 0
     }
 
-    pub fun getNetworkFromAddress(_ input: AnyStruct): String? {
-        for network in ["MAINNET", "TESTNET", "EMULATOR"]{
+    access(all) fun getNetworkFromAddress(_ input: AnyStruct): String? {
+        for network in ["MAINNET", "TESTNET", "EMULATOR"] {
             if self.isValidAddress(input, forNetwork: network){
                 return network
             }
@@ -102,8 +100,7 @@ pub contract AddressUtils {
         return nil
     }
 
-    pub fun currentNetwork(): String {
-        return self.getNetworkFromAddress(self.account.address)!
+    access(all) fun currentNetwork(): String {
+        return  self.getNetworkFromAddress(self.account.address) ?? panic("unknown network!")
     }
-
 }

package/contracts/flow-utils/ArrayUtils.cdc

@@ -1,69 +1,120 @@
-// Copied from https://github.com/bluesign/flow-utils/blob/dnz/cadence/contracts/ArrayUtils.cdc with minor adjustments
+import "FungibleToken"
+import "StringUtils"
 
-pub contract ArrayUtils {
+// ScopedFTProviders
+//
+// TO AVOID RISK, PLEASE DEPLOY YOUR OWN VERSION OF THIS CONTRACT SO THAT
+// MALICIOUS UPDATES ARE NOT POSSIBLE
+//
+// ScopedProviders are meant to solve the issue of unbounded access FungibleToken vaults
+// when a provider is called for.
+access(all) contract ScopedFTProviders {
+    access(all) struct interface FTFilter {
+        access(all) fun canWithdrawAmount(_ amount: UFix64): Bool
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64)
+        access(all) fun getDetails(): {String: AnyStruct}
+    }
+
+    access(all) struct AllowanceFilter: FTFilter {
+        access(self) let allowance: UFix64
+        access(self) var allowanceUsed: UFix64
 
-    pub fun rangeFunc(_ start: Int, _ end: Int, _ f: ((Int): Void)) {
-        var current = start
-        while current < end {
-            f(current)
-            current = current + 1
+        init(_ allowance: UFix64) {
+            self.allowance = allowance
+            self.allowanceUsed = 0.0
         }
-    }
 
-    pub fun range(_ start: Int, _ end: Int): [Int] {
-        var res: [Int] = []
-        self.rangeFunc(start, end, fun (i: Int) {
-            res.append(i)
-        })
-        return res
-    }
+        access(all) fun canWithdrawAmount(_ amount: UFix64): Bool {
+            return amount + self.allowanceUsed <= self.allowance
+        }
 
-    pub fun reverse(_ array: [Int]): [Int] {
-        var res: [Int] = []
-        var i: Int = array.length - 1
-        while i >= 0 {
-            res.append(array[i])
-            i = i - 1
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64) {
+            self.allowanceUsed = self.allowanceUsed + amount
         }
-        return res
-    }
 
-    pub fun transform(_ array: &[AnyStruct], _ f : ((AnyStruct): AnyStruct)){
-        for i in self.range(0, array.length){
-            array[i] = f(array[i])
+        access(all) fun getDetails(): {String: AnyStruct} {
+            return {
+                "allowance": self.allowance,
+                "allowanceUsed": self.allowanceUsed
+            }
         }
     }
 
-    pub fun iterate(_ array: [AnyStruct], _ f : ((AnyStruct): Bool)){
-        for item in array{
-            if !f(item){
-                break
+    // ScopedFTProvider
+    //
+    // A ScopedFTProvider is a wrapped FungibleTokenProvider with
+    // filters that can be defined by anyone using the ScopedFTProvider.
+    access(all) resource ScopedFTProvider: FungibleToken.Provider {
+        access(self) let provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>
+        access(self) var filters: [{FTFilter}]
+
+        // block timestamp that this provider can no longer be used after
+        access(self) let expiration: UFix64?
+
+        access(all) init(provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>, filters: [{FTFilter}], expiration: UFix64?) {
+            self.provider = provider
+            self.filters = filters
+            self.expiration = expiration
+        }
+
+        access(all) fun check(): Bool {
+            return self.provider.check()
+        }
+
+        access(all) view fun isExpired(): Bool {
+            if let expiration = self.expiration {
+                return getCurrentBlock().timestamp >= expiration
             }
+            return false
         }
-    }
 
-    pub fun map(_ array: [AnyStruct], _ f : ((AnyStruct): AnyStruct)) : [AnyStruct] {
-        var res : [AnyStruct] = []
-        for item in array{
-            res.append(f(item))
+        access(all) fun canWithdraw(_ amount: UFix64): Bool {
+            if self.isExpired() {
+                return false
+            }
+
+            for filter in self.filters {
+                if !filter.canWithdrawAmount(amount) {
+                    return false
+                }
+            }
+
+            return true
         }
-        return res
-    }
 
-    pub fun mapStrings(_ array: [String], _ f: ((String) : String) ) : [String] {
-        var res : [String] = []
-        for item in array{
-            res.append(f(item))
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
+            pre {
+                !self.isExpired(): "provider has expired"
+            }
+
+            var i = 0
+            while i < self.filters.length {
+                if !self.filters[i].canWithdrawAmount(amount) {
+                    panic(StringUtils.join(["cannot withdraw tokens. filter of type", self.filters[i].getType().identifier, "failed."], " "))
+                }
+
+                self.filters[i].markAmountWithdrawn(amount)
+                i = i + 1
+            }
+
+            return <-self.provider.borrow()!.withdraw(amount: amount)
         }
-        return res
-    }
 
-    pub fun reduce(_ array: [AnyStruct], _ initial: AnyStruct, _ f : ((AnyStruct, AnyStruct): AnyStruct)) : AnyStruct{
-        var res: AnyStruct = f(initial, array[0])
-        for i in self.range(1, array.length){
-            res =  f(res, array[i])
+        access(all) fun getDetails(): [{String: AnyStruct}] {
+            let details: [{String: AnyStruct}] = []
+            for filter in self.filters {
+                details.append(filter.getDetails())
+            }
+
+            return details
         }
-        return res
     }
 
-}
+    access(all) fun createScopedFTProvider(
+        provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>,
+        filters: [{FTFilter}],
+        expiration: UFix64?
+    ): @ScopedFTProvider {
+        return <- create ScopedFTProvider(provider: provider, filters: filters, expiration: expiration)
+    }
+}

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -11,14 +11,14 @@ import "StringUtils"
 //
 // By using a scoped provider, only a subset of assets can be taken if the provider leaks
 // instead of the entire nft collection.
-pub contract ScopedNFTProviders {
-    pub struct interface NFTFilter {
-        pub fun canWithdraw(_ nft: &NonFungibleToken.NFT): Bool
-        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT)
-        pub fun getDetails(): {String: AnyStruct}
+access(all) contract ScopedNFTProviders {
+    access(all) struct interface NFTFilter {
+        access(all) fun canWithdraw(_ nft: &{NonFungibleToken.NFT}): Bool
+        access(NonFungibleToken.Withdraw) fun markWithdrawn(_ nft: &{NonFungibleToken.NFT})
+        access(all) fun getDetails(): {String: AnyStruct}
     }
 
-    pub struct NFTIDFilter: NFTFilter {
+    access(all) struct NFTIDFilter: NFTFilter {
         // the ids that are allowed to be withdrawn.
         // If ids[num] is false, the id cannot be withdrawn anymore
         access(self) let ids: {UInt64: Bool}
@@ -31,22 +31,22 @@ pub contract ScopedNFTProviders {
             self.ids = d
         }
 
-        pub fun canWithdraw(_ nft: &NonFungibleToken.NFT): Bool {
-            return self.ids[nft.id] != nil && self.ids[nft.id] == true
+        access(all) fun canWithdraw(_ nft: &{NonFungibleToken.NFT}): Bool {
+            return self.ids[nft.getID()] != nil && self.ids[nft.getID()] == true
         }
 
-        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT) {
-            self.ids[nft.id] = false
+        access(NonFungibleToken.Withdraw) fun markWithdrawn(_ nft: &{NonFungibleToken.NFT}) {
+            self.ids[nft.getID()] = false
         }
 
-        pub fun getDetails(): {String: AnyStruct} {
+        access(all) fun getDetails(): {String: AnyStruct} {
             return {
                 "ids": self.ids
             }
         }
     }
 
-    pub struct UUIDFilter: NFTFilter {
+    access(all) struct UUIDFilter: NFTFilter {
         // the ids that are allowed to be withdrawn.
         // If ids[num] is false, the id cannot be withdrawn anymore
         access(self) let uuids: {UInt64: Bool}
@@ -59,15 +59,15 @@ pub contract ScopedNFTProviders {
             self.uuids = d
         }
 
-        pub fun canWithdraw(_ nft: &NonFungibleToken.NFT): Bool {
+        access(all) fun canWithdraw(_ nft: &{NonFungibleToken.NFT}): Bool {
             return self.uuids[nft.uuid] != nil && self.uuids[nft.uuid]! == true
         }
 
-        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT) {
+        access(NonFungibleToken.Withdraw) fun markWithdrawn(_ nft: &{NonFungibleToken.NFT}) {
             self.uuids[nft.uuid] = false
         }
 
-        pub fun getDetails(): {String: AnyStruct} {
+        access(all) fun getDetails(): {String: AnyStruct} {
             return {
                 "uuids": self.uuids
             }
@@ -77,39 +77,39 @@ pub contract ScopedNFTProviders {
     // ScopedNFTProvider
     //
     // Wrapper around an NFT Provider that is restricted to specific ids.
-    pub resource ScopedNFTProvider: NonFungibleToken.Provider {
-        access(self) let provider: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+    access(all) resource ScopedNFTProvider: NonFungibleToken.Provider {
+        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>
         access(self) let filters: [{NFTFilter}]
 
         // block timestamp that this provider can no longer be used after
         access(self) let expiration: UFix64?
 
-         pub fun isExpired(): Bool {
+         access(all) view fun isExpired(): Bool {
             if let expiration = self.expiration {
                 return getCurrentBlock().timestamp >= expiration
             }
             return false
         }
 
-        pub init(provider: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
+        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>, filters: [{NFTFilter}], expiration: UFix64?) {
             self.provider = provider
             self.expiration = expiration
             self.filters = filters
         }
 
-        pub fun canWithdraw(_ id: UInt64): Bool {
+        access(all) fun canWithdraw(_ id: UInt64): Bool {
             if self.isExpired() {
                 return false
             }
 
-            let nft = self.provider.borrow()!.borrowNFT(id: id)
+            let nft = self.provider.borrow()!.borrowNFT(id)
             if nft == nil {
                 return false
             }
 
             var i = 0
             while i < self.filters.length {
-                if !self.filters[i].canWithdraw(nft) {
+                if !self.filters[i].canWithdraw(nft!) {
                     return false
                 }
                 i = i + 1
@@ -117,17 +117,17 @@ pub contract ScopedNFTProviders {
             return true
         }
 
-        pub fun check(): Bool {
+        access(all) fun check(): Bool {
             return self.provider.check()
         }
 
-        pub fun withdraw(withdrawID: UInt64): @NonFungibleToken.NFT {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
 
             let nft <- self.provider.borrow()!.withdraw(withdrawID: withdrawID)
-            let ref = &nft as &NonFungibleToken.NFT
+            let ref = &nft as &{NonFungibleToken.NFT}
 
             var i = 0
             while i < self.filters.length {
@@ -142,7 +142,7 @@ pub contract ScopedNFTProviders {
             return <-nft
         }
 
-        pub fun getDetails(): [{String: AnyStruct}] {
+        access(all) fun getDetails(): [{String: AnyStruct}] {
             let details: [{String: AnyStruct}] = []
             for f in self.filters {
                 details.append(f.getDetails())
@@ -152,8 +152,8 @@ pub contract ScopedNFTProviders {
         }
     }
 
-    pub fun createScopedNFTProvider(
-        provider: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
+    access(all) fun createScopedNFTProvider(
+        provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>,
         filters: [{NFTFilter}],
         expiration: UFix64?
     ): @ScopedNFTProvider {

package/contracts/flow-utils/StringUtils.cdc

@@ -1,16 +1,16 @@
 import "ArrayUtils"
 
-pub contract StringUtils {
-   
-    pub fun format(_ s: String, _ args: {String:String}): String{
-      var formatted = s
-      for key in args.keys{
-        formatted = StringUtils.replaceAll(formatted, "{".concat(key).concat("}"), args[key]!)
-      }
-      return formatted
+access(all) contract StringUtils {
+
+    access(all) fun format(_ s: String, _ args: {String:String}): String{
+        var formatted = s
+        for key in args.keys{
+            formatted = StringUtils.replaceAll(formatted, "{".concat(key).concat("}"), args[key]!)
+        }
+        return formatted
     }
 
-    pub fun explode(_ s: String): [String]{
+    access(all) fun explode(_ s: String): [String]{
         var chars : [String] =  []
         for i in ArrayUtils.range(0, s.length){
             chars.append(s[i].toString())
@@ -18,7 +18,7 @@ pub contract StringUtils {
         return chars
     }
 
-    pub fun trimLeft(_ s: String): String{
+    access(all) fun trimLeft(_ s: String): String{
         for i in ArrayUtils.range(0, s.length){
             if s[i] != " "{
                 return s.slice(from: i, upTo: s.length)
@@ -27,23 +27,23 @@ pub contract StringUtils {
         return ""
     }
 
-    pub fun trim(_ s: String): String{
+    access(all) fun trim(_ s: String): String{
         return self.trimLeft(s)
     }
 
-    pub fun replaceAll(_ s: String, _ search: String, _ replace: String): String{
-        return self.join(self.split(s, search), replace)
+    access(all) fun replaceAll(_ s: String, _ search: String, _ replace: String): String{
+        return s.replaceAll(of: search, with: replace)
     }
 
-    pub fun hasPrefix(_ s: String, _ prefix: String) : Bool{
+    access(all) fun hasPrefix(_ s: String, _ prefix: String) : Bool{
         return s.length >= prefix.length && s.slice(from:0, upTo: prefix.length)==prefix
     }
 
-    pub fun hasSuffix(_ s: String, _ suffix: String) : Bool{
+    access(all) fun hasSuffix(_ s: String, _ suffix: String) : Bool{
         return s.length >= suffix.length && s.slice(from:s.length-suffix.length, upTo: s.length)==suffix
     }
 
-    pub fun index(_ s : String, _ substr : String, _ startIndex: Int): Int?{
+    access(all) fun index(_ s : String, _ substr : String, _ startIndex: Int): Int?{
         for i in ArrayUtils.range(startIndex,s.length-substr.length+1){
             if s[i]==substr[0] && s.slice(from:i, upTo:i+substr.length) == substr{
                 return i
@@ -52,7 +52,7 @@ pub contract StringUtils {
         return nil
     }
 
-    pub fun count(_ s: String, _ substr: String): Int{
+    access(all) fun count(_ s: String, _ substr: String): Int{
         var pos = [self.index(s, substr, 0)]
         while pos[0]!=nil {
             pos.insert(at:0, self.index(s, substr, pos[0]!+pos.length*substr.length+1))
@@ -60,38 +60,25 @@ pub contract StringUtils {
         return pos.length-1
     }
 
-    pub fun contains(_ s: String, _ substr: String): Bool {
+    access(all) fun contains(_ s: String, _ substr: String): Bool {
         if let index =  self.index(s, substr, 0) {
             return true
         }
         return false
     }
 
-    pub fun substringUntil(_ s: String, _ until: String, _ startIndex: Int): String{
+    access(all) fun substringUntil(_ s: String, _ until: String, _ startIndex: Int): String{
         if let index = self.index( s, until, startIndex){
             return s.slice(from:startIndex, upTo: index)
         }
         return s.slice(from:startIndex, upTo:s.length)
     }
 
-    pub fun split(_ s: String, _ delimiter: String): [String] {
-        let segments: [String] = [] 
-        var p = 0
-        while p<=s.length{
-            var preDelimiter = self.substringUntil(s, delimiter, p)
-            segments.append(preDelimiter)
-            p = p + preDelimiter.length + delimiter.length 
-        }
-        return segments 
+    access(all) fun split(_ s: String, _ delimiter: String): [String] {
+        return s.split(separator: delimiter)
     }
 
-    pub fun join(_ strs: [String], _ separator: String): String {
-        var joinedStr = ""
-        for s in strs {
-            joinedStr = joinedStr.concat(s).concat(separator)
-        }
-        return joinedStr.slice(from: 0, upTo: joinedStr.length - separator.length)
+    access(all) fun join(_ strs: [String], _ separator: String): String {
+        return String.join(strs, separator: separator)
     }
-
-
 }

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowtyio/flow-contracts",
-    "version": "0.1.0-beta.4",
+    "version": "0.1.0-beta.6",
     "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",