@flowtyio/flow-contracts 0.0.18 → 0.1.0-beta.10

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 {
+        access(all) fun canWithdraw(_ nft: &{NonFungibleToken.NFT}): Bool {
             return self.ids[nft.id] != nil && self.ids[nft.id] == true
         }
 
-        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT) {
+        access(NonFungibleToken.Withdraw) fun markWithdrawn(_ nft: &{NonFungibleToken.NFT}) {
             self.ids[nft.id] = 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 | NonFungibleToken.Owner) 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,11 +152,12 @@ 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 {
         return <- create ScopedNFTProvider(provider: provider, filters: filters, expiration: expiration)
     }
 }
+

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/lost-and-found/FeeEstimator.cdc

@@ -11,49 +11,41 @@ import "FlowToken"
 
     Consumers of this contract would then need to pop the resource out of the DepositEstimate resource to get it back
  */
-pub contract FeeEstimator {
-    pub resource DepositEstimate {
-        pub var item: @AnyResource?
-        pub var storageFee: UFix64
+access(all) contract FeeEstimator {
+    access(all) resource DepositEstimate {
+        access(all) var item: @AnyResource?
+        access(all) var storageFee: UFix64
 
         init(item: @AnyResource, storageFee: UFix64) {
             self.item <- item
             self.storageFee = storageFee
         }
 
-        pub fun withdraw(): @AnyResource {
-            let resource <- self.item <- nil
-            return <-resource!
-        }
-
-        destroy() {
-            pre {
-                self.item == nil: "cannot destroy with non-null item"
-            }
-
-            destroy self.item
+        access(all) fun withdraw(): @AnyResource {
+            let r <- self.item <- nil
+            return <-r!
         }
     }
 
-    pub fun hasStorageCapacity(_ addr: Address, _ storageFee: UFix64): Bool {
+    access(all) fun hasStorageCapacity(_ addr: Address, _ storageFee: UFix64): Bool {
         return FlowStorageFees.defaultTokenAvailableBalance(addr) > storageFee
     }
 
-    pub fun estimateDeposit(
+    access(all) fun estimateDeposit(
         item: @AnyResource,
     ): @DepositEstimate {
-        let storageUsedBefore = FeeEstimator.account.storageUsed
-        FeeEstimator.account.save(<-item, to: /storage/temp)
-        let storageUsedAfter = FeeEstimator.account.storageUsed
+        let storageUsedBefore = FeeEstimator.account.storage.used
+        FeeEstimator.account.storage.save(<-item, to: /storage/temp)
+        let storageUsedAfter = FeeEstimator.account.storage.used
 
         let storageDiff = storageUsedAfter - storageUsedBefore
         let storageFee = FeeEstimator.storageUsedToFlowAmount(storageDiff)
-        let loadedItem <- FeeEstimator.account.load<@AnyResource>(from: /storage/temp)!
+        let loadedItem <- FeeEstimator.account.storage.load<@AnyResource>(from: /storage/temp)!
         let estimate <- create DepositEstimate(item: <-loadedItem, storageFee: storageFee)
         return <- estimate
     }
 
-    pub fun storageUsedToFlowAmount(_ storageUsed: UInt64): UFix64 {
+    access(all) fun storageUsedToFlowAmount(_ storageUsed: UInt64): UFix64 {
         let storageMB = FlowStorageFees.convertUInt64StorageBytesToUFix64Megabytes(storageUsed)
         return FlowStorageFees.storageCapacityToFlow(storageMB)
     }