DomainUtils

1import Flowns from 0x233eb012d34b0070
2import Domains from 0x233eb012d34b0070
3import FIND from 0x097bafa4e0b48eef
4
5pub contract DomainUtils {
6
7    pub fun getAddressesOfDomains(names: [String], roots: [String]): {String: Address} {
8        assert(names.length == roots.length, message: "names and roots should have the same length")
9        let res: {String: Address} = {}
10        for index, name in names {
11            let root = roots[index]
12            if let address = self.getAddressOfDomain(name: name, root: root) {
13                let domain = name.concat(".").concat(root)
14                res[domain] = address
15            }
16        }
17        return res
18    }
19
20    pub fun getDefaultDomainsOfAddresses(_ addresses: [Address]): {Address: {String: String}} {
21        let res: {Address: {String: String}} = {}
22        for address in addresses {
23            let domains = self.getDefaultDomainsOfAddress(address)
24            res[address] = domains
25        }
26        return res
27    }
28
29    pub fun getAddressOfDomain(name: String, root: String): Address? {
30        if let address = self.getFINDAddress(name: name, root: root) {
31            return address
32        }
33        return self.getFlownsAddress(name: name, root: root)
34    }
35
36    pub fun getDefaultDomainsOfAddress(_ address: Address): {String: String} {
37        let res: {String: String} = {}
38        if let domainFIND = self.getFINDDefaultDomain(address: address) {
39            res["find"] = domainFIND
40        }
41        if let domainFlowns = self.getFlownsDefaultDomain(address: address) {
42            res["flowns"] = domainFlowns
43        }
44        return res
45    }
46
47    pub fun getFINDAddress(name: String, root: String): Address? {
48        if root == "find" && FIND.validateFindName(name)  {
49            return FIND.lookupAddress(name)
50        }
51        return nil
52    }
53
54    pub fun getFINDDefaultDomain(address: Address): String? {
55        if let name = FIND.reverseLookup(address) {
56            return name.concat(".find")
57        }
58        return nil
59    }
60
61    pub fun getFlownsAddress(name: String, root: String): Address? {
62        let prefix = "0x"
63        let rootHash = Flowns.hash(node: "", lable: root)
64        let nameHash = prefix.concat(Flowns.hash(node: rootHash, lable: name))
65        return Domains.getRecords(nameHash)
66    }
67
68    pub fun getFlownsDefaultDomain(address: Address): String? {
69        let account = getAccount(address)
70        let collectionCap = account.getCapability<&{Domains.CollectionPublic}>(Domains.CollectionPublicPath)
71        if !collectionCap.check() {
72            return nil
73        }
74
75        let collection = collectionCap.borrow()!
76        let ids = collection.getIDs()
77        if ids.length == 0 {
78            return nil
79        }
80
81        var defaultDomainID: UInt64 = ids[0]
82        for id in ids {
83            let domain = collection.borrowDomain(id: id)
84            let isDefault = domain.getText(key: "isDefault")
85            if isDefault == "true" {
86                defaultDomainID = id
87                break
88            }
89        }
90
91        let domain = collection.borrowDomain(id: defaultDomainID)
92        return domain.getDomainName()
93    }
94}
95
96
97