@flowtyio/flow-contracts 0.1.5 → 0.1.7

package/contracts/example/ExampleToken.cdc

@@ -1,10 +1,8 @@
 import "FungibleToken"
-import "FungibleTokenMetadataViews"
 import "MetadataViews"
+import "FungibleTokenMetadataViews"
 
-
-// THIS CONTRACT IS FOR TESTING PURPOSES ONLY!
-access(all) contract ExampleToken {
+access(all) contract ExampleToken: FungibleToken {
 
     /// Total supply of ExampleTokens in existence
     access(all) var totalSupply: UFix64
@@ -66,32 +64,36 @@ access(all) contract ExampleToken {
             self.balance = balance
         }
 
-        access(all) view fun getBalance(): UFix64 {
-            return self.balance
-        }
-
-        access(all) view fun getDefaultStoragePath(): StoragePath? {
-            return /storage/exampleTokenVault
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return amount <= self.balance
         }
 
-        access(all) view fun getDefaultPublicPath(): PublicPath? {
-            return /public/exampleTokenPublic
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {self.getType(): true}
         }
 
-        access(all) view fun getDefaultReceiverPath(): PublicPath? {
-            return /public/exampleTokenPublic
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            if (type == self.getType()) { return true } else { return false }
         }
 
-        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
-            return self.balance >= amount
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <-create Vault(balance: 0.0)
         }
 
-        /// Same as getViews above, but on a specific NFT instead of a contract
-        access(all) view fun getViews(): [Type] {
+        /// Get all the Metadata Views implemented by ExampleToken
+        ///
+        /// @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]{
             return ExampleToken.getContractViews(resourceType: nil)
         }
 
-        /// Same as resolveView above, but on a specific NFT instead of a contract
+        /// Get a Metadata View from ExampleToken
+        ///
+        /// @param view: The Type of the desired view.
+        /// @return A structure representing the requested view.
+        ///
         access(all) fun resolveView(_ view: Type): AnyStruct? {
             return ExampleToken.resolveContractView(resourceType: nil, viewType: view)
         }
@@ -112,16 +114,6 @@ access(all) contract ExampleToken {
             return <-create Vault(balance: amount)
         }
 
-        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
-            return {
-                Type<@ExampleToken.Vault>(): true
-            }
-        }
-
-        access(all) view fun isSupportedVaultType(type: Type): Bool {
-            return type == Type<@ExampleToken.Vault>()
-        }
-
         /// deposit
         ///
         /// Function that takes a Vault object as an argument and adds
@@ -139,8 +131,8 @@ access(all) contract ExampleToken {
             destroy vault
         }
 
-        access(all) fun createEmptyVault(): @Vault {
-            return <- ExampleToken.createEmptyVault()
+        access(contract) fun burnCallback() {
+            ExampleToken.totalSupply = ExampleToken.totalSupply - self.balance
         }
     }
 
@@ -151,7 +143,7 @@ access(all) contract ExampleToken {
     /// and store the returned Vault in their storage in order to allow their
     /// account to be able to receive deposits of this token type.
     ///
-    access(all) fun createEmptyVault(): @Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @Vault {
         return <-create Vault(balance: 0.0)
     }
 
@@ -227,6 +219,7 @@ access(all) contract ExampleToken {
         }
     }
 
+    /// Gets a list of the metadata views that this contract supports
     access(all) view fun getContractViews(resourceType: Type?): [Type] {
         return [Type<FungibleTokenMetadataViews.FTView>(),
                 Type<FungibleTokenMetadataViews.FTDisplay>(),
@@ -234,6 +227,21 @@ access(all) contract ExampleToken {
                 Type<FungibleTokenMetadataViews.TotalSupply>()]
     }
 
+    access(all) fun mintTokens(amount: UFix64): @{FungibleToken.Vault} {
+        let admin = self.account.storage.borrow<&Administrator>(from: /storage/exampleTokenAdmin)!
+        let minter <- admin.createNewMinter(allowedAmount: amount)
+
+        let tokens <- minter.mintTokens(amount: amount)
+        destroy minter
+
+        return <- tokens
+    }
+
+    /// Get a Metadata View from ExampleToken
+    ///
+    /// @param view: The Type of the desired view.
+    /// @return A structure representing the requested view.
+    ///
     access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
         switch viewType {
             case Type<FungibleTokenMetadataViews.FTView>():
@@ -244,15 +252,15 @@ access(all) contract ExampleToken {
             case Type<FungibleTokenMetadataViews.FTDisplay>():
                 let media = MetadataViews.Media(
                         file: MetadataViews.HTTPFile(
-                        url: "https://example.com"
+                        url: "example.com"
                     ),
                     mediaType: "image/svg+xml"
                 )
                 let medias = MetadataViews.Medias([media])
                 return FungibleTokenMetadataViews.FTDisplay(
-                    name: "Example Token",
+                    name: "EXAMPLE Token",
                     symbol: "EXAMPLE",
-                    description: "",
+                    description: "This is an example token",
                     externalURL: MetadataViews.ExternalURL("https://flow.com"),
                     logos: medias,
                     socials: {
@@ -286,11 +294,10 @@ access(all) contract ExampleToken {
         let vault <- create Vault(balance: self.totalSupply)
         self.account.storage.save(<-vault, to: /storage/exampleTokenVault)
 
-        // Create a public capability to the stored Vault that only exposes
-        // the `deposit` method through the `Receiver` interface
-        //
-        let publicCap = self.account.capabilities.storage.issue<&ExampleToken.Vault>(/storage/exampleTokenVault)
-        self.account.capabilities.publish(publicCap, at: /public/exampleTokenPublic)
+        let cap = self.account.capabilities.storage.issue<&{FungibleToken.Vault}>(/storage/exampleTokenVault)
+        self.account.capabilities.publish(cap, at: /public/exampleTokenReceiver)
+        self.account.capabilities.publish(cap, at: /public/exampleTokenBalance)
+
 
         let admin <- create Administrator()
         self.account.storage.save(<-admin, to: /storage/exampleTokenAdmin)

package/contracts/flowty-drops/ContractManager.cdc

@@ -1,6 +1,13 @@
 import "FlowToken"
 import "FungibleToken"
 import "FungibleTokenRouter"
+import "HybridCustody"
+import "MetadataViews"
+import "ViewResolver"
+import "AddressUtils"
+import "CapabilityFactory"
+import "CapabilityFilter"
+import "FungibleTokenMetadataViews"
 
 access(all) contract ContractManager {
     access(all) let StoragePath: StoragePath
@@ -58,6 +65,7 @@ access(all) contract ContractManager {
                 )
             }
 
+            self.configureHybridCustody(acct: acct)
             emit ManagerSaved(uuid: self.uuid, contractAddress: self.acct.address, ownerAddress: self.owner!.address)
         }
 
@@ -72,6 +80,9 @@ access(all) contract ContractManager {
 
             acct.storage.borrow<&{FungibleToken.Receiver}>(from: /storage/flowTokenVault)!.deposit(from: <-tokens)
 
+            // setup a provider capability so that tokens are accessible via hybrid custody
+            acct.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(/storage/flowTokenVault)
+
             let router <- FungibleTokenRouter.createRouter(defaultAddress: defaultRouterAddress)
             acct.storage.save(<-router, to: FungibleTokenRouter.StoragePath)
 
@@ -84,6 +95,121 @@ access(all) contract ContractManager {
             self.data = {}
             self.resources <- {}
         }
+
+        access(self) fun configureHybridCustody(acct: auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account) {
+            if acct.storage.borrow<&HybridCustody.OwnedAccount>(from: HybridCustody.OwnedAccountStoragePath) == nil {
+                let ownedAccount <- HybridCustody.createOwnedAccount(acct: self.acct)
+                acct.storage.save(<-ownedAccount, to: HybridCustody.OwnedAccountStoragePath)
+            }
+
+            let owned = acct.storage.borrow<auth(HybridCustody.Owner) &HybridCustody.OwnedAccount>(from: HybridCustody.OwnedAccountStoragePath)
+                ?? panic("owned account not found")
+
+            let thumbnail = MetadataViews.HTTPFile(url: "https://avatars.flowty.io/6.x/thumbs/png?seed=".concat(self.acct.address.toString()))
+            let display = MetadataViews.Display(name: "Creator Hub", description: "Created by the Flowty Creator Hub", thumbnail: thumbnail)
+            owned.setDisplay(display)
+
+            if !acct.capabilities.get<&{HybridCustody.OwnedAccountPublic, ViewResolver.Resolver}>(HybridCustody.OwnedAccountPublicPath).check() {
+                acct.capabilities.unpublish(HybridCustody.OwnedAccountPublicPath)
+                acct.capabilities.storage.issue<&{HybridCustody.BorrowableAccount, HybridCustody.OwnedAccountPublic, ViewResolver.Resolver}>(HybridCustody.OwnedAccountStoragePath)
+                acct.capabilities.publish(
+                    acct.capabilities.storage.issue<&{HybridCustody.OwnedAccountPublic, ViewResolver.Resolver}>(HybridCustody.OwnedAccountStoragePath),
+                    at: HybridCustody.OwnedAccountPublicPath
+                )
+            }
+
+            // make sure that only the owner of this resource is a valid parent
+            let parents = owned.getParentAddresses()
+            let owner = self.owner!.address
+            var foundOwner = false
+            for parent in parents {
+                if parent == owner {
+                    foundOwner = true
+                    continue
+                }
+
+                // found a parent that should not be present
+                owned.removeParent(parent: parent)
+            }
+
+            if foundOwner {
+                return
+            }
+
+            // Flow maintains a set of pre-configured filter and factory resources that we will use:
+            // https://github.com/onflow/hybrid-custody?tab=readme-ov-file#hosted-capabilityfactory--capabilityfilter-implementations
+            var factoryAddress = ContractManager.account.address
+            var filterAddress = ContractManager.account.address
+            if let network = AddressUtils.getNetworkFromAddress(ContractManager.account.address) {
+                switch network {
+                    case "TESTNET":
+                        factoryAddress = Address(0x1b7fa5972fcb8af5)
+                        filterAddress = Address(0xe2664be06bb0fe62)
+                        break
+                    case "MAINNET":
+                        factoryAddress = Address(0x071d382668250606)
+                        filterAddress = Address(0x78e93a79b05d0d7d)
+                        break
+                }
+            }
+
+            owned.publishToParent(
+                parentAddress: owner,
+                factory: getAccount(factoryAddress!).capabilities.get<&CapabilityFactory.Manager>(CapabilityFactory.PublicPath),
+                filter: getAccount(filterAddress!).capabilities.get<&{CapabilityFilter.Filter}>(CapabilityFilter.PublicPath)
+            )
+        }
+
+        // Configure a given fungible token vault so that it can be received by this contract account
+        access(Manage) fun configureVault(vaultType: Type) {
+            pre {
+                vaultType.isSubtype(of: Type<@{FungibleToken.Vault}>()): "vault must be a fungible token"
+            }
+
+            let address = AddressUtils.parseAddress(vaultType)!
+            let name = vaultType.identifier.split(separator: ".")[2]
+
+            let ftContract = getAccount(address).contracts.borrow<&{FungibleToken}>(name: name)
+                ?? panic("vault contract does not implement FungibleToken")
+            let data = ftContract.resolveContractView(resourceType: vaultType, viewType: Type<FungibleTokenMetadataViews.FTVaultData>())! as! FungibleTokenMetadataViews.FTVaultData
+
+            let acct = self.acct.borrow()!
+            if acct.storage.type(at: data.storagePath) == nil {
+                acct.storage.save(<- ftContract.createEmptyVault(vaultType: vaultType), to: data.storagePath)
+            }
+
+            if !acct.capabilities.get<&{FungibleToken.Receiver}>(data.receiverPath).check() {
+                acct.capabilities.unpublish(data.receiverPath)
+                acct.capabilities.publish(
+                    acct.capabilities.storage.issue<&{FungibleToken.Receiver}>(data.storagePath),
+                    at: data.receiverPath
+                )
+            }
+
+            if !acct.capabilities.get<&{FungibleToken.Receiver}>(data.metadataPath).check() {
+                acct.capabilities.unpublish(data.metadataPath)
+                acct.capabilities.publish(
+                    acct.capabilities.storage.issue<&{FungibleToken.Vault}>(data.storagePath),
+                    at: data.metadataPath
+                )
+            }
+
+            // is there a valid provider capability for this vault type?
+            var foundProvider = false
+            for controller in acct.capabilities.storage.getControllers(forPath: data.storagePath) {
+                if controller.borrowType.isSubtype(of: Type<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>()) {
+                    foundProvider = true
+                    break
+                }
+            }
+
+            if foundProvider {
+                return
+            }
+
+            // we did not find a provider, issue one so that its parent account is able to access it.
+            acct.capabilities.storage.issue<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>(data.storagePath)
+        }
     }
 
     access(all) fun createManager(tokens: @FlowToken.Vault, defaultRouterAddress: Address): @Manager {

package/flow.json

@@ -359,7 +359,7 @@
       "source": "./contracts/flowty-drops/ContractManager.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -367,7 +367,7 @@
       "source": "./contracts/flowty-drops/initializers/ContractInitializer.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -375,7 +375,7 @@
       "source": "./contracts/flowty-drops/initializers/ContractBorrower.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -383,7 +383,7 @@
       "source": "./contracts/flowty-drops/initializers/OpenEditionInitializer.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -391,7 +391,7 @@
       "source": "./contracts/flowty-drops/nft/BaseCollection.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -399,7 +399,7 @@
       "source": "./contracts/flowty-drops/nft/ContractFactoryTemplate.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -407,7 +407,7 @@
       "source": "./contracts/flowty-drops/nft/ContractFactory.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -415,7 +415,7 @@
       "source": "./contracts/flowty-drops/nft/OpenEditionTemplate.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -423,7 +423,7 @@
       "source": "./contracts/flowty-drops/nft/UniversalCollection.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -431,7 +431,7 @@
       "source": "./contracts/flowty-drops/nft/BaseNFT.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -439,7 +439,7 @@
       "source": "./contracts/flowty-drops/nft/NFTMetadata.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -447,7 +447,7 @@
       "source": "./contracts/flowty-drops/FlowtyDrops.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -455,7 +455,7 @@
       "source": "./contracts/flowty-drops/DropFactory.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -463,7 +463,7 @@
       "source": "./contracts/flowty-drops/FlowtyActiveCheckers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -471,7 +471,7 @@
       "source": "./contracts/flowty-drops/FlowtyPricers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -479,7 +479,7 @@
       "source": "./contracts/flowty-drops/FlowtyAddressVerifiers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x5d06d5357cdf8063",
+        "testnet": "0xea3e1b74e99dc035",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -487,7 +487,7 @@
       "source": "./contracts/flowty-drops/DropTypes.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0xa8d83f18fd8ba80a",
+        "testnet": "0xfc6a7e477099ca54",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },

package/package.json

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