@flowtyio/flow-contracts 0.0.15 → 0.0.17

package/README.md

@@ -57,6 +57,11 @@ Currently, the list includes:
 | TokenForwarding | 0x51ea0e37c27a1f1a | 0xe544175ee0461c4b |
 | DapperUtilityCoin | 0x82ec283f88a62e65 | 0xead892083b3e2c6c |
 | FlowUtilityToken | 0x82ec283f88a62e65 | 0xead892083b3e2c6c |
+| ArrayUtils| 0x31ad40c07a2a9788 | 0xa340dc0a4ec828ab |
+| StringUtils| 0x31ad40c07a2a9788 | 0xa340dc0a4ec828ab |
+| AddressUtils | 0x31ad40c07a2a9788 | 0xa340dc0a4ec828ab |
+| ScopedNFTProviders | 0x31ad40c07a2a9788 | 0xa340dc0a4ec828ab |
+| ScopedFTProviders | 0x31ad40c07a2a9788 | 0xa340dc0a4ec828ab |
 
 
 ## Using a contract

package/contracts/flow-utils/AddressUtils.cdc

@@ -0,0 +1,109 @@
+import "StringUtils"
+
+pub contract AddressUtils {
+
+    pub fun withoutPrefix(_ input: String): String {
+        var address = input
+
+        // get rid of 0x
+        if address.length > 1 && address.utf8[1] == 120 {
+            address = address.slice(from: 2, upTo: address.length)
+        }
+
+        // ensure even length
+        if address.length % 2 == 1 {
+            address = "0".concat(address)
+        }
+        return address
+    }
+
+    pub fun parseUInt64(_ input: AnyStruct): UInt64? {
+        var stringValue = ""
+
+        if let string = input as? String {
+            stringValue = string
+        } else if let address = input as? Address {
+            stringValue = address.toString()
+        } else if let type = input as? Type {
+            let parts = StringUtils.split(type.identifier, ".")
+            if parts.length == 1 {
+                return nil
+            }
+            stringValue = parts[1]
+        } else {
+            return nil
+        }
+
+        let address = self.withoutPrefix(stringValue)
+        let bytes = address.decodeHex()
+        var r: UInt64 = 0
+        var length = bytes.length
+        for byte in bytes {
+            length = length - 1
+            r = r + (UInt64(byte) << UInt64(length * 8))
+        }
+        return r
+    }
+
+    pub fun parseAddress(_ input: AnyStruct): Address? {
+        if let parsed = self.parseUInt64(input) {
+            return Address(parsed)
+        }
+        return nil
+    }
+
+    pub fun isValidAddress(_ input: AnyStruct, forNetwork: String): Bool {
+        let address = self.parseUInt64(input)
+        if address == nil {
+            return false
+        }
+
+        let codeWords: {String: UInt64} = {
+            "MAINNET" : 0,
+            "TESTNET" : 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
+        ]
+
+        var parity: UInt64 = 0
+        var codeWord: UInt64 = codeWords[forNetwork]!
+        codeWord = codeWord ^ address!
+
+        if codeWord == 0 {
+            return false
+        }
+
+        for column in parityCheckMatrixColumns{
+            if codeWord & 1 == 1 {
+                parity = parity ^ column
+            }
+            codeWord = codeWord >> 1
+        }
+
+        return parity == 0 && codeWord == 0
+    }
+
+    pub fun getNetworkFromAddress(_ input: AnyStruct): String? {
+        for network in ["MAINNET", "TESTNET", "EMULATOR"]{
+            if self.isValidAddress(input, forNetwork: network){
+                return network
+            }
+        }
+        return nil
+    }
+
+    pub fun currentNetwork(): String {
+        return self.getNetworkFromAddress(self.account.address)!
+    }
+
+}

package/contracts/flow-utils/ArrayUtils.cdc

@@ -0,0 +1,69 @@
+// Copied from https://github.com/bluesign/flow-utils/blob/dnz/cadence/contracts/ArrayUtils.cdc with minor adjustments
+
+pub contract ArrayUtils {
+
+    pub fun rangeFunc(_ start: Int, _ end: Int, _ f: ((Int): Void)) {
+        var current = start
+        while current < end {
+            f(current)
+            current = current + 1
+        }
+    }
+
+    pub fun range(_ start: Int, _ end: Int): [Int] {
+        var res: [Int] = []
+        self.rangeFunc(start, end, fun (i: Int) {
+            res.append(i)
+        })
+        return res
+    }
+
+    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
+        }
+        return res
+    }
+
+    pub fun transform(_ array: &[AnyStruct], _ f : ((AnyStruct): AnyStruct)){
+        for i in self.range(0, array.length){
+            array[i] = f(array[i])
+        }
+    }
+
+    pub fun iterate(_ array: [AnyStruct], _ f : ((AnyStruct): Bool)){
+        for item in array{
+            if !f(item){
+                break
+            }
+        }
+    }
+
+    pub fun map(_ array: [AnyStruct], _ f : ((AnyStruct): AnyStruct)) : [AnyStruct] {
+        var res : [AnyStruct] = []
+        for item in array{
+            res.append(f(item))
+        }
+        return res
+    }
+
+    pub fun mapStrings(_ array: [String], _ f: ((String) : String) ) : [String] {
+        var res : [String] = []
+        for item in array{
+            res.append(f(item))
+        }
+        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])
+        }
+        return res
+    }
+
+}

package/contracts/flow-utils/ScopedFTProviders.cdc

@@ -0,0 +1,120 @@
+import "FungibleToken"
+import "StringUtils"
+
+// 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.
+pub contract ScopedFTProviders {
+    pub struct interface FTFilter {
+        pub fun canWithdrawAmount(_ amount: UFix64): Bool
+        pub fun markAmountWithdrawn(_ amount: UFix64)
+        pub fun getDetails(): {String: AnyStruct}
+    }
+
+    pub struct AllowanceFilter: FTFilter {
+        access(self) let allowance: UFix64
+        access(self) var allowanceUsed: UFix64
+
+        init(_ allowance: UFix64) {
+            self.allowance = allowance
+            self.allowanceUsed = 0.0
+        }
+
+        pub fun canWithdrawAmount(_ amount: UFix64): Bool {
+            return amount + self.allowanceUsed <= self.allowance
+        }
+
+        pub fun markAmountWithdrawn(_ amount: UFix64) {
+            self.allowanceUsed = self.allowanceUsed + amount
+        }
+
+        pub fun getDetails(): {String: AnyStruct} {
+            return {
+                "allowance": self.allowance,
+                "allowanceUsed": self.allowanceUsed
+            }
+        }
+    }
+
+    // ScopedFTProvider
+    //
+    // A ScopedFTProvider is a wrapped FungibleTokenProvider with
+    // filters that can be defined by anyone using the ScopedFTProvider.
+    pub resource ScopedFTProvider: FungibleToken.Provider {
+        access(self) let provider: Capability<&{FungibleToken.Provider}>
+        access(self) var filters: [{FTFilter}]
+
+        // block timestamp that this provider can no longer be used after
+        access(self) let expiration: UFix64?
+
+        pub init(provider: Capability<&{FungibleToken.Provider}>, filters: [{FTFilter}], expiration: UFix64?) {
+            self.provider = provider
+            self.filters = filters
+            self.expiration = expiration
+        }
+
+        pub fun check(): Bool {
+            return self.provider.check()
+        }
+
+        pub fun isExpired(): Bool {
+            if let expiration = self.expiration {
+                return getCurrentBlock().timestamp >= expiration
+            }
+            return false
+        }
+
+        pub fun canWithdraw(_ amount: UFix64): Bool {
+            if self.isExpired() {
+                return false
+            }
+
+            for filter in self.filters {
+                if !filter.canWithdrawAmount(amount) {
+                    return false
+                }
+            }
+
+            return true
+        }
+
+        pub 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)
+        }
+
+        pub fun getDetails(): [{String: AnyStruct}] {
+            let details: [{String: AnyStruct}] = []
+            for filter in self.filters {
+                details.append(filter.getDetails())
+            }
+
+            return details
+        }
+    }
+
+    pub fun createScopedFTProvider(
+        provider: Capability<&{FungibleToken.Provider}>,
+        filters: [{FTFilter}],
+        expiration: UFix64?
+    ): @ScopedFTProvider {
+        return <- create ScopedFTProvider(provider: provider, filters: filters, expiration: expiration)
+    }
+}

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -0,0 +1,162 @@
+import "NonFungibleToken"
+import "StringUtils"
+
+// ScopedNFTProviders
+//
+// TO AVOID RISK, PLEASE DEPLOY YOUR OWN VERSION OF THIS CONTRACT SO THAT
+// MALICIOUS UPDATES ARE NOT POSSIBLE
+//
+// ScopedNFTProviders are meant to solve the issue of unbounded access to NFT Collections.
+// A provider can be given extensible filters which allow limited access to resources based on any trait on the NFT itself.
+//
+// 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}
+    }
+
+    pub 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}
+
+        init(_ ids: [UInt64]) {
+            let d: {UInt64: Bool} = {}
+            for i in ids {
+                d[i] = true
+            }
+            self.ids = d
+        }
+
+        pub fun canWithdraw(_ nft: &NonFungibleToken.NFT): Bool {
+            return self.ids[nft.id] != nil && self.ids[nft.id] == true
+        }
+
+        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT) {
+            self.ids[nft.id] = false
+        }
+
+        pub fun getDetails(): {String: AnyStruct} {
+            return {
+                "ids": self.ids
+            }
+        }
+    }
+
+    pub 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}
+
+        init(_ uuids: [UInt64]) {
+            let d: {UInt64: Bool} = {}
+            for i in uuids {
+                d[i] = true
+            }
+            self.uuids = d
+        }
+
+        pub fun canWithdraw(_ nft: &NonFungibleToken.NFT): Bool {
+            return self.uuids[nft.uuid] != nil && self.uuids[nft.uuid]! == true
+        }
+
+        pub fun markWithdrawn(_ nft: &NonFungibleToken.NFT) {
+            self.uuids[nft.uuid] = false
+        }
+
+        pub fun getDetails(): {String: AnyStruct} {
+            return {
+                "uuids": self.uuids
+            }
+        }
+    }
+
+    // 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(self) let filters: [{NFTFilter}]
+
+        // block timestamp that this provider can no longer be used after
+        access(self) let expiration: UFix64?
+
+         pub 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?) {
+            self.provider = provider
+            self.expiration = expiration
+            self.filters = filters
+        }
+
+        pub fun canWithdraw(_ id: UInt64): Bool {
+            if self.isExpired() {
+                return false
+            }
+
+            let nft = self.provider.borrow()!.borrowNFT(id: id)
+            if nft == nil {
+                return false
+            }
+
+            var i = 0
+            while i < self.filters.length {
+                if !self.filters[i].canWithdraw(nft) {
+                    return false
+                }
+                i = i + 1
+            }
+            return true
+        }
+
+        pub fun check(): Bool {
+            return self.provider.check()
+        }
+
+        pub 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
+
+            var i = 0
+            while i < self.filters.length {
+                if !self.filters[i].canWithdraw(ref) {
+                    panic(StringUtils.join(["cannot withdraw nft. filter of type", self.filters[i].getType().identifier, "failed."], " "))
+                }
+
+                self.filters[i].markWithdrawn(ref)
+                i = i + 1
+            }
+
+            return <-nft
+        }
+
+        pub fun getDetails(): [{String: AnyStruct}] {
+            let details: [{String: AnyStruct}] = []
+            for f in self.filters {
+                details.append(f.getDetails())
+            }
+
+            return details
+        }
+    }
+
+    pub fun createScopedNFTProvider(
+        provider: Capability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
+        filters: [{NFTFilter}],
+        expiration: UFix64?
+    ): @ScopedNFTProvider {
+        return <- create ScopedNFTProvider(provider: provider, filters: filters, expiration: expiration)
+    }
+}

package/contracts/flow-utils/StringUtils.cdc

@@ -0,0 +1,97 @@
+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
+    }
+
+    pub fun explode(_ s: String): [String]{
+        var chars : [String] =  []
+        for i in ArrayUtils.range(0, s.length){
+            chars.append(s[i].toString())
+        }  
+        return chars
+    }
+
+    pub fun trimLeft(_ s: String): String{
+        for i in ArrayUtils.range(0, s.length){
+            if s[i] != " "{
+                return s.slice(from: i, upTo: s.length)
+            }
+        }
+        return ""
+    }
+
+    pub 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)
+    }
+
+    pub 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{
+        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?{
+        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
+            }
+        }
+        return nil
+    }
+
+    pub 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))
+        }
+        return pos.length-1
+    }
+
+    pub 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{
+        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 
+    }
+
+    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)
+    }
+
+
+}

package/flow.json

@@ -267,6 +267,46 @@
         "testnet": "0x8a5f647e58dde1ee",
         "mainnet": "0xb8ea91944fd51c43"
       }
+    },
+    "ArrayUtils": {
+      "source": "./contracts/flow-utils/ArrayUtils.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x31ad40c07a2a9788",
+        "mainnet": "0xa340dc0a4ec828ab"
+      }
+    },
+    "StringUtils": {
+      "source": "./contracts/flow-utils/StringUtils.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x31ad40c07a2a9788",
+        "mainnet": "0xa340dc0a4ec828ab"
+      }
+    },
+    "AddressUtils": {
+      "source": "./contracts/flow-utils/AddressUtils.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x31ad40c07a2a9788",
+        "mainnet": "0xa340dc0a4ec828ab"
+      }
+    },
+    "ScopedFTProviders": {
+      "source": "./contracts/flow-utils/ScopedFTProviders.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x31ad40c07a2a9788",
+        "mainnet": "0xa340dc0a4ec828ab"
+      }
+    },
+    "ScopedNFTProviders": {
+      "source": "./contracts/flow-utils/ScopedNFTProviders.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x31ad40c07a2a9788",
+        "mainnet": "0xa340dc0a4ec828ab"
+      }
     }
   },
   "deployments": {
@@ -288,7 +328,12 @@
         "DapperOffersV2",
         "OffersV2",
         "TopShot",
-        "TopShotLocking"
+        "TopShotLocking",
+        "ArrayUtils",
+        "StringUtils",
+        "AddressUtils",
+        "ScopedNFTProviders",
+        "ScopedFTProviders"
       ],
       "emulator-ft": [
         "FungibleToken",

package/package.json

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