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

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,8 +1,7 @@
 // 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)) {
+access(all) contract ArrayUtils {
+    access(all) fun rangeFunc(_ start: Int, _ end: Int, _ f: fun (Int): Void) {
         var current = start
         while current < end {
             f(current)
@@ -10,7 +9,7 @@ pub contract ArrayUtils {
         }
     }
 
-    pub fun range(_ start: Int, _ end: Int): [Int] {
+    access(all) fun range(_ start: Int, _ end: Int): [Int] {
         var res: [Int] = []
         self.rangeFunc(start, end, fun (i: Int) {
             res.append(i)
@@ -18,7 +17,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun reverse(_ array: [Int]): [Int] {
+    access(all) fun reverse(_ array: [Int]): [Int] {
         var res: [Int] = []
         var i: Int = array.length - 1
         while i >= 0 {
@@ -28,13 +27,13 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun transform(_ array: &[AnyStruct], _ f : ((AnyStruct): AnyStruct)){
+    access(all) fun transform(_ array: auth(Mutate) &[AnyStruct], _ f : fun (&AnyStruct, auth(Mutate) &[AnyStruct], Int)){
         for i in self.range(0, array.length){
-            array[i] = f(array[i])
+            f(array[i], array, i)
         }
     }
 
-    pub fun iterate(_ array: [AnyStruct], _ f : ((AnyStruct): Bool)){
+    access(all) fun iterate(_ array: [AnyStruct], _ f : fun (AnyStruct): Bool) {
         for item in array{
             if !f(item){
                 break
@@ -42,7 +41,7 @@ pub contract ArrayUtils {
         }
     }
 
-    pub fun map(_ array: [AnyStruct], _ f : ((AnyStruct): AnyStruct)) : [AnyStruct] {
+    access(all) fun map(_ array: [AnyStruct], _ f : fun (AnyStruct): AnyStruct) : [AnyStruct] {
         var res : [AnyStruct] = []
         for item in array{
             res.append(f(item))
@@ -50,7 +49,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun mapStrings(_ array: [String], _ f: ((String) : String) ) : [String] {
+    access(all) fun mapStrings(_ array: [String], _ f: fun (String) : String) : [String] {
         var res : [String] = []
         for item in array{
             res.append(f(item))
@@ -58,7 +57,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun reduce(_ array: [AnyStruct], _ initial: AnyStruct, _ f : ((AnyStruct, AnyStruct): AnyStruct)) : AnyStruct{
+    access(all) fun reduce(_ array: [AnyStruct], _ initial: AnyStruct, _ f : fun (AnyStruct, AnyStruct): AnyStruct) : AnyStruct{
         var res: AnyStruct = f(initial, array[0])
         for i in self.range(1, array.length){
             res =  f(res, array[i])

package/contracts/flow-utils/ScopedFTProviders.cdc

@@ -8,14 +8,14 @@ import "StringUtils"
 //
 // 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}
+access(all) contract ScopedFTProviders {
+    access(all) struct interface FTFilter {
+        access(all) view fun canWithdrawAmount(_ amount: UFix64): Bool
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64)
+        access(all) fun getDetails(): {String: AnyStruct}
     }
 
-    pub struct AllowanceFilter: FTFilter {
+    access(all) struct AllowanceFilter: FTFilter {
         access(self) let allowance: UFix64
         access(self) var allowanceUsed: UFix64
 
@@ -24,15 +24,15 @@ pub contract ScopedFTProviders {
             self.allowanceUsed = 0.0
         }
 
-        pub fun canWithdrawAmount(_ amount: UFix64): Bool {
+        access(all) view fun canWithdrawAmount(_ amount: UFix64): Bool {
             return amount + self.allowanceUsed <= self.allowance
         }
 
-        pub fun markAmountWithdrawn(_ amount: UFix64) {
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64) {
             self.allowanceUsed = self.allowanceUsed + amount
         }
 
-        pub fun getDetails(): {String: AnyStruct} {
+        access(all) fun getDetails(): {String: AnyStruct} {
             return {
                 "allowance": self.allowance,
                 "allowanceUsed": self.allowanceUsed
@@ -44,31 +44,35 @@ pub contract ScopedFTProviders {
     //
     // 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(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?
 
-        pub init(provider: Capability<&{FungibleToken.Provider}>, filters: [{FTFilter}], 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
         }
 
-        pub fun check(): Bool {
+        access(all) fun getProviderType(): Type {
+            return self.provider.borrow()!.getType()
+        }
+
+        access(all) fun check(): Bool {
             return self.provider.check()
         }
 
-        pub fun isExpired(): Bool {
+        access(all) view fun isExpired(): Bool {
             if let expiration = self.expiration {
                 return getCurrentBlock().timestamp >= expiration
             }
             return false
         }
 
-        pub fun canWithdraw(_ amount: UFix64): Bool {
+        access(all) view fun canWithdraw(_ amount: UFix64): Bool {
             if self.isExpired() {
                 return false
             }
@@ -82,7 +86,11 @@ pub contract ScopedFTProviders {
             return true
         }
 
-        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.canWithdraw(amount)
+        }
+
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -100,7 +108,7 @@ pub contract ScopedFTProviders {
             return <-self.provider.borrow()!.withdraw(amount: amount)
         }
 
-        pub fun getDetails(): [{String: AnyStruct}] {
+        access(all) fun getDetails(): [{String: AnyStruct}] {
             let details: [{String: AnyStruct}] = []
             for filter in self.filters {
                 details.append(filter.getDetails())
@@ -110,8 +118,8 @@ pub contract ScopedFTProviders {
         }
     }
 
-    pub fun createScopedFTProvider(
-        provider: Capability<&{FungibleToken.Provider}>,
+    access(all) fun createScopedFTProvider(
+        provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>,
         filters: [{FTFilter}],
         expiration: UFix64?
     ): @ScopedFTProvider {

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,43 @@ 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)
+            if !self.provider.check() {
+                return false
+            }
+
+            let nft: &{NonFungibleToken.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 +121,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 +146,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 +156,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/flowty-drops/ContractManager.cdc

@@ -0,0 +1,47 @@
+import "FlowToken"
+import "FungibleToken"
+
+access(all) contract ContractManager {
+    access(all) let StoragePath: StoragePath
+    access(all) let PublicPath: PublicPath
+
+    access(all) entitlement Manage
+
+    access(all) resource Manager {
+        access(self) let acct: Capability<auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account>
+
+        access(Manage) fun borrowContractAccount(): auth(Contracts) &Account {
+            return self.acct.borrow()!
+        }
+
+        access(all) fun addFlowTokensToAccount(_ tokens: @FlowToken.Vault) {
+            self.acct.borrow()!.storage.borrow<&{FungibleToken.Receiver}>(from: /storage/flowTokenVault)!.deposit(from: <-tokens)
+        }
+
+        access(all) fun getAccount(): &Account {
+            return getAccount(self.acct.address)
+        }
+
+        init(tokens: @FlowToken.Vault) {
+            pre {
+                tokens.balance >= 0.001: "minimum balance of 0.001 required for initialization"
+            }
+
+            let acct = Account(payer: ContractManager.account)
+            self.acct = acct.capabilities.account.issue<auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account>()
+            assert(self.acct.check(), message: "failed to setup account capability")
+
+            acct.storage.borrow<&{FungibleToken.Receiver}>(from: /storage/flowTokenVault)!.deposit(from: <-tokens)
+        }
+    }
+
+    access(all) fun createManager(tokens: @FlowToken.Vault): @Manager {
+        return <- create Manager(tokens: <- tokens)
+    }
+
+    init() {
+        let identifier = "ContractManager_".concat(self.account.address.toString())
+        self.StoragePath = StoragePath(identifier: identifier)!
+        self.PublicPath = PublicPath(identifier: identifier)!
+    }
+}