Skip to content

Commit 528e3a5

Browse files
FesenkoGFesenkoG
committed
more methods for ENS interaction added
1 parent f94d4e1 commit 528e3a5

File tree

4 files changed

+606
-156
lines changed

4 files changed

+606
-156
lines changed

‎web3swift/Utils/Classes/ENS.swift

Lines changed: 106 additions & 106 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,110 @@ public struct ENS {
3636
return Web3Options.defaultOptions()
3737
}()
3838

39+
//MARK: - Convenience methods
40+
public mutating func getAddress(_ domain: String) -> Result<EthereumAddress, Web3Error> {
41+
let resolver = self.resolver(forDomain: domain)
42+
switch resolver {
43+
case .success(var resolver):
44+
let isAddrSupports = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.addr.hash())
45+
switch isAddrSupports{
46+
case .success(let isSupported):
47+
if isSupported {
48+
return resolver.addr(forDomain: domain)
49+
} else {
50+
return Result.failure(Web3Error.dataError)
51+
}
52+
case .failure(let error):
53+
return Result.failure(error)
54+
}
55+
case .failure(let error):
56+
return Result.failure(error)
57+
}
58+
}
59+
60+
61+
public mutating func setAddress(domain: String, address: EthereumAddress, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error>{
62+
let resolver = self.resolver(forDomain: domain)
63+
switch resolver {
64+
case .success(var resolver):
65+
let isSetAddrSupported = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.addr.hash())
66+
switch isSetAddrSupported {
67+
case .success(let value):
68+
if value {
69+
return resolver.setAddr(node: domain, address: address, options: options, password: password)
70+
} else {
71+
return Result.failure(Web3Error.dataError)
72+
}
73+
case .failure(let error):
74+
return Result.failure(error)
75+
}
76+
case .failure(let error):
77+
return Result.failure(error)
78+
}
79+
}
80+
81+
public mutating func getPubkey(domain: String) -> Result<PublicKey, Web3Error> {
82+
let resolver = self.resolver(forDomain: domain)
83+
switch resolver {
84+
case .success(var resolver):
85+
let isPubkeySupports = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.pubkey.hash())
86+
switch isPubkeySupports {
87+
case .success(let value):
88+
if value {
89+
return resolver.pubkey(node: domain)
90+
} else {
91+
return Result.failure(Web3Error.dataError)
92+
}
93+
case .failure(let error):
94+
return Result.failure(error)
95+
}
96+
97+
case .failure(let error):
98+
return Result.failure(error)
99+
}
100+
}
101+
102+
mutating public func setPubkey(domain: String, x: String, y: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
103+
let resolver = self.resolver(forDomain: domain)
104+
switch resolver {
105+
case .success(var value):
106+
return value.setPubkey(node: domain, x: x, y: y, options: options, password: password)
107+
case .failure(let error):
108+
return Result.failure(error)
109+
}
110+
}
111+
112+
mutating public func getContent(domain: String) -> Result<String, Web3Error> {
113+
let resolver = self.resolver(forDomain: domain)
114+
switch resolver {
115+
case .success(var value):
116+
return value.content(node: domain)
117+
case .failure(let error):
118+
return Result.failure(error)
119+
}
120+
}
121+
122+
public mutating func setContent(domain: String, hash: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
123+
let resolver = self.resolver(forDomain: domain)
124+
switch resolver {
125+
case .success(var value):
126+
return value.setContent(node: domain, hash: hash, options: options, password: password)
127+
case .failure(let error):
128+
return Result.failure(error)
129+
}
130+
}
131+
132+
133+
public mutating func getMultihash(domain: String) -> Result<Data, Web3Error> {
134+
let resolver = self.resolver(forDomain: domain)
135+
switch resolver {
136+
case .success(var value):
137+
return value.multihash(node: domain)
138+
case .failure(let error):
139+
return Result.failure(error)
140+
}
141+
}
142+
39143

40144
//MARK: - Returns resolver for the given domain
41145
mutating func resolver(forDomain domain: String) -> Result<ResolverENS, Web3Error> {
@@ -97,7 +201,8 @@ public struct ENS {
97201
mutating func setSubnodeOwner(node: String, label: String, owner: EthereumAddress, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
98202
let options = getOptions(options)
99203
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
100-
guard let transaction = self.registryContract.method("setSubnodeOwner", parameters: [nameHash, label, owner] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError)}
204+
guard let labelHash = NameHash.nameHash(label) else { return Result.failure(Web3Error.dataError) }
205+
guard let transaction = self.registryContract.method("setSubnodeOwner", parameters: [nameHash, labelHash, owner] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError)}
101206
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
102207
switch result {
103208
case .success(let value):
@@ -136,111 +241,6 @@ public struct ENS {
136241
}
137242
}
138243

139-
//MARK: - Convenience methods
140-
141-
142-
public mutating func getAddress(_ domain: String) -> Result<EthereumAddress, Web3Error> {
143-
let resolver = self.resolver(forDomain: domain)
144-
switch resolver {
145-
case .success(var resolver):
146-
let isAddrSupports = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.addr.hash())
147-
switch isAddrSupports{
148-
case .success(let isSupported):
149-
if isSupported {
150-
return resolver.addr(forDomain: domain)
151-
} else {
152-
return Result.failure(Web3Error.dataError)
153-
}
154-
case .failure(let error):
155-
return Result.failure(error)
156-
}
157-
case .failure(let error):
158-
return Result.failure(error)
159-
}
160-
}
161-
162-
163-
public mutating func setAddress(domain: String, address: EthereumAddress, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error>{
164-
let resolver = self.resolver(forDomain: domain)
165-
switch resolver {
166-
case .success(var resolver):
167-
let isSetAddrSupported = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.setAddr.hash())
168-
switch isSetAddrSupported {
169-
case .success(let value):
170-
if value {
171-
return resolver.setAddr(node: domain, address: address, options: options, password: password)
172-
} else {
173-
return Result.failure(Web3Error.dataError)
174-
}
175-
case .failure(let error):
176-
return Result.failure(error)
177-
}
178-
case .failure(let error):
179-
return Result.failure(error)
180-
}
181-
}
182-
183-
public mutating func getPubkey(domain: String) -> Result<Point, Web3Error> {
184-
let resolver = self.resolver(forDomain: domain)
185-
switch resolver {
186-
case .success(var resolver):
187-
let isPubkeySupports = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.pubkey.hash())
188-
switch isPubkeySupports {
189-
case .success(let value):
190-
if value {
191-
return resolver.pubkey(node: domain)
192-
} else {
193-
return Result.failure(Web3Error.dataError)
194-
}
195-
case .failure(let error):
196-
return Result.failure(error)
197-
}
198-
199-
case .failure(let error):
200-
return Result.failure(error)
201-
}
202-
}
203-
204-
mutating public func setPubkey(domain: String, x: String, y: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
205-
let resolver = self.resolver(forDomain: domain)
206-
switch resolver {
207-
case .success(var value):
208-
return value.setPubkey(node: domain, x: x, y: y, options: options, password: password)
209-
case .failure(let error):
210-
return Result.failure(error)
211-
}
212-
}
213-
214-
mutating public func getContent(domain: String) -> Result<String, Web3Error> {
215-
let resolver = self.resolver(forDomain: domain)
216-
switch resolver {
217-
case .success(var value):
218-
return value.content(node: domain)
219-
case .failure(let error):
220-
return Result.failure(error)
221-
}
222-
}
223-
224-
225-
mutating public func setContent(domain: String, hash: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
226-
let resolver = self.resolver(forDomain: domain)
227-
switch resolver {
228-
case .success(var value):
229-
return value.setContent(node: domain, hash: hash, options: options, password: password)
230-
case .failure(let error):
231-
return Result.failure(error)
232-
}
233-
}
234-
235-
/*
236-
TODO:
237-
*/
238-
239-
//
240-
// public func getMultihash(domain: String) -> String {
241-
//
242-
// }
243-
244244
private func getOptions(_ options: Web3Options) -> Web3Options {
245245
var options = options
246246
options.to = self.ensContractAddress

‎web3swift/Utils/Classes/ENSResolver.swift

Lines changed: 51 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,9 @@ public struct ResolverENS {
1919
case name
2020
case ABI
2121
case pubkey
22-
case setAddr
2322
case content
23+
case multihash
24+
case text
2425

2526
func hash() -> String {
2627
switch self {
@@ -34,8 +35,10 @@ public struct ResolverENS {
3435
return "0xc8690233"
3536
case .content:
3637
return "0xd8389dc5"
37-
case .setAddr:
38-
return "0x01ffc9a7"
38+
case .multihash:
39+
return "0xe89401a1"
40+
case .text:
41+
return "0x59d1d43c"
3942
}
4043
}
4144
}
@@ -91,12 +94,7 @@ public struct ResolverENS {
9194
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError)}
9295
guard let transaction = self.resolverContract.method("setAddr", parameters: [nameHash, address] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
9396
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
94-
switch result {
95-
case .failure(let error):
96-
return Result.failure(error)
97-
case .success(let value):
98-
return Result(value)
99-
}
97+
return result
10098
}
10199

102100
//MARK: - returns corresponding ENS to the requested node
@@ -117,12 +115,7 @@ public struct ResolverENS {
117115
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
118116
guard let transaction = self.resolverContract.method("setName", parameters: [nameHash, name] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
119117
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
120-
switch result {
121-
case .success(let value):
122-
return Result(value)
123-
case .failure(let error):
124-
return Result.failure(error)
125-
}
118+
return result
126119
}
127120

128121
//MARK: - returns ABI in the requested encodings
@@ -145,16 +138,11 @@ public struct ResolverENS {
145138
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
146139
guard let transaction = self.resolverContract.method("setABI", parameters: [nameHash, contentType, data] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
147140
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
148-
switch result {
149-
case .success(let value):
150-
return Result(value)
151-
case .failure(let error):
152-
return Result.failure(error)
153-
}
141+
return result
154142
}
155143

156144
//MARK: - returns x and y coordinates
157-
mutating public func pubkey(node: String) -> Result<Point, Web3Error> {
145+
mutating public func pubkey(node: String) -> Result<PublicKey, Web3Error> {
158146
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
159147
guard let transaction = self.resolverContract.method("pubkey", parameters: [nameHash as AnyObject], options: defaultOptions) else { return Result.failure(Web3Error.transactionSerializationError) }
160148
let result = transaction.call(options: defaultOptions)
@@ -163,7 +151,7 @@ public struct ResolverENS {
163151
print(value)
164152
guard let x = value["x"] as? Data else { return Result.failure(Web3Error.dataError) }
165153
guard let y = value["y"] as? Data else { return Result.failure(Web3Error.dataError) }
166-
return Result(Point(x: "0x" + x.toHexString(), y: "0x" + y.toHexString()))
154+
return Result(PublicKey(x: "0x" + x.toHexString(), y: "0x" + y.toHexString()))
167155
case .failure(let error):
168156
return Result.failure(error)
169157
}
@@ -174,12 +162,7 @@ public struct ResolverENS {
174162
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
175163
guard let transaction = self.resolverContract.method("getPubkey", parameters: [nameHash, x, y] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
176164
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
177-
switch result {
178-
case .success(let value):
179-
return Result(value)
180-
case .failure(let error):
181-
return Result.failure(error)
182-
}
165+
return result
183166
}
184167

185168
mutating func content(node: String) -> Result<String, Web3Error> {
@@ -195,27 +178,62 @@ public struct ResolverENS {
195178
}
196179
}
197180

198-
mutating func setContent(node: String, hash: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error>{
181+
mutating func setContent(node: String, hash: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
199182
let options = getOptions(options)
200183
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
201184
guard let transaction = self.resolverContract.method("setContent", parameters: [nameHash, hash] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
202185
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
186+
return result
187+
}
188+
//function multihash(bytes32 node) public view returns (bytes)
189+
mutating public func multihash(node: String) -> Result<Data, Web3Error> {
190+
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.transactionSerializationError) }
191+
guard let transaction = self.resolverContract.method("multihash", parameters: [nameHash] as [AnyObject], options: self.defaultOptions) else { return Result.failure(Web3Error.dataError) }
192+
let result = transaction.call(options: defaultOptions)
203193
switch result {
204194
case .success(let value):
205-
return Result(value)
195+
guard let hash = value["0"] as? Data else { return Result.failure(Web3Error.dataError) }
196+
return Result(hash)
206197
case .failure(let error):
207198
return Result.failure(error)
208199
}
209200
}
210-
201+
//function setMultihash(bytes32 node, bytes hash) public only_owner(node)
202+
mutating public func setMultihash(node: String, hash: Data, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
203+
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.transactionSerializationError) }
204+
let options = getOptions(options)
205+
guard let transaction = self.resolverContract.method("setMultihash", parameters: [nameHash, hash] as [AnyObject], options: options) else { return Result.failure(Web3Error.dataError) }
206+
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
207+
return result
208+
}
209+
//function text(bytes32 node, string key) public view returns (string)
210+
mutating public func text(node: String, key: String) -> Result<String, Web3Error> {
211+
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
212+
guard let transaction = self.resolverContract.method("text", parameters: [nameHash, key] as [AnyObject], options: defaultOptions) else { return Result.failure(Web3Error.transactionSerializationError) }
213+
let result = transaction.call(options: defaultOptions)
214+
switch result {
215+
case .failure(let error):
216+
return Result.failure(error)
217+
case .success(let value):
218+
guard let ans = value["0"] as? String else { return Result.failure(Web3Error.dataError) }
219+
return Result(ans)
220+
}
221+
}
222+
//function setText(bytes32 node, string key, string value) public only_owner(node)
223+
mutating public func setText(node: String, key: String, value: String, options: Web3Options, password: String? = nil) -> Result<TransactionSendingResult, Web3Error> {
224+
guard let nameHash = NameHash.nameHash(node) else { return Result.failure(Web3Error.dataError) }
225+
guard let transaction = self.resolverContract.method("setText", parameters: [nameHash, key, value] as [AnyObject], options: options) else { return Result.failure(Web3Error.transactionSerializationError) }
226+
let result = password == nil ? transaction.send() : transaction.send(password: password!, options: options)
227+
return result
228+
}
211229
private func getOptions(_ options: Web3Options) -> Web3Options {
212230
var options = options
213231
options.to = self.resolverAddress
214232
return options
215233
}
216234
}
217235

218-
public struct Point {
236+
public struct PublicKey {
219237
let x: String
220238
let y: String
221239
}

0 commit comments

Comments
 (0)