@flowtyio/flow-contracts 0.1.0-beta.9 → 0.1.1

package/contracts/tokens/USDCFlow.cdc

@@ -0,0 +1,232 @@
+import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "MetadataViews"
+import "Burner"
+import "ViewResolver"
+import "FlowEVMBridgeHandlerInterfaces"
+import "FlowEVMBridgeConfig"
+
+/// After the Crescendo migration, the `USDCFlow` smart contract
+/// will integrate directly with the Flow VM bridge to become
+/// the bridged version of Flow EVM USDC. These tokens will be backed
+/// by real USDC via Flow EVM.
+
+/// This is not the official Circle USDC, only a bridged version
+/// that is still backed by official USDC on the other side of the bridge
+
+access(all) contract USDCFlow: FungibleToken, ViewResolver {
+
+    /// Total supply of USDCFlows in existence
+    access(all) var totalSupply: UFix64
+
+    /// Storage and Public Paths
+    access(all) let VaultStoragePath: StoragePath
+    access(all) let VaultPublicPath: PublicPath
+    access(all) let ReceiverPublicPath: PublicPath
+
+    /// The event that is emitted when new tokens are minted
+    access(all) event Minted(amount: UFix64, mintedUUID: UInt64)
+    access(all) event Burned(amount: UFix64, burntUUID: UInt64)
+
+    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://uploads-ssl.webflow.com/5f734f4dbd95382f4fdfa0ea/66bfae00953c3d7bd09e7ac4_USDC-and-FLOW.svg"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "USDC (Flow)",
+                    symbol: "USDCf",
+                    description: "This fungible token representation of Standard Bridged USDC is bridged from Flow EVM.",
+                    externalURL: MetadataViews.ExternalURL("https://github.com/circlefin/stablecoin-evm/blob/master/doc/bridged_USDC_standard.md"),
+                    logos: medias,
+                    socials: {},
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: USDCFlow.VaultStoragePath,
+                    receiverPath: USDCFlow.ReceiverPublicPath,
+                    metadataPath: USDCFlow.VaultPublicPath,
+                    receiverLinkedType: Type<&USDCFlow.Vault>(),
+                    metadataLinkedType: Type<&USDCFlow.Vault>(),
+                    createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} {
+                        return <-USDCFlow.createEmptyVault(vaultType: Type<@USDCFlow.Vault>())
+                    })
+                )
+            case Type<FungibleTokenMetadataViews.TotalSupply>():
+                return FungibleTokenMetadataViews.TotalSupply(
+                    totalSupply: USDCFlow.totalSupply
+                )
+        }
+        return nil
+    }
+
+    access(all) resource Vault: FungibleToken.Vault {
+
+        /// The total balance of this vault
+        access(all) var balance: UFix64
+
+        /// Initialize the balance at resource creation time
+        init(balance: UFix64) {
+            self.balance = balance
+        }
+
+        /// Called when a fungible token is burned via the `Burner.burn()` method
+        /// The total supply will only reflect the supply in the Cadence version
+        /// of the USDCFlow smart contract
+        access(contract) fun burnCallback() {
+            if self.balance > 0.0 {
+                assert(USDCFlow.totalSupply >= self.balance, message: "Cannot burn more than the total supply")
+                emit Burned(amount: self.balance, burntUUID: self.uuid)
+                USDCFlow.totalSupply = USDCFlow.totalSupply - self.balance
+            }
+            self.balance = 0.0
+        }
+
+        /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            let supportedTypes: {Type: Bool} = {}
+            supportedTypes[self.getType()] = true
+            return supportedTypes
+        }
+
+        /// Returns whether the specified type can be deposited
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return self.getSupportedVaultTypes()[type] ?? false
+        }
+
+        /// Asks if the amount can be withdrawn from this vault
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return amount <= self.balance
+        }
+
+        access(all) fun createEmptyVault(): @USDCFlow.Vault {
+            return <-create Vault(balance: 0.0)
+        }
+
+        /// withdraw
+        /// @param amount: The amount of tokens to be withdrawn from the vault
+        /// @return The Vault resource containing the withdrawn funds
+        ///
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
+            self.balance = self.balance - amount
+            return <-create Vault(balance: amount)
+        }
+
+        /// deposit
+        /// @param from: The Vault resource containing the funds that will be deposited
+        ///
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
+            let vault <- from as! @USDCFlow.Vault
+            self.balance = self.balance + vault.balance
+            destroy vault
+        }
+
+        /// Gets an array of all the Metadata Views implemented by USDCFlow
+        ///
+        /// @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 USDCFlow.getContractViews(resourceType: nil)
+        }
+
+        /// Resolves Metadata Views out of the USDCFlow
+        ///
+        /// @param view: The Type of the desired view.
+        /// @return A structure representing the requested view.
+        ///
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return USDCFlow.resolveContractView(resourceType: nil, viewType: view)
+        }
+    }
+
+    access(all) resource Minter: FlowEVMBridgeHandlerInterfaces.TokenMinter {
+
+        /// Required function for the bridge to be able to work with the Minter
+        access(all) view fun getMintedType(): Type {
+            return Type<@USDCFlow.Vault>()
+        }
+
+        /// Function for the bridge to mint tokens that are bridged from Flow EVM
+        access(FlowEVMBridgeHandlerInterfaces.Mint) fun mint(amount: UFix64): @{FungibleToken.Vault} {
+            let newTotalSupply = USDCFlow.totalSupply + amount
+            USDCFlow.totalSupply = newTotalSupply
+
+            let vault <-create Vault(balance: amount)
+
+            emit Minted(amount: amount, mintedUUID: vault.uuid)
+            return <-vault
+        }
+
+        /// Function for the bridge to burn tokens that are bridged back to Flow EVM
+        access(all) fun burn(vault: @{FungibleToken.Vault}) {
+            let toBurn <- vault as! @USDCFlow.Vault
+            let amount = toBurn.balance
+
+            // This function updates USDCFlow.totalSupply
+            Burner.burn(<-toBurn)
+        }
+    }
+
+    /// Sends the USDCFlow Minter to the Flow/EVM bridge
+    /// without giving any account access to the minter
+    /// before it is safely in the decentralized bridge
+    access(all) fun sendMinterToBridge(_ bridgeAddress: Address) {
+        let minter <- create Minter()
+        // borrow a reference to the bridge's configuration admin resource from public Capability
+        let bridgeAdmin = getAccount(bridgeAddress).capabilities.borrow<&FlowEVMBridgeConfig.Admin>(
+                FlowEVMBridgeConfig.adminPublicPath
+            ) ?? panic("FlowEVMBridgeConfig.Admin could not be referenced from ".concat(bridgeAddress.toString()))
+            
+        // sets the USDCFlow as the minter resource for all USDCFlow bridge requests
+        // prior to transferring the Minter, a TokenHandler will be set for USDCFlow during the bridge's initial
+        // configuration, setting the stage for this minter to be sent.
+        bridgeAdmin.setTokenHandlerMinter(targetType: Type<@USDCFlow.Vault>(), minter: <-minter)
+    }
+
+    /// createEmptyVault
+    ///
+    /// @return The new Vault resource with a balance of zero
+    ///
+    access(all) fun createEmptyVault(vaultType: Type): @Vault {
+        let r <-create Vault(balance: 0.0)
+        return <-r
+    }
+
+    init() {
+        self.totalSupply = 0.0
+        self.VaultStoragePath = /storage/usdcFlowVault
+        self.VaultPublicPath = /public/usdcFlowMetadata
+        self.ReceiverPublicPath = /public/usdcFlowReceiver
+
+        let minter <- create Minter()
+        self.account.storage.save(<-minter, to: /storage/usdcFlowMinter)
+
+        // Create the Vault with the total supply of tokens and save it in storage.
+        let vault <- create Vault(balance: self.totalSupply)
+        self.account.storage.save(<-vault, to: self.VaultStoragePath)
+
+        let tokenCap = self.account.capabilities.storage.issue<&USDCFlow.Vault>(self.VaultStoragePath)
+        self.account.capabilities.publish(tokenCap, at: self.ReceiverPublicPath)
+        self.account.capabilities.publish(tokenCap, at: self.VaultPublicPath)
+    }
+}

package/flow.json

@@ -33,8 +33,8 @@
       "source": "./contracts/Burner.cdc",
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
-        "testnet": "0x631e88ae7f1d7c20",
-        "mainnet": "0x1d7e57aa55817448"
+        "testnet": "0x9a0766d93b6608b7",
+        "mainnet": "0xf233dcee88fe0abe"
       }
     },
     "MetadataViews": {
@@ -61,6 +61,14 @@
         "mainnet": "0xf233dcee88fe0abe"
       }
     },
+    "FungibleTokenSwitchboard": {
+      "source": "./contracts/FungibleTokenSwitchboard.cdc",
+      "aliases": {
+        "emulator": "0xee82856bf20e2aa6",
+        "testnet": "0x9a0766d93b6608b7",
+        "mainnet": "0xf233dcee88fe0abe"
+      }
+    },
     "ViewResolver": {
       "source": "./contracts/ViewResolver.cdc",
       "aliases": {
@@ -141,8 +149,8 @@
         "mainnet": "0xd8a7e05a7ac670c0"
       }
     },
-    "NFTProviderAndCollectionPublicFactory": {
-      "source": "./contracts/hybrid-custody/factories/NFTProviderAndCollectionPublicFactory.cdc",
+    "NFTProviderAndCollectionFactory": {
+      "source": "./contracts/hybrid-custody/factories/NFTProviderAndCollectionFactory.cdc",
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
         "testnet": "0x294e44e1ec6993c6",
@@ -186,7 +194,7 @@
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
         "testnet": "0x8c5303eaa26202d6",
-        "mainnet": "0xf919ee77447b7497"
+        "mainnet": "0xe467b9dd11fa00df"
       }
     },
     "TokenForwarding": {
@@ -346,6 +354,256 @@
         "emulator": "0xf8d6e0586b0a20c7",
         "testing": "0x0000000000000007"
       }
+    },
+    "ContractManager": {
+      "source": "./contracts/flowty-drops/ContractManager.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractInitializer": {
+      "source": "./contracts/flowty-drops/initializers/ContractInitializer.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractBorrower": {
+      "source": "./contracts/flowty-drops/initializers/ContractBorrower.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "OpenEditionInitializer": {
+      "source": "./contracts/flowty-drops/initializers/OpenEditionInitializer.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "BaseCollection": {
+      "source": "./contracts/flowty-drops/nft/BaseCollection.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractFactoryTemplate": {
+      "source": "./contracts/flowty-drops/nft/ContractFactoryTemplate.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "ContractFactory": {
+      "source": "./contracts/flowty-drops/nft/ContractFactory.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "OpenEditionTemplate": {
+      "source": "./contracts/flowty-drops/nft/OpenEditionTemplate.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "UniversalCollection": {
+      "source": "./contracts/flowty-drops/nft/UniversalCollection.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "BaseNFT": {
+      "source": "./contracts/flowty-drops/nft/BaseNFT.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "NFTMetadata": {
+      "source": "./contracts/flowty-drops/nft/NFTMetadata.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyDrops": {
+      "source": "./contracts/flowty-drops/FlowtyDrops.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "DropFactory": {
+      "source": "./contracts/flowty-drops/DropFactory.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyActiveCheckers": {
+      "source": "./contracts/flowty-drops/FlowtyActiveCheckers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyPricers": {
+      "source": "./contracts/flowty-drops/FlowtyPricers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "FlowtyAddressVerifiers": {
+      "source": "./contracts/flowty-drops/FlowtyAddressVerifiers.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x772a10c786851a1b",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "DropTypes": {
+      "source": "./contracts/flowty-drops/DropTypes.cdc",
+      "aliases": {
+        "testing": "0x0000000000000006",
+        "testnet": "0x934da91a977f1ac4",
+        "emulator": "0xf8d6e0586b0a20c7"
+      }
+    },
+    "CapabilityCache": {
+      "source": "./contracts/capability-cache/CapabilityCache.cdc",
+      "aliases": {
+        "testing": "0x0000000000000007",
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x83d75469f66d2ee6",
+        "mainnet": "0xacc5081c003e24cf"
+      }
+    },
+    "FungibleTokenRouter": {
+      "source": "./contracts/fungible-token-router/FungibleTokenRouter.cdc",
+      "aliases": {
+        "testing": "0x0000000000000007",
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x83231f90a288bc35",
+        "mainnet": "0x707c0b39a8d689cb"
+      }
+    },
+    "EVM": {
+      "source": "./contracts/evm/EVM.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x8c5303eaa26202d6",
+        "mainnet": "0xe467b9dd11fa00df"
+      }
+    },
+    "FlowEVMBridgeConfig": {
+			"source": "./contracts/evm/FlowEVMBridgeConfig.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"FlowEVMBridgeHandlerInterfaces": {
+			"source": "./contracts/evm/FlowEVMBridgeHandlerInterfaces.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"FlowEVMBridgeHandlers": {
+			"source": "./contracts/evm/FlowEVMBridgeHandlers.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"IBridgePermissions": {
+			"source": "./contracts/evm/IBridgePermissions.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"Serialize": {
+			"source": "./contracts/evm/Serialize.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"SerializeMetadata": {
+			"source": "./contracts/evm/SerializeMetadata.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"ICrossVM": {
+			"source": "./contracts/evm/ICrossVM.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"ICrossVMAsset": {
+			"source": "./contracts/evm/ICrossVMAsset.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"CrossVMNFT": {
+			"source": "./contracts/evm/CrossVMNFT.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+		"FlowEVMBridgeUtils": {
+			"source": "./contracts/evm/FlowEVMBridgeUtils.cdc",
+			"aliases": {
+				"emulator": "0xf8d6e0586b0a20c7",
+				"mainnet": "0x1e4aa0b87d10b141",
+				"testnet": "0xdfc20aee650fcbdf"
+			}
+		},
+    "USDCFlow": {
+      "source": "./contracts/tokens/USDCFlow.cdc",
+      "aliases": {
+        "emulator": "0xf8d6e0586b0a20c7",
+        "testnet": "0x64adf39cbc354fcb",
+        "mainnet": "0xf1ab99c82dee3526"
+      }
     }
   },
   "deployments": {
@@ -377,11 +635,24 @@
         "FindViews",
         "FLOAT",
         "ExampleNFT",
-        "ExampleToken"
+        "ExampleToken",
+        "HybridCustody",
+        "CapabilityFactory",
+        "CapabilityDelegator",
+        "CapabilityFilter",
+        "FTAllFactory",
+        "FTBalanceFactory",
+        "FTProviderFactory",
+        "FTReceiverFactory",
+        "NFTCollectionPublicFactory",
+        "NFTProviderAndCollectionFactory",
+        "NFTProviderFactory",
+        "USDCFlow"
       ],
       "emulator-ft": [
         "FungibleToken",
-        "FungibleTokenMetadataViews"
+        "FungibleTokenMetadataViews",
+        "FungibleTokenSwitchboard"
       ],
       "emulator-flowtoken": [
         "FlowToken"

package/package.json

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

package/contracts/hybrid-custody/factories/NFTProviderAndCollectionPublicFactory.cdc

@@ -1,10 +0,0 @@
-import "CapabilityFactory"
-import "NonFungibleToken"
-
-pub contract NFTProviderAndCollectionFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(path)
-        }
-    }
-}