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

package/contracts/flowty-drops/nft/BaseCollection.cdc

@@ -0,0 +1,97 @@
+import "NonFungibleToken"
+import "ViewResolver"
+import "MetadataViews"
+import "NFTMetadata"
+import "FlowtyDrops"
+import "AddressUtils"
+import "StringUtils"
+
+access(all) contract interface BaseCollection: ViewResolver {
+    access(all) var MetadataCap: Capability<&NFTMetadata.Container>
+    access(all) var totalSupply: UInt64
+
+    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection}
+
+    // The base collection is an interface that attmepts to take more boilerplate
+    // off of NFT-standard compliant definitions.
+    access(all) resource interface Collection: NonFungibleToken.Collection {
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var nftType: Type
+
+        access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
+            pre {
+                token.getType() == self.nftType: "unexpected nft type being deposited"
+            }
+
+            destroy self.ownedNFTs.insert(key: token.uuid, <-token)
+        }
+
+        access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
+            return &self.ownedNFTs[id]
+        }
+
+        access(all) view fun getSupportedNFTTypes(): {Type: Bool} {
+            return {
+                self.nftType: true
+            }
+        }
+
+        access(all) view fun isSupportedNFTType(type: Type): Bool {
+            return type == self.nftType
+        }
+
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+            return <- self.ownedNFTs.remove(key: withdrawID)!
+        }
+    }
+
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
+        return [
+            Type<MetadataViews.NFTCollectionData>(),
+            Type<MetadataViews.NFTCollectionDisplay>()
+        ]
+    }
+
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        if resourceType == nil {
+            return nil
+        }
+
+        let rt = resourceType!
+        let segments = rt.identifier.split(separator: ".") 
+        let pathIdentifier = StringUtils.join([segments[2], segments[1]], "_")
+
+        let addr = AddressUtils.parseAddress(rt)!
+        let acct = getAccount(addr)
+        
+        switch viewType {
+            case Type<MetadataViews.NFTCollectionData>():
+                let segments = rt.identifier.split(separator: ".") 
+                let pathIdentifier = StringUtils.join([segments[2], segments[1]], "_")
+
+                return MetadataViews.NFTCollectionData(
+                    storagePath: StoragePath(identifier: pathIdentifier)!,
+                    publicPath: PublicPath(identifier: pathIdentifier)!,
+                    publicCollection: Type<&{NonFungibleToken.Collection}>(),
+                    publicLinkedType: Type<&{NonFungibleToken.Collection}>(),
+                    createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection} {
+                        let addr = AddressUtils.parseAddress(rt)!
+                        let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])!
+                        return <- c.createEmptyCollection(nftType: rt)
+                    }
+                )
+            case Type<MetadataViews.NFTCollectionDisplay>():
+                let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])!
+                let md = c.MetadataCap.borrow()
+                if md == nil {
+                    return nil
+                }
+
+                return md!.collectionInfo.collectionDisplay
+            case Type<FlowtyDrops.DropResolver>():
+                return FlowtyDrops.DropResolver(cap: acct.capabilities.get<&{FlowtyDrops.ContainerPublic}>(FlowtyDrops.ContainerPublicPath))
+        }
+
+        return nil
+    }
+}

package/contracts/flowty-drops/nft/BaseNFT.cdc

@@ -0,0 +1,107 @@
+import "NonFungibleToken"
+import "StringUtils"
+import "AddressUtils"
+import "ViewResolver"
+import "MetadataViews"
+import "BaseCollection"
+import "FlowtyDrops"
+import "NFTMetadata"
+import "UniversalCollection"
+
+// A few primary challenges that have come up in thinking about how to define base-level interfaces
+// for collections and NFTs:
+// 
+// - How do we resolve contract-level interfaces?
+// - How do we track total supply/serial numbers for NFTs?
+// - How do we store traits and medias?
+//
+// For some of these, mainly contract-level interfaces, we might be able to simply consolidate
+// all of these into one contract interface and require that collection display (banner, thumbnail, name, description, etc.)
+// be stored at the top-level of the contract so that they can be easily referenced later. This could make things easier in that we can
+// make a base definition for anyone to use, but since it isn't a concrete definition, anyone can later override the pre-generated
+// pieces to and modify the code to their liking. This could achieve the best of both worlds where there is minimal work to get something
+// off the ground, but doesn't close the door to customization in the future. This could come at the cost of duplicated resource definitions,
+// or could have the risk of circular imports depending on how we resolve certain pieces of information about a collection.
+access(all) contract interface BaseNFT: ViewResolver {
+    access(all) resource interface NFT: NonFungibleToken.NFT {
+        // This is the id entry that corresponds to an NFTs NFTMetadata.Container entry.
+        // Some NFTs might share the same data, so we want to permit reusing storage where possible
+        access(all) metadataID: UInt64
+
+        access(all) view fun getViews(): [Type] {
+            return [
+                Type<MetadataViews.Display>(),
+                Type<MetadataViews.Serial>(),
+                Type<MetadataViews.Traits>(),
+                Type<MetadataViews.Editions>(),
+                Type<MetadataViews.ExternalURL>(),
+                Type<MetadataViews.NFTCollectionData>(),
+                Type<MetadataViews.NFTCollectionDisplay>()
+            ]
+        }
+
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            if view == Type<MetadataViews.Serial>() {
+                return self.id
+            }
+
+            let rt = self.getType()
+            let segments = rt.identifier.split(separator: ".")
+            let addr = AddressUtils.parseAddress(rt)!
+            let tmp = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])
+            if tmp == nil {
+                return nil
+            }
+            
+            let c = tmp!
+            let tmpMd = c.MetadataCap.borrow()
+            if tmpMd == nil {
+                return nil
+            }
+
+            let md = tmpMd!
+            switch view {
+                case Type<MetadataViews.NFTCollectionData>():
+                    let pathIdentifier = StringUtils.join([segments[2], segments[1]], "_")
+                    return MetadataViews.NFTCollectionData(
+                        storagePath: StoragePath(identifier: pathIdentifier)!,
+                        publicPath: PublicPath(identifier: pathIdentifier)!,
+                        publicCollection: Type<&{NonFungibleToken.Collection}>(),
+                        publicLinkedType: Type<&{NonFungibleToken.Collection}>(),
+                        createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection} {
+                            let addr = AddressUtils.parseAddress(rt)!
+                            let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])!
+                            return <- c.createEmptyCollection(nftType: rt)
+                        }
+                    )
+                case Type<MetadataViews.NFTCollectionDisplay>():
+                    return md.collectionInfo.collectionDisplay
+            }
+
+            if let entry = md.borrowMetadata(id: self.metadataID) {
+                switch view {
+                    case Type<MetadataViews.Traits>():
+                        return entry.traits
+                    case Type<MetadataViews.Editions>():
+                        return entry.editions
+                    case Type<MetadataViews.Display>():
+                        let num = (entry.editions?.infoList?.length ?? 0) > 0 ? entry.editions!.infoList[0].number : self.id
+
+                        return MetadataViews.Display(
+                            name: entry.name.concat(" #").concat(num.toString()),
+                            description: entry.description,
+                            thumbnail: NFTMetadata.UriFile(entry.thumbnail.uri())
+                        )
+                    case Type<MetadataViews.ExternalURL>():
+                        return entry.externalURL
+                }
+            }
+
+            return nil
+        }
+
+        access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
+            return <- UniversalCollection.createCollection(nftType: self.getType())
+        }
+    }
+}

package/contracts/flowty-drops/nft/ContractFactory.cdc

@@ -0,0 +1,13 @@
+import "ContractFactoryTemplate"
+import "AddressUtils"
+
+access(all) contract ContractFactory {
+    access(all) fun createContract(templateType: Type, acct: auth(Contracts) &Account, name: String, params: {String: AnyStruct}, initializeIdentifier: String) {
+        let templateAddr = AddressUtils.parseAddress(templateType)!
+        let contractName = templateType.identifier.split(separator: ".")[2]
+        let templateContract = getAccount(templateAddr).contracts.borrow<&{ContractFactoryTemplate}>(name: contractName)
+            ?? panic("provided type is not a ContractTemplateFactory")
+        
+        templateContract.createContract(acct: acct, name: name, params: params, initializeIdentifier: initializeIdentifier)
+    }
+}

package/contracts/flowty-drops/nft/ContractFactoryTemplate.cdc

@@ -0,0 +1,48 @@
+import "NonFungibleToken"
+import "MetadataViews"
+import "ViewResolver"
+
+import "FlowtyDrops"
+import "BaseNFT"
+import "BaseCollection"
+import "NFTMetadata"
+import "UniversalCollection"
+import "ContractBorrower"
+
+import "AddressUtils"
+
+access(all) contract interface ContractFactoryTemplate {
+    access(all) fun createContract(acct: auth(Contracts) &Account, name: String, params: {String: AnyStruct}, initializeIdentifier: String)
+
+    access(all) fun getContractAddresses(): {String: Address} {
+        let d: {String: Address} = {
+            "NonFungibleToken": AddressUtils.parseAddress(Type<&{NonFungibleToken}>())!,
+            "MetadataViews": AddressUtils.parseAddress(Type<&MetadataViews>())!,
+            "ViewResolver": AddressUtils.parseAddress(Type<&{ViewResolver}>())!,
+            "FlowtyDrops": AddressUtils.parseAddress(Type<&FlowtyDrops>())!,
+            "BaseNFT": AddressUtils.parseAddress(Type<&{BaseNFT}>())!,
+            "BaseCollection": AddressUtils.parseAddress(Type<&{BaseCollection}>())!,
+            "NFTMetadata": AddressUtils.parseAddress(Type<&NFTMetadata>())!,
+            "UniversalCollection": AddressUtils.parseAddress(Type<&UniversalCollection>())!,
+            "BaseCollection": AddressUtils.parseAddress(Type<&{BaseCollection}>())!,
+            "AddressUtils": AddressUtils.parseAddress(Type<&AddressUtils>())!,
+            "ContractBorrower": AddressUtils.parseAddress(Type<ContractBorrower>())!
+        }
+
+        return d
+    }
+
+    access(all) fun importLine(name: String, addr: Address): String {
+        return "import ".concat(name).concat(" from ").concat(addr.toString()).concat("\n")
+    }
+
+    access(all) fun generateImports(names: [String]): String {
+        let addresses = self.getContractAddresses()
+        var imports = ""
+        for n in names {
+            imports = imports.concat(self.importLine(name: n, addr: addresses[n] ?? panic("missing contract import address: ".concat(n))))
+        }
+
+        return imports
+    }
+}

package/contracts/flowty-drops/nft/NFTMetadata.cdc

@@ -0,0 +1,119 @@
+import "NonFungibleToken"
+import "MetadataViews"
+
+access(all) contract NFTMetadata {
+    access(all) entitlement Owner
+
+    access(all) event MetadataFrozen(uuid: UInt64, owner: Address?)
+
+    access(all) struct CollectionInfo {
+        access(all) var collectionDisplay: MetadataViews.NFTCollectionDisplay
+
+        init(collectionDisplay: MetadataViews.NFTCollectionDisplay) {
+            self.collectionDisplay = collectionDisplay
+        }
+    }
+
+    access(all) struct Metadata {
+        // these are used to create the display metadata view so that we can concatenate
+        // the id onto it.
+        access(all) let name: String
+        access(all) let description: String
+        access(all) let thumbnail: {MetadataViews.File}
+
+        access(all) let traits: MetadataViews.Traits?
+        access(all) let editions: MetadataViews.Editions?
+        access(all) let externalURL: MetadataViews.ExternalURL?
+
+        access(all) let data: {String: AnyStruct} // general-purpose data bucket
+
+        init(
+            name: String,
+            description: String,
+            thumbnail: {MetadataViews.File},
+            traits: MetadataViews.Traits?,
+            editions: MetadataViews.Editions?,
+            externalURL: MetadataViews.ExternalURL?,
+            data: {String: AnyStruct}
+        ) {
+            self.name = name
+            self.description = description
+            self.thumbnail = thumbnail
+
+            self.traits = traits
+            self.editions = editions
+            self.externalURL = externalURL
+
+            self.data = {}
+        }
+    }
+
+    access(all) resource Container {
+        access(all) var collectionInfo: CollectionInfo
+        access(all) let metadata: {UInt64: Metadata}
+        access(all) var frozen: Bool
+
+        access(all) fun borrowMetadata(id: UInt64): &Metadata? {
+            return &self.metadata[id]
+        }
+
+        access(Owner) fun addMetadata(id: UInt64, data: Metadata) {
+            pre {
+                self.metadata[id] == nil: "id already has metadata assigned"
+            }
+
+            self.metadata[id] = data
+        }
+
+        access(Owner) fun freeze() {
+            self.frozen = true
+            emit MetadataFrozen(uuid: self.uuid, owner: self.owner?.address)
+        }
+
+        init(collectionInfo: CollectionInfo) {
+            self.collectionInfo = collectionInfo
+            self.metadata = {}
+            self.frozen = false
+        }
+    }
+
+    access(all) struct InitializedCaps {
+        access(all) let pubCap: Capability<&Container>
+        access(all) let ownerCap: Capability<auth(Owner) &Container>
+
+        init(pubCap: Capability<&Container>, ownerCap: Capability<auth(Owner) &Container>) {
+            self.pubCap = pubCap
+            self.ownerCap = ownerCap
+        }
+    }
+
+    access(all) fun createContainer(collectionInfo: CollectionInfo): @Container {
+        return <- create Container(collectionInfo: collectionInfo)
+    }
+
+    access(all) fun initialize(acct: auth(Storage, Capabilities) &Account, collectionInfo: CollectionInfo, collectionType: Type): InitializedCaps {
+        let storagePath = self.getCollectionStoragePath(type: collectionType)
+        let container <- self.createContainer(collectionInfo: collectionInfo)
+        acct.storage.save(<-container, to: storagePath)
+        let pubCap = acct.capabilities.storage.issue<&Container>(storagePath)
+        let ownerCap = acct.capabilities.storage.issue<auth(Owner) &Container>(storagePath)
+        return InitializedCaps(pubCap: pubCap, ownerCap: ownerCap)
+    }
+
+    access(all) struct UriFile: MetadataViews.File {
+        access(self) let url: String
+
+        access(all) view fun uri(): String {
+            return self.url
+        }
+
+        init(_ url: String) {
+            self.url = url
+        }
+    }
+
+    access(all) fun getCollectionStoragePath(type: Type): StoragePath {
+        let segments = type.identifier.split(separator: ".")
+        return StoragePath(identifier: "NFTMetadataContainer_".concat(segments[2]).concat("_").concat(segments[1]))!
+    }
+}

package/contracts/flowty-drops/nft/OpenEditionNFT.cdc

@@ -0,0 +1,41 @@
+import "NonFungibleToken"
+import "FlowtyDrops"
+import "BaseNFT"
+import "NFTMetadata"
+import "UniversalCollection"
+import "ContractBorrower"
+import "BaseCollection"
+
+access(all) contract OpenEditionNFT: BaseCollection {
+    access(all) var MetadataCap: Capability<&NFTMetadata.Container>
+    access(all) var totalSupply: UInt64
+
+    access(all) resource NFT: BaseNFT.NFT {
+        access(all) let id: UInt64
+        access(all) let metadataID: UInt64
+
+        init() {
+            OpenEditionNFT.totalSupply = OpenEditionNFT.totalSupply + 1
+            self.id = OpenEditionNFT.totalSupply
+            self.metadataID = 0
+        }
+    }
+
+    access(all) resource NFTMinter: FlowtyDrops.Minter {
+        access(contract) fun createNextNFT(): @{NonFungibleToken.NFT} {
+            return <- create NFT()
+        }
+    }
+
+    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} {
+        return <- UniversalCollection.createCollection(nftType: Type<@NFT>())
+    }
+
+    init(params: {String: AnyStruct}, initializeIdentifier: String) {
+        self.totalSupply = 0
+        self.account.storage.save(<- create NFTMinter(), to: FlowtyDrops.getMinterStoragePath(type: self.getType()))
+        params["minterController"] = self.account.capabilities.storage.issue<&{FlowtyDrops.Minter}>(FlowtyDrops.getMinterStoragePath(type: self.getType()))
+
+        self.MetadataCap = ContractBorrower.borrowInitializer(typeIdentifier: initializeIdentifier).initialize(contractAcct: self.account, params: params).pubCap
+    }
+}

package/contracts/flowty-drops/nft/OpenEditionTemplate.cdc

@@ -0,0 +1,52 @@
+import "ContractFactoryTemplate"
+import "MetadataViews"
+import "NFTMetadata"
+
+access(all) contract OpenEditionTemplate: ContractFactoryTemplate {
+    access(all) fun createContract(acct: auth(Contracts) &Account, name: String, params: {String: AnyStruct}, initializeIdentifier: String) {
+        let code = self.generateImports(names: [
+            "NonFungibleToken",
+            "FlowtyDrops",
+            "BaseNFT",
+            "NFTMetadata",
+            "UniversalCollection",
+            "ContractBorrower",
+            "BaseCollection"
+        ]).concat("\n\n")
+        .concat("access(all) contract ").concat(name).concat(": BaseCollection {\n")
+        .concat("    access(all) var MetadataCap: Capability<&NFTMetadata.Container>\n")
+        .concat("    access(all) var totalSupply: UInt64\n")
+        .concat("\n\n")
+        .concat("    access(all) resource NFT: BaseNFT.NFT {\n")
+        .concat("        access(all) let id: UInt64\n")
+        .concat("        access(all) let metadataID: UInt64\n")
+        .concat("\n\n")
+        .concat("        init() {\n")
+        .concat("            ").concat(name).concat(".totalSupply = ").concat(name).concat(".totalSupply + 1\n")
+        .concat("            self.id = ").concat(name).concat(".totalSupply\n")
+        .concat("            self.metadataID = 0\n")
+        .concat("        }\n")
+        .concat("    }\n")
+        .concat("    access(all) resource NFTMinter: FlowtyDrops.Minter {\n")
+        .concat("        access(contract) fun createNextNFT(): @{NonFungibleToken.NFT} {\n")
+        .concat("            return <- create NFT()\n")
+        .concat("        }\n")
+        .concat("    }\n")
+        .concat("\n")
+        .concat("    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} {\n")
+        .concat("        return <- UniversalCollection.createCollection(nftType: Type<@NFT>())\n")
+        .concat("    }\n")
+        .concat("\n")
+        .concat("    init(params: {String: AnyStruct}, initializeIdentifier: String) {\n")
+        .concat("        self.totalSupply = 0\n")
+        .concat("        let minter <- create NFTMinter()\n")
+        .concat("        self.account.storage.save(<-minter, to: FlowtyDrops.getMinterStoragePath(type: self.getType()))\n")
+        .concat("        params[\"minterController\"] = self.account.capabilities.storage.issue<&{FlowtyDrops.Minter}>(FlowtyDrops.getMinterStoragePath(type: self.getType()))\n")
+        .concat("\n\n")
+        .concat("        self.MetadataCap = ContractBorrower.borrowInitializer(typeIdentifier: initializeIdentifier).initialize(contractAcct: self.account, params: params).pubCap\n")
+        .concat("    }\n")
+        .concat("}\n")
+
+        acct.contracts.add(name: name, code: code.utf8, params, initializeIdentifier)
+    }
+}

package/contracts/flowty-drops/nft/UniversalCollection.cdc

@@ -0,0 +1,23 @@
+import "NonFungibleToken"
+import "MetadataViews"
+import "BaseCollection"
+
+access(all) contract UniversalCollection {
+    access(all) resource Collection: BaseCollection.Collection {
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var nftType: Type
+
+        access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
+            return <- create Collection(nftType: self.nftType)
+        }
+
+        init (nftType: Type) {
+            self.ownedNFTs <- {}
+            self.nftType = nftType
+        }
+    }
+
+    access(all) fun createCollection(nftType: Type): @Collection {
+        return <- create Collection(nftType: nftType)
+    }
+}

package/contracts/fungible-token-router/FungibleTokenRouter.cdc

@@ -0,0 +1,105 @@
+/*
+FungibleTokenRouter forwards tokens from one account to another using
+FungibleToken metadata views. If a token is not configured to be received,
+any deposits will panic like they would a deposit that it attempt to a
+non-existent receiver
+
+https://github.com/Flowtyio/fungible-token-router
+*/
+
+import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "FlowToken"
+
+access(all) contract FungibleTokenRouter {
+    access(all) let StoragePath: StoragePath
+    access(all) let PublicPath: PublicPath
+
+    access(all) entitlement Owner
+
+    access(all) event RouterCreated(uuid: UInt64, defaultAddress: Address)
+    access(all) event OverrideAdded(uuid: UInt64, owner: Address?, overrideAddress: Address, tokenType: String)
+    access(all) event OverrideRemoved(uuid: UInt64, owner: Address?, overrideAddress: Address?, tokenType: String)
+    access(all) event TokensRouted(tokenType: String, amount: UFix64, to: Address)
+
+    access(all) resource Router: FungibleToken.Receiver {
+        // a default address that is used for any token type that is not overridden
+        access(all) var defaultAddress: Address
+
+        // token type identifier -> destination address
+        access(all) var addressOverrides: {String: Address}
+
+        access(Owner) fun setDefaultAddress(_ addr: Address) {
+            self.defaultAddress = addr
+        }
+
+        access(Owner) fun addOverride(type: Type, addr: Address) {
+            emit OverrideAdded(uuid: self.uuid, owner: self.owner?.address, overrideAddress: addr, tokenType: type.identifier)
+            self.addressOverrides[type.identifier] = addr
+        }
+
+        access(Owner) fun removeOverride(type: Type): Address? {
+            let removedAddr = self.addressOverrides.remove(key: type.identifier)
+            emit OverrideRemoved(uuid: self.uuid, owner: self.owner?.address, overrideAddress: removedAddr, tokenType: type.identifier)
+            return removedAddr
+        }
+
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
+            let tokenType = from.getType()
+            let destination = self.addressOverrides[tokenType.identifier] ?? self.defaultAddress
+
+            var vaultDataOpt: FungibleTokenMetadataViews.FTVaultData? = nil
+
+            if tokenType == Type<@FlowToken.Vault>() {
+                vaultDataOpt = FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/flowTokenVault,
+                    receiverPath: /public/flowTokenReceiver,
+                    metadataPath: /public/flowTokenReceiver,
+                    receiverLinkedType: Type<&FlowToken.Vault>(),
+                    metadataLinkedType: Type<&FlowToken.Vault>(),
+                    createEmptyVaultFunction: fun(): @{FungibleToken.Vault} {
+                        return <- FlowToken.createEmptyVault(vaultType: tokenType)   
+                    }
+                )
+            } else if let md = from.resolveView(Type<FungibleTokenMetadataViews.FTVaultData>()) {
+                vaultDataOpt = md as! FungibleTokenMetadataViews.FTVaultData
+            }
+
+            let vaultData = vaultDataOpt ?? panic("vault data could not be retrieved")
+            let receiver = getAccount(destination).capabilities.get<&{FungibleToken.Receiver}>(vaultData.receiverPath)
+            assert(receiver.check(), message: "no receiver found at path: ".concat(vaultData.receiverPath.toString()))
+
+            emit TokensRouted(tokenType: tokenType.identifier, amount: from.balance, to: destination)
+            receiver.borrow()!.deposit(from: <-from)
+
+            panic("Could not find FungibleTokenMetadataViews.FTVaultData on depositing tokens")
+        }
+
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            // theoretically any token is supported, it depends on the defaultAddress
+            return {}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            // theoretically any token is supported, it depends on the defaultAddress
+            return true
+        }
+
+        init(defaultAddress: Address) {
+            self.defaultAddress = defaultAddress
+            self.addressOverrides = {}
+
+            emit RouterCreated(uuid: self.uuid, defaultAddress: defaultAddress)
+        }
+    }
+
+    access(all) fun createRouter(defaultAddress: Address): @Router {
+        return <- create Router(defaultAddress: defaultAddress)
+    }
+
+    init() {
+        let identifier = "FungibleTokenRouter_".concat(self.account.address.toString())
+        self.StoragePath = StoragePath(identifier: identifier)!
+        self.PublicPath = PublicPath(identifier: identifier)!
+    }
+}