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

package/contracts/TokenForwarding.cdc

@@ -16,29 +16,37 @@ their tokens to.
 
 import "FungibleToken"
 
-pub contract TokenForwarding {
+access(all) contract TokenForwarding {
 
     // Event that is emitted when tokens are deposited to the target receiver
-    pub event ForwardedDeposit(amount: UFix64, from: Address?)
+    access(all) event ForwardedDeposit(amount: UFix64, from: Address?)
 
-    pub resource interface ForwarderPublic {
-        pub fun check(): Bool
-        pub fun safeBorrow(): &{FungibleToken.Receiver}?
+    access(all) resource interface ForwarderPublic {
+        access(all) fun check(): Bool
+        access(all) fun safeBorrow(): &{FungibleToken.Receiver}?
     }
 
-    pub resource Forwarder: FungibleToken.Receiver, ForwarderPublic {
+    access(all) resource Forwarder: FungibleToken.Receiver, ForwarderPublic {
 
         // This is where the deposited tokens will be sent.
         // The type indicates that it is a reference to a receiver
         //
         access(self) var recipient: Capability
 
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return true
+        }
+
         // deposit
         //
         // Function that takes a Vault object as an argument and forwards
         // it to the recipient's Vault using the stored reference
         //
-        pub fun deposit(from: @FungibleToken.Vault) {
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let receiverRef = self.recipient.borrow<&{FungibleToken.Receiver}>()!
 
             let balance = from.balance
@@ -48,17 +56,17 @@ pub contract TokenForwarding {
             emit ForwardedDeposit(amount: balance, from: self.owner?.address)
         }
 
-        pub fun check(): Bool {
+        access(all) fun check(): Bool {
             return self.recipient.check<&{FungibleToken.Receiver}>()
         }
 
-        pub fun safeBorrow(): &{FungibleToken.Receiver}? {
+        access(all) fun safeBorrow(): &{FungibleToken.Receiver}? {
             return self.recipient.borrow<&{FungibleToken.Receiver}>()
         }
 
         // changeRecipient changes the recipient of the forwarder to the provided recipient
         //
-        pub fun changeRecipient(_ newRecipient: Capability) {
+        access(all) fun changeRecipient(_ newRecipient: Capability) {
             pre {
                 newRecipient.borrow<&{FungibleToken.Receiver}>() != nil: "Could not borrow Receiver reference from the Capability"
             }
@@ -75,7 +83,7 @@ pub contract TokenForwarding {
 
     // createNewForwarder creates a new Forwarder reference with the provided recipient
     //
-    pub fun createNewForwarder(recipient: Capability): @Forwarder {
+    access(all) fun createNewForwarder(recipient: Capability): @Forwarder {
         return <-create Forwarder(recipient: recipient)
     }
 }

package/contracts/ViewResolver.cdc

@@ -1,43 +1,47 @@
-// Taken from the NFT Metadata standard, this contract exposes an interface to let
+// Taken from the NFT Metadata standard, this contract exposes an interface to let 
 // anyone borrow a contract and resolve views on it.
 //
 // This will allow you to obtain information about a contract without necessarily knowing anything about it.
 // All you need is its address and name and you're good to go!
 access(all) contract interface ViewResolver {
 
-    /// Function that returns all the Metadata Views implemented by the resolving contract
+    /// Function that returns all the Metadata Views implemented by the resolving contract.
+    /// Some contracts may have multiple resource types that support metadata views
+    /// so there there is an optional parameter for specify which resource type the caller
+    /// is looking for views for.
+    /// Some contract-level views may be type-agnostic. In that case, the contract
+    /// should return the same views regardless of what type is passed in.
     ///
+    /// @param resourceType: An optional resource type to return views for
     /// @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 []
-    }
+    access(all) view fun getContractViews(resourceType: Type?): [Type]
 
     /// Function that resolves a metadata view for this token.
+    /// Some contracts may have multiple resource types that support metadata views
+    /// so there there is an optional parameter for specify which resource type the caller
+    /// is looking for views for.
+    /// Some contract-level views may be type-agnostic. In that case, the contract
+    /// should return the same views regardless of what type is passed in.
     ///
+    /// @param resourceType: An optional resource type to return views for
     /// @param view: The Type of the desired view.
     /// @return A structure representing the requested view.
     ///
-    access(all) fun resolveView(_ view: Type): AnyStruct? {
-        return nil
-    }
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct?
 
-    /// Provides access to a set of metadata views. A struct or
-    /// resource (e.g. an NFT) can implement this interface to provide access to
+    /// Provides access to a set of metadata views. A struct or 
+    /// resource (e.g. an NFT) can implement this interface to provide access to 
     /// the views that it supports.
     ///
     access(all) resource interface Resolver {
 
         /// Same as getViews above, but on a specific NFT instead of a contract
-        access(all) view fun getViews(): [Type] {
-            return []
-        }
+        access(all) view fun getViews(): [Type]
 
         /// Same as resolveView above, but on a specific NFT instead of a contract
-        access(all) fun resolveView(_ view: Type): AnyStruct? {
-            return nil
-        }
+        access(all) fun resolveView(_ view: Type): AnyStruct?
     }
 
     /// A group of view resolvers indexed by ID.

package/contracts/capability-cache/CapabilityCache.cdc

@@ -0,0 +1,97 @@
+/*
+https://github.com/Flowtyio/capability-cache
+
+CapabilityCache helps manage capabilities which are issued but are not in public paths.
+Rather than looping through all capabilities under a storage path and finding one that 
+matches the Capability type you want, the cache can be used to retrieve them
+*/
+access(all) contract CapabilityCache {
+
+    access(all) let basePathIdentifier: String
+
+    access(all) event CapabilityAdded(owner: Address?, cacheUuid: UInt64, namespace: String, resourceType: Type, capabilityType: Type, capabilityID: UInt64)
+    access(all) event CapabilityRemoved(owner: Address?, cacheUuid: UInt64, namespace: String, resourceType: Type, capabilityType: Type, capabilityID: UInt64)
+
+    // Add to a namespace
+    access(all) entitlement Add
+
+    // Remove from a namespace
+    access(all) entitlement Delete
+
+    // Retrieve a cap from the namespace
+    access(all) entitlement Get
+
+    // Resource that manages capabilities for a provided namespace. Only one capability is permitted per type.
+    access(all) resource Cache {
+        // A dictionary of resourceType -> CapabilityType -> Capability
+        // For example, one might store a Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}> for the @TopShot.NFT resource.
+        // Note that the resource type is not necessarily the type that the borrowed capability is an instance of. This is because some resource definitions
+        // might be reused.
+        access(self) let caps: {Type: {Type: Capability}}
+
+        // who is this capability cache maintained by? e.g. flowty, dapper, find? 
+        access(all) let namespace: String
+
+        // Remove a capability, if it exists, 
+        access(Delete) fun removeCapabilityByType(resourceType: Type, capabilityType: Type): Capability? {
+            if let ref = &self.caps[resourceType] as auth(Mutate) &{Type: Capability}? {
+                let cap = ref.remove(key: capabilityType)
+                if cap != nil {
+                    emit CapabilityRemoved(owner: self.owner?.address, cacheUuid: self.uuid, namespace: self.namespace, resourceType: resourceType, capabilityType: capabilityType, capabilityID: cap!.id)
+                }
+            }
+
+            return nil
+        }
+
+        // Adds a capability to the cache. If there is already an entry for the given type,
+        // it will be returned
+        access(Add) fun addCapability(resourceType: Type, cap: Capability): Capability? {
+            pre {
+                cap.id != 0: "cannot add a capability with id 0"
+            }
+
+            let capType = cap.getType()
+            emit CapabilityAdded(owner: self.owner?.address, cacheUuid: self.uuid, namespace: self.namespace, resourceType: resourceType, capabilityType: capType, capabilityID: cap.id)
+            if let ref = &self.caps[resourceType] as auth(Mutate) &{Type: Capability}? {
+                return ref.insert(key: capType, cap)
+            }
+
+            self.caps[resourceType] = {
+                capType: cap
+            }
+
+            return nil
+        }
+
+        // Retrieve a capability key'd by a given type.
+        access(Get) fun getCapabilityByType(resourceType: Type, capabilityType: Type): Capability? {
+            if let tmp = self.caps[resourceType] {
+                return tmp[capabilityType]
+            }
+
+            return nil
+        }
+
+        init(namespace: String) {
+            self.caps = {}
+
+            self.namespace = namespace
+        }
+    }
+
+    // There is no uniform storage path for the Capability Cache. Instead, each platform which issues capabilities
+    // should manage their own cache, and can generate the storage path to store it in with this helper method
+    access(all) fun getPathForCache(_ namespace: String): StoragePath {
+        return StoragePath(identifier: self.basePathIdentifier.concat(namespace))
+            ?? panic("invalid namespace value")
+    }
+
+    access(all) fun createCache(namespace: String): @Cache {
+        return <- create Cache(namespace: namespace)
+    }
+
+    init() {
+        self.basePathIdentifier = "CapabilityCache_".concat(self.account.address.toString()).concat("_")
+    }
+}

package/contracts/dapper/DapperUtilityCoin.cdc

@@ -1,30 +1,32 @@
 import "FungibleToken"
+import "MetadataViews"
+import "FungibleTokenMetadataViews"
 
-pub contract DapperUtilityCoin: FungibleToken {
+access(all) contract DapperUtilityCoin: FungibleToken {
 
     // Total supply of DapperUtilityCoins in existence
-    pub var totalSupply: UFix64
+    access(all) var totalSupply: UFix64
 
     // Event that is emitted when the contract is created
-    pub event TokensInitialized(initialSupply: UFix64)
+    access(all) event TokensInitialized(initialSupply: UFix64)
 
     // Event that is emitted when tokens are withdrawn from a Vault
-    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
 
     // Event that is emitted when tokens are deposited to a Vault
-    pub event TokensDeposited(amount: UFix64, to: Address?)
+    access(all) event TokensDeposited(amount: UFix64, to: Address?)
 
     // Event that is emitted when new tokens are minted
-    pub event TokensMinted(amount: UFix64)
+    access(all) event TokensMinted(amount: UFix64)
 
     // Event that is emitted when tokens are destroyed
-    pub event TokensBurned(amount: UFix64)
+    access(all) event TokensBurned(amount: UFix64)
 
     // Event that is emitted when a new minter resource is created
-    pub event MinterCreated(allowedAmount: UFix64)
+    access(all) event MinterCreated(allowedAmount: UFix64)
 
     // Event that is emitted when a new burner resource is created
-    pub event BurnerCreated()
+    access(all) event BurnerCreated()
 
     // Vault
     //
@@ -38,10 +40,10 @@ pub contract DapperUtilityCoin: FungibleToken {
     // out of thin air. A special Minter resource needs to be defined to mint
     // new tokens.
     //
-    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
+    access(all) resource Vault: FungibleToken.Vault {
 
         // holds the balance of a users tokens
-        pub var balance: UFix64
+        access(all) var balance: UFix64
 
         // initialize the balance at resource creation time
         init(balance: UFix64) {
@@ -57,7 +59,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // created Vault to the context that called so it can be deposited
         // elsewhere.
         //
-        pub 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)
@@ -70,7 +72,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // It is allowed to destroy the sent Vault because the Vault
         // was a temporary holder of the tokens. The Vault's balance has
         // been consumed and therefore can be destroyed.
-        pub fun deposit(from: @FungibleToken.Vault) {
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let vault <- from as! @DapperUtilityCoin.Vault
             self.balance = self.balance + vault.balance
             emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
@@ -78,9 +80,33 @@ pub contract DapperUtilityCoin: FungibleToken {
             destroy vault
         }
 
-        destroy() {
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.balance >= amount
+        }
+
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {Type<@Vault>(): true}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return type == Type<@Vault>()
+        }
+
+        access(contract) fun burnCallback() {
             DapperUtilityCoin.totalSupply = DapperUtilityCoin.totalSupply - self.balance
         }
+
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <- create Vault(balance: 0.0)
+        }
+
+        access(all) view fun getViews(): [Type]{
+            return DapperUtilityCoin.getContractViews(resourceType: nil)
+        }
+
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return DapperUtilityCoin.resolveContractView(resourceType: nil, viewType: view)
+        }
     }
 
     // createEmptyVault
@@ -90,16 +116,16 @@ pub contract DapperUtilityCoin: FungibleToken {
     // and store the returned Vault in their storage in order to allow their
     // account to be able to receive deposits of this token type.
     //
-    pub fun createEmptyVault(): @FungibleToken.Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
         return <-create Vault(balance: 0.0)
     }
 
-    pub resource Administrator {
+    access(all) resource Administrator {
         // createNewMinter
         //
         // Function that creates and returns a new minter resource
         //
-        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+        access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
             emit MinterCreated(allowedAmount: allowedAmount)
             return <-create Minter(allowedAmount: allowedAmount)
         }
@@ -108,7 +134,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         //
         // Function that creates and returns a new burner resource
         //
-        pub fun createNewBurner(): @Burner {
+        access(all) fun createNewBurner(): @Burner {
             emit BurnerCreated()
             return <-create Burner()
         }
@@ -118,19 +144,19 @@ pub contract DapperUtilityCoin: FungibleToken {
     //
     // Resource object that token admin accounts can hold to mint new tokens.
     //
-    pub resource Minter {
+    access(all) resource Minter {
 
         // the amount of tokens that the minter is allowed to mint
-        pub var allowedAmount: UFix64
+        access(all) var allowedAmount: UFix64
 
         // mintTokens
         //
         // Function that mints new tokens, adds them to the total supply,
         // and returns them to the calling context.
         //
-        pub fun mintTokens(amount: UFix64): @DapperUtilityCoin.Vault {
+        access(all) fun mintTokens(amount: UFix64): @DapperUtilityCoin.Vault {
             pre {
-                amount > UFix64(0): "Amount minted must be greater than zero"
+                amount > 0.0: "Amount minted must be greater than zero"
                 amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
             }
             DapperUtilityCoin.totalSupply = DapperUtilityCoin.totalSupply + amount
@@ -148,7 +174,7 @@ pub contract DapperUtilityCoin: FungibleToken {
     //
     // Resource object that token admin accounts can hold to burn tokens.
     //
-    pub resource Burner {
+    access(all) resource Burner {
 
         // burnTokens
         //
@@ -157,7 +183,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // Note: the burned tokens are automatically subtracted from the
         // total supply in the Vault destructor.
         //
-        pub fun burnTokens(from: @FungibleToken.Vault) {
+        access(all) fun burnTokens(from: @{FungibleToken.Vault}) {
             let vault <- from as! @DapperUtilityCoin.Vault
             let amount = vault.balance
             destroy vault
@@ -165,6 +191,57 @@ pub contract DapperUtilityCoin: FungibleToken {
         }
     }
 
+    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://meetdapper.com/"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "Dapper Utility Coin",
+                    symbol: "DUC",
+                    description: "",
+                    externalURL: MetadataViews.ExternalURL("https://meetdapper.com/"),
+                    logos: medias,
+                    socials: {
+                        "twitter": MetadataViews.ExternalURL("https://twitter.com/hellodapper")
+                    }
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = DapperUtilityCoin.account.storage.borrow<auth(FungibleToken.Withdraw) &DapperUtilityCoin.Vault>(from: /storage/dapperUtilityCoinVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/dapperUtilityCoinVault,
+                    receiverPath: /public/exampleTokenReceiver,
+                    metadataPath: /public/dapperUtilityCoinBalance,
+                    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: DapperUtilityCoin.totalSupply)
+        }
+        return nil
+    }
+
     init() {
         // we're using a high value as the balance here to make it look like we've got a ton of money,
         // just in case some contract manually checks that our balance is sufficient to pay for stuff
@@ -172,26 +249,16 @@ pub contract DapperUtilityCoin: FungibleToken {
 
         let admin <- create Administrator()
         let minter <- admin.createNewMinter(allowedAmount: self.totalSupply)
-        self.account.save(<-admin, to: /storage/dapperUtilityCoinAdmin)
+        self.account.storage.save(<-admin, to: /storage/dapperUtilityCoinAdmin)
 
         // mint tokens
         let tokenVault <- minter.mintTokens(amount: self.totalSupply)
-        self.account.save(<-tokenVault, to: /storage/dapperUtilityCoinVault)
+        self.account.storage.save(<-tokenVault, to: /storage/dapperUtilityCoinVault)
         destroy minter
 
-        // Create a public capability to the stored Vault that only exposes
-        // the balance field through the Balance interface
-        self.account.link<&DapperUtilityCoin.Vault{FungibleToken.Balance}>(
-            /public/dapperUtilityCoinBalance,
-            target: /storage/dapperUtilityCoinVault
-        )
-
-        // Create a public capability to the stored Vault that only exposes
-        // the deposit method through the Receiver interface
-        self.account.link<&{FungibleToken.Receiver}>(
-            /public/dapperUtilityCoinReceiver,
-            target: /storage/dapperUtilityCoinVault
-        )
+        let cap = self.account.capabilities.storage.issue<&DapperUtilityCoin.Vault>(/storage/dapperUtilityCoinVault)
+        self.account.capabilities.publish(cap, at: /public/dapperUtilityCoinBalance)
+        self.account.capabilities.publish(cap, at: /public/dapperUtilityCoinReceiver)
 
         // Emit an event that shows that the contract was initialized
         emit TokensInitialized(initialSupply: self.totalSupply)