@gitmyabi-stg/ens--resolver-contracts 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +108 -0
- package/contracts/PublicResolver_json.d.ts +1627 -0
- package/contracts/PublicResolver_json.js +1777 -0
- package/contracts/PublicResolver_json.ts +2145 -0
- package/contracts/UniversalResolver_json.d.ts +794 -0
- package/contracts/UniversalResolver_json.js +1005 -0
- package/contracts/UniversalResolver_json.ts +1081 -0
- package/contracts/index.d.ts +4 -0
- package/contracts/index.js +10 -0
- package/contracts/index.ts +5 -0
- package/index.d.ts +1 -0
- package/index.js +19 -0
- package/package.json +43 -0
|
@@ -0,0 +1,1777 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.PublicResolver_json = exports.PublicResolver_jsonAbi = void 0;
|
|
4
|
+
const viem_1 = require("viem");
|
|
5
|
+
/**
|
|
6
|
+
* PublicResolver_json ABI
|
|
7
|
+
*
|
|
8
|
+
* This ABI is typed using viem's type system for full type safety.
|
|
9
|
+
*/
|
|
10
|
+
exports.PublicResolver_jsonAbi = [
|
|
11
|
+
{
|
|
12
|
+
"inputs": [
|
|
13
|
+
{
|
|
14
|
+
"internalType": "contract ENS",
|
|
15
|
+
"name": "_ens",
|
|
16
|
+
"type": "address"
|
|
17
|
+
},
|
|
18
|
+
{
|
|
19
|
+
"internalType": "contract INameWrapper",
|
|
20
|
+
"name": "wrapperAddress",
|
|
21
|
+
"type": "address"
|
|
22
|
+
},
|
|
23
|
+
{
|
|
24
|
+
"internalType": "address",
|
|
25
|
+
"name": "_trustedETHController",
|
|
26
|
+
"type": "address"
|
|
27
|
+
},
|
|
28
|
+
{
|
|
29
|
+
"internalType": "address",
|
|
30
|
+
"name": "_trustedReverseRegistrar",
|
|
31
|
+
"type": "address"
|
|
32
|
+
}
|
|
33
|
+
],
|
|
34
|
+
"stateMutability": "nonpayable",
|
|
35
|
+
"type": "constructor"
|
|
36
|
+
},
|
|
37
|
+
{
|
|
38
|
+
"inputs": [
|
|
39
|
+
{
|
|
40
|
+
"internalType": "bytes",
|
|
41
|
+
"name": "addressBytes",
|
|
42
|
+
"type": "bytes"
|
|
43
|
+
}
|
|
44
|
+
],
|
|
45
|
+
"name": "InvalidEVMAddress",
|
|
46
|
+
"type": "error"
|
|
47
|
+
},
|
|
48
|
+
{
|
|
49
|
+
"anonymous": false,
|
|
50
|
+
"inputs": [
|
|
51
|
+
{
|
|
52
|
+
"indexed": true,
|
|
53
|
+
"internalType": "bytes32",
|
|
54
|
+
"name": "node",
|
|
55
|
+
"type": "bytes32"
|
|
56
|
+
},
|
|
57
|
+
{
|
|
58
|
+
"indexed": true,
|
|
59
|
+
"internalType": "uint256",
|
|
60
|
+
"name": "contentType",
|
|
61
|
+
"type": "uint256"
|
|
62
|
+
}
|
|
63
|
+
],
|
|
64
|
+
"name": "ABIChanged",
|
|
65
|
+
"type": "event"
|
|
66
|
+
},
|
|
67
|
+
{
|
|
68
|
+
"anonymous": false,
|
|
69
|
+
"inputs": [
|
|
70
|
+
{
|
|
71
|
+
"indexed": true,
|
|
72
|
+
"internalType": "bytes32",
|
|
73
|
+
"name": "node",
|
|
74
|
+
"type": "bytes32"
|
|
75
|
+
},
|
|
76
|
+
{
|
|
77
|
+
"indexed": false,
|
|
78
|
+
"internalType": "address",
|
|
79
|
+
"name": "a",
|
|
80
|
+
"type": "address"
|
|
81
|
+
}
|
|
82
|
+
],
|
|
83
|
+
"name": "AddrChanged",
|
|
84
|
+
"type": "event"
|
|
85
|
+
},
|
|
86
|
+
{
|
|
87
|
+
"anonymous": false,
|
|
88
|
+
"inputs": [
|
|
89
|
+
{
|
|
90
|
+
"indexed": true,
|
|
91
|
+
"internalType": "bytes32",
|
|
92
|
+
"name": "node",
|
|
93
|
+
"type": "bytes32"
|
|
94
|
+
},
|
|
95
|
+
{
|
|
96
|
+
"indexed": false,
|
|
97
|
+
"internalType": "uint256",
|
|
98
|
+
"name": "coinType",
|
|
99
|
+
"type": "uint256"
|
|
100
|
+
},
|
|
101
|
+
{
|
|
102
|
+
"indexed": false,
|
|
103
|
+
"internalType": "bytes",
|
|
104
|
+
"name": "newAddress",
|
|
105
|
+
"type": "bytes"
|
|
106
|
+
}
|
|
107
|
+
],
|
|
108
|
+
"name": "AddressChanged",
|
|
109
|
+
"type": "event"
|
|
110
|
+
},
|
|
111
|
+
{
|
|
112
|
+
"anonymous": false,
|
|
113
|
+
"inputs": [
|
|
114
|
+
{
|
|
115
|
+
"indexed": true,
|
|
116
|
+
"internalType": "address",
|
|
117
|
+
"name": "owner",
|
|
118
|
+
"type": "address"
|
|
119
|
+
},
|
|
120
|
+
{
|
|
121
|
+
"indexed": true,
|
|
122
|
+
"internalType": "address",
|
|
123
|
+
"name": "operator",
|
|
124
|
+
"type": "address"
|
|
125
|
+
},
|
|
126
|
+
{
|
|
127
|
+
"indexed": false,
|
|
128
|
+
"internalType": "bool",
|
|
129
|
+
"name": "approved",
|
|
130
|
+
"type": "bool"
|
|
131
|
+
}
|
|
132
|
+
],
|
|
133
|
+
"name": "ApprovalForAll",
|
|
134
|
+
"type": "event"
|
|
135
|
+
},
|
|
136
|
+
{
|
|
137
|
+
"anonymous": false,
|
|
138
|
+
"inputs": [
|
|
139
|
+
{
|
|
140
|
+
"indexed": false,
|
|
141
|
+
"internalType": "address",
|
|
142
|
+
"name": "owner",
|
|
143
|
+
"type": "address"
|
|
144
|
+
},
|
|
145
|
+
{
|
|
146
|
+
"indexed": true,
|
|
147
|
+
"internalType": "bytes32",
|
|
148
|
+
"name": "node",
|
|
149
|
+
"type": "bytes32"
|
|
150
|
+
},
|
|
151
|
+
{
|
|
152
|
+
"indexed": true,
|
|
153
|
+
"internalType": "address",
|
|
154
|
+
"name": "delegate",
|
|
155
|
+
"type": "address"
|
|
156
|
+
},
|
|
157
|
+
{
|
|
158
|
+
"indexed": true,
|
|
159
|
+
"internalType": "bool",
|
|
160
|
+
"name": "approved",
|
|
161
|
+
"type": "bool"
|
|
162
|
+
}
|
|
163
|
+
],
|
|
164
|
+
"name": "Approved",
|
|
165
|
+
"type": "event"
|
|
166
|
+
},
|
|
167
|
+
{
|
|
168
|
+
"anonymous": false,
|
|
169
|
+
"inputs": [
|
|
170
|
+
{
|
|
171
|
+
"indexed": true,
|
|
172
|
+
"internalType": "bytes32",
|
|
173
|
+
"name": "node",
|
|
174
|
+
"type": "bytes32"
|
|
175
|
+
},
|
|
176
|
+
{
|
|
177
|
+
"indexed": false,
|
|
178
|
+
"internalType": "bytes",
|
|
179
|
+
"name": "hash",
|
|
180
|
+
"type": "bytes"
|
|
181
|
+
}
|
|
182
|
+
],
|
|
183
|
+
"name": "ContenthashChanged",
|
|
184
|
+
"type": "event"
|
|
185
|
+
},
|
|
186
|
+
{
|
|
187
|
+
"anonymous": false,
|
|
188
|
+
"inputs": [
|
|
189
|
+
{
|
|
190
|
+
"indexed": true,
|
|
191
|
+
"internalType": "bytes32",
|
|
192
|
+
"name": "node",
|
|
193
|
+
"type": "bytes32"
|
|
194
|
+
},
|
|
195
|
+
{
|
|
196
|
+
"indexed": false,
|
|
197
|
+
"internalType": "bytes",
|
|
198
|
+
"name": "name",
|
|
199
|
+
"type": "bytes"
|
|
200
|
+
},
|
|
201
|
+
{
|
|
202
|
+
"indexed": false,
|
|
203
|
+
"internalType": "uint16",
|
|
204
|
+
"name": "resource",
|
|
205
|
+
"type": "uint16"
|
|
206
|
+
},
|
|
207
|
+
{
|
|
208
|
+
"indexed": false,
|
|
209
|
+
"internalType": "bytes",
|
|
210
|
+
"name": "record",
|
|
211
|
+
"type": "bytes"
|
|
212
|
+
}
|
|
213
|
+
],
|
|
214
|
+
"name": "DNSRecordChanged",
|
|
215
|
+
"type": "event"
|
|
216
|
+
},
|
|
217
|
+
{
|
|
218
|
+
"anonymous": false,
|
|
219
|
+
"inputs": [
|
|
220
|
+
{
|
|
221
|
+
"indexed": true,
|
|
222
|
+
"internalType": "bytes32",
|
|
223
|
+
"name": "node",
|
|
224
|
+
"type": "bytes32"
|
|
225
|
+
},
|
|
226
|
+
{
|
|
227
|
+
"indexed": false,
|
|
228
|
+
"internalType": "bytes",
|
|
229
|
+
"name": "name",
|
|
230
|
+
"type": "bytes"
|
|
231
|
+
},
|
|
232
|
+
{
|
|
233
|
+
"indexed": false,
|
|
234
|
+
"internalType": "uint16",
|
|
235
|
+
"name": "resource",
|
|
236
|
+
"type": "uint16"
|
|
237
|
+
}
|
|
238
|
+
],
|
|
239
|
+
"name": "DNSRecordDeleted",
|
|
240
|
+
"type": "event"
|
|
241
|
+
},
|
|
242
|
+
{
|
|
243
|
+
"anonymous": false,
|
|
244
|
+
"inputs": [
|
|
245
|
+
{
|
|
246
|
+
"indexed": true,
|
|
247
|
+
"internalType": "bytes32",
|
|
248
|
+
"name": "node",
|
|
249
|
+
"type": "bytes32"
|
|
250
|
+
},
|
|
251
|
+
{
|
|
252
|
+
"indexed": false,
|
|
253
|
+
"internalType": "bytes",
|
|
254
|
+
"name": "lastzonehash",
|
|
255
|
+
"type": "bytes"
|
|
256
|
+
},
|
|
257
|
+
{
|
|
258
|
+
"indexed": false,
|
|
259
|
+
"internalType": "bytes",
|
|
260
|
+
"name": "zonehash",
|
|
261
|
+
"type": "bytes"
|
|
262
|
+
}
|
|
263
|
+
],
|
|
264
|
+
"name": "DNSZonehashChanged",
|
|
265
|
+
"type": "event"
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
"anonymous": false,
|
|
269
|
+
"inputs": [
|
|
270
|
+
{
|
|
271
|
+
"indexed": true,
|
|
272
|
+
"internalType": "bytes32",
|
|
273
|
+
"name": "node",
|
|
274
|
+
"type": "bytes32"
|
|
275
|
+
},
|
|
276
|
+
{
|
|
277
|
+
"indexed": true,
|
|
278
|
+
"internalType": "bytes4",
|
|
279
|
+
"name": "interfaceID",
|
|
280
|
+
"type": "bytes4"
|
|
281
|
+
},
|
|
282
|
+
{
|
|
283
|
+
"indexed": false,
|
|
284
|
+
"internalType": "address",
|
|
285
|
+
"name": "implementer",
|
|
286
|
+
"type": "address"
|
|
287
|
+
}
|
|
288
|
+
],
|
|
289
|
+
"name": "InterfaceChanged",
|
|
290
|
+
"type": "event"
|
|
291
|
+
},
|
|
292
|
+
{
|
|
293
|
+
"anonymous": false,
|
|
294
|
+
"inputs": [
|
|
295
|
+
{
|
|
296
|
+
"indexed": true,
|
|
297
|
+
"internalType": "bytes32",
|
|
298
|
+
"name": "node",
|
|
299
|
+
"type": "bytes32"
|
|
300
|
+
},
|
|
301
|
+
{
|
|
302
|
+
"indexed": false,
|
|
303
|
+
"internalType": "string",
|
|
304
|
+
"name": "name",
|
|
305
|
+
"type": "string"
|
|
306
|
+
}
|
|
307
|
+
],
|
|
308
|
+
"name": "NameChanged",
|
|
309
|
+
"type": "event"
|
|
310
|
+
},
|
|
311
|
+
{
|
|
312
|
+
"anonymous": false,
|
|
313
|
+
"inputs": [
|
|
314
|
+
{
|
|
315
|
+
"indexed": true,
|
|
316
|
+
"internalType": "bytes32",
|
|
317
|
+
"name": "node",
|
|
318
|
+
"type": "bytes32"
|
|
319
|
+
},
|
|
320
|
+
{
|
|
321
|
+
"indexed": false,
|
|
322
|
+
"internalType": "bytes32",
|
|
323
|
+
"name": "x",
|
|
324
|
+
"type": "bytes32"
|
|
325
|
+
},
|
|
326
|
+
{
|
|
327
|
+
"indexed": false,
|
|
328
|
+
"internalType": "bytes32",
|
|
329
|
+
"name": "y",
|
|
330
|
+
"type": "bytes32"
|
|
331
|
+
}
|
|
332
|
+
],
|
|
333
|
+
"name": "PubkeyChanged",
|
|
334
|
+
"type": "event"
|
|
335
|
+
},
|
|
336
|
+
{
|
|
337
|
+
"anonymous": false,
|
|
338
|
+
"inputs": [
|
|
339
|
+
{
|
|
340
|
+
"indexed": true,
|
|
341
|
+
"internalType": "bytes32",
|
|
342
|
+
"name": "node",
|
|
343
|
+
"type": "bytes32"
|
|
344
|
+
},
|
|
345
|
+
{
|
|
346
|
+
"indexed": true,
|
|
347
|
+
"internalType": "string",
|
|
348
|
+
"name": "indexedKey",
|
|
349
|
+
"type": "string"
|
|
350
|
+
},
|
|
351
|
+
{
|
|
352
|
+
"indexed": false,
|
|
353
|
+
"internalType": "string",
|
|
354
|
+
"name": "key",
|
|
355
|
+
"type": "string"
|
|
356
|
+
},
|
|
357
|
+
{
|
|
358
|
+
"indexed": false,
|
|
359
|
+
"internalType": "string",
|
|
360
|
+
"name": "value",
|
|
361
|
+
"type": "string"
|
|
362
|
+
}
|
|
363
|
+
],
|
|
364
|
+
"name": "TextChanged",
|
|
365
|
+
"type": "event"
|
|
366
|
+
},
|
|
367
|
+
{
|
|
368
|
+
"anonymous": false,
|
|
369
|
+
"inputs": [
|
|
370
|
+
{
|
|
371
|
+
"indexed": true,
|
|
372
|
+
"internalType": "bytes32",
|
|
373
|
+
"name": "node",
|
|
374
|
+
"type": "bytes32"
|
|
375
|
+
},
|
|
376
|
+
{
|
|
377
|
+
"indexed": false,
|
|
378
|
+
"internalType": "uint64",
|
|
379
|
+
"name": "newVersion",
|
|
380
|
+
"type": "uint64"
|
|
381
|
+
}
|
|
382
|
+
],
|
|
383
|
+
"name": "VersionChanged",
|
|
384
|
+
"type": "event"
|
|
385
|
+
},
|
|
386
|
+
{
|
|
387
|
+
"inputs": [
|
|
388
|
+
{
|
|
389
|
+
"internalType": "bytes32",
|
|
390
|
+
"name": "node",
|
|
391
|
+
"type": "bytes32"
|
|
392
|
+
},
|
|
393
|
+
{
|
|
394
|
+
"internalType": "uint256",
|
|
395
|
+
"name": "contentTypes",
|
|
396
|
+
"type": "uint256"
|
|
397
|
+
}
|
|
398
|
+
],
|
|
399
|
+
"name": "ABI",
|
|
400
|
+
"outputs": [
|
|
401
|
+
{
|
|
402
|
+
"internalType": "uint256",
|
|
403
|
+
"name": "",
|
|
404
|
+
"type": "uint256"
|
|
405
|
+
},
|
|
406
|
+
{
|
|
407
|
+
"internalType": "bytes",
|
|
408
|
+
"name": "",
|
|
409
|
+
"type": "bytes"
|
|
410
|
+
}
|
|
411
|
+
],
|
|
412
|
+
"stateMutability": "view",
|
|
413
|
+
"type": "function"
|
|
414
|
+
},
|
|
415
|
+
{
|
|
416
|
+
"inputs": [
|
|
417
|
+
{
|
|
418
|
+
"internalType": "bytes32",
|
|
419
|
+
"name": "node",
|
|
420
|
+
"type": "bytes32"
|
|
421
|
+
}
|
|
422
|
+
],
|
|
423
|
+
"name": "addr",
|
|
424
|
+
"outputs": [
|
|
425
|
+
{
|
|
426
|
+
"internalType": "address payable",
|
|
427
|
+
"name": "",
|
|
428
|
+
"type": "address"
|
|
429
|
+
}
|
|
430
|
+
],
|
|
431
|
+
"stateMutability": "view",
|
|
432
|
+
"type": "function"
|
|
433
|
+
},
|
|
434
|
+
{
|
|
435
|
+
"inputs": [
|
|
436
|
+
{
|
|
437
|
+
"internalType": "bytes32",
|
|
438
|
+
"name": "node",
|
|
439
|
+
"type": "bytes32"
|
|
440
|
+
},
|
|
441
|
+
{
|
|
442
|
+
"internalType": "uint256",
|
|
443
|
+
"name": "coinType",
|
|
444
|
+
"type": "uint256"
|
|
445
|
+
}
|
|
446
|
+
],
|
|
447
|
+
"name": "addr",
|
|
448
|
+
"outputs": [
|
|
449
|
+
{
|
|
450
|
+
"internalType": "bytes",
|
|
451
|
+
"name": "addressBytes",
|
|
452
|
+
"type": "bytes"
|
|
453
|
+
}
|
|
454
|
+
],
|
|
455
|
+
"stateMutability": "view",
|
|
456
|
+
"type": "function"
|
|
457
|
+
},
|
|
458
|
+
{
|
|
459
|
+
"inputs": [
|
|
460
|
+
{
|
|
461
|
+
"internalType": "bytes32",
|
|
462
|
+
"name": "node",
|
|
463
|
+
"type": "bytes32"
|
|
464
|
+
},
|
|
465
|
+
{
|
|
466
|
+
"internalType": "address",
|
|
467
|
+
"name": "delegate",
|
|
468
|
+
"type": "address"
|
|
469
|
+
},
|
|
470
|
+
{
|
|
471
|
+
"internalType": "bool",
|
|
472
|
+
"name": "approved",
|
|
473
|
+
"type": "bool"
|
|
474
|
+
}
|
|
475
|
+
],
|
|
476
|
+
"name": "approve",
|
|
477
|
+
"outputs": [],
|
|
478
|
+
"stateMutability": "nonpayable",
|
|
479
|
+
"type": "function"
|
|
480
|
+
},
|
|
481
|
+
{
|
|
482
|
+
"inputs": [
|
|
483
|
+
{
|
|
484
|
+
"internalType": "bytes32",
|
|
485
|
+
"name": "node",
|
|
486
|
+
"type": "bytes32"
|
|
487
|
+
}
|
|
488
|
+
],
|
|
489
|
+
"name": "clearRecords",
|
|
490
|
+
"outputs": [],
|
|
491
|
+
"stateMutability": "nonpayable",
|
|
492
|
+
"type": "function"
|
|
493
|
+
},
|
|
494
|
+
{
|
|
495
|
+
"inputs": [
|
|
496
|
+
{
|
|
497
|
+
"internalType": "bytes32",
|
|
498
|
+
"name": "node",
|
|
499
|
+
"type": "bytes32"
|
|
500
|
+
}
|
|
501
|
+
],
|
|
502
|
+
"name": "contenthash",
|
|
503
|
+
"outputs": [
|
|
504
|
+
{
|
|
505
|
+
"internalType": "bytes",
|
|
506
|
+
"name": "",
|
|
507
|
+
"type": "bytes"
|
|
508
|
+
}
|
|
509
|
+
],
|
|
510
|
+
"stateMutability": "view",
|
|
511
|
+
"type": "function"
|
|
512
|
+
},
|
|
513
|
+
{
|
|
514
|
+
"inputs": [
|
|
515
|
+
{
|
|
516
|
+
"internalType": "bytes32",
|
|
517
|
+
"name": "node",
|
|
518
|
+
"type": "bytes32"
|
|
519
|
+
},
|
|
520
|
+
{
|
|
521
|
+
"internalType": "bytes32",
|
|
522
|
+
"name": "name",
|
|
523
|
+
"type": "bytes32"
|
|
524
|
+
},
|
|
525
|
+
{
|
|
526
|
+
"internalType": "uint16",
|
|
527
|
+
"name": "resource",
|
|
528
|
+
"type": "uint16"
|
|
529
|
+
}
|
|
530
|
+
],
|
|
531
|
+
"name": "dnsRecord",
|
|
532
|
+
"outputs": [
|
|
533
|
+
{
|
|
534
|
+
"internalType": "bytes",
|
|
535
|
+
"name": "",
|
|
536
|
+
"type": "bytes"
|
|
537
|
+
}
|
|
538
|
+
],
|
|
539
|
+
"stateMutability": "view",
|
|
540
|
+
"type": "function"
|
|
541
|
+
},
|
|
542
|
+
{
|
|
543
|
+
"inputs": [
|
|
544
|
+
{
|
|
545
|
+
"internalType": "bytes32",
|
|
546
|
+
"name": "node",
|
|
547
|
+
"type": "bytes32"
|
|
548
|
+
},
|
|
549
|
+
{
|
|
550
|
+
"internalType": "uint256",
|
|
551
|
+
"name": "coinType",
|
|
552
|
+
"type": "uint256"
|
|
553
|
+
}
|
|
554
|
+
],
|
|
555
|
+
"name": "hasAddr",
|
|
556
|
+
"outputs": [
|
|
557
|
+
{
|
|
558
|
+
"internalType": "bool",
|
|
559
|
+
"name": "",
|
|
560
|
+
"type": "bool"
|
|
561
|
+
}
|
|
562
|
+
],
|
|
563
|
+
"stateMutability": "view",
|
|
564
|
+
"type": "function"
|
|
565
|
+
},
|
|
566
|
+
{
|
|
567
|
+
"inputs": [
|
|
568
|
+
{
|
|
569
|
+
"internalType": "bytes32",
|
|
570
|
+
"name": "node",
|
|
571
|
+
"type": "bytes32"
|
|
572
|
+
},
|
|
573
|
+
{
|
|
574
|
+
"internalType": "bytes32",
|
|
575
|
+
"name": "name",
|
|
576
|
+
"type": "bytes32"
|
|
577
|
+
}
|
|
578
|
+
],
|
|
579
|
+
"name": "hasDNSRecords",
|
|
580
|
+
"outputs": [
|
|
581
|
+
{
|
|
582
|
+
"internalType": "bool",
|
|
583
|
+
"name": "",
|
|
584
|
+
"type": "bool"
|
|
585
|
+
}
|
|
586
|
+
],
|
|
587
|
+
"stateMutability": "view",
|
|
588
|
+
"type": "function"
|
|
589
|
+
},
|
|
590
|
+
{
|
|
591
|
+
"inputs": [
|
|
592
|
+
{
|
|
593
|
+
"internalType": "bytes32",
|
|
594
|
+
"name": "node",
|
|
595
|
+
"type": "bytes32"
|
|
596
|
+
},
|
|
597
|
+
{
|
|
598
|
+
"internalType": "bytes4",
|
|
599
|
+
"name": "interfaceID",
|
|
600
|
+
"type": "bytes4"
|
|
601
|
+
}
|
|
602
|
+
],
|
|
603
|
+
"name": "interfaceImplementer",
|
|
604
|
+
"outputs": [
|
|
605
|
+
{
|
|
606
|
+
"internalType": "address",
|
|
607
|
+
"name": "",
|
|
608
|
+
"type": "address"
|
|
609
|
+
}
|
|
610
|
+
],
|
|
611
|
+
"stateMutability": "view",
|
|
612
|
+
"type": "function"
|
|
613
|
+
},
|
|
614
|
+
{
|
|
615
|
+
"inputs": [
|
|
616
|
+
{
|
|
617
|
+
"internalType": "address",
|
|
618
|
+
"name": "owner",
|
|
619
|
+
"type": "address"
|
|
620
|
+
},
|
|
621
|
+
{
|
|
622
|
+
"internalType": "bytes32",
|
|
623
|
+
"name": "node",
|
|
624
|
+
"type": "bytes32"
|
|
625
|
+
},
|
|
626
|
+
{
|
|
627
|
+
"internalType": "address",
|
|
628
|
+
"name": "delegate",
|
|
629
|
+
"type": "address"
|
|
630
|
+
}
|
|
631
|
+
],
|
|
632
|
+
"name": "isApprovedFor",
|
|
633
|
+
"outputs": [
|
|
634
|
+
{
|
|
635
|
+
"internalType": "bool",
|
|
636
|
+
"name": "",
|
|
637
|
+
"type": "bool"
|
|
638
|
+
}
|
|
639
|
+
],
|
|
640
|
+
"stateMutability": "view",
|
|
641
|
+
"type": "function"
|
|
642
|
+
},
|
|
643
|
+
{
|
|
644
|
+
"inputs": [
|
|
645
|
+
{
|
|
646
|
+
"internalType": "address",
|
|
647
|
+
"name": "account",
|
|
648
|
+
"type": "address"
|
|
649
|
+
},
|
|
650
|
+
{
|
|
651
|
+
"internalType": "address",
|
|
652
|
+
"name": "operator",
|
|
653
|
+
"type": "address"
|
|
654
|
+
}
|
|
655
|
+
],
|
|
656
|
+
"name": "isApprovedForAll",
|
|
657
|
+
"outputs": [
|
|
658
|
+
{
|
|
659
|
+
"internalType": "bool",
|
|
660
|
+
"name": "",
|
|
661
|
+
"type": "bool"
|
|
662
|
+
}
|
|
663
|
+
],
|
|
664
|
+
"stateMutability": "view",
|
|
665
|
+
"type": "function"
|
|
666
|
+
},
|
|
667
|
+
{
|
|
668
|
+
"inputs": [
|
|
669
|
+
{
|
|
670
|
+
"internalType": "bytes[]",
|
|
671
|
+
"name": "data",
|
|
672
|
+
"type": "bytes[]"
|
|
673
|
+
}
|
|
674
|
+
],
|
|
675
|
+
"name": "multicall",
|
|
676
|
+
"outputs": [
|
|
677
|
+
{
|
|
678
|
+
"internalType": "bytes[]",
|
|
679
|
+
"name": "results",
|
|
680
|
+
"type": "bytes[]"
|
|
681
|
+
}
|
|
682
|
+
],
|
|
683
|
+
"stateMutability": "nonpayable",
|
|
684
|
+
"type": "function"
|
|
685
|
+
},
|
|
686
|
+
{
|
|
687
|
+
"inputs": [
|
|
688
|
+
{
|
|
689
|
+
"internalType": "bytes32",
|
|
690
|
+
"name": "nodehash",
|
|
691
|
+
"type": "bytes32"
|
|
692
|
+
},
|
|
693
|
+
{
|
|
694
|
+
"internalType": "bytes[]",
|
|
695
|
+
"name": "data",
|
|
696
|
+
"type": "bytes[]"
|
|
697
|
+
}
|
|
698
|
+
],
|
|
699
|
+
"name": "multicallWithNodeCheck",
|
|
700
|
+
"outputs": [
|
|
701
|
+
{
|
|
702
|
+
"internalType": "bytes[]",
|
|
703
|
+
"name": "results",
|
|
704
|
+
"type": "bytes[]"
|
|
705
|
+
}
|
|
706
|
+
],
|
|
707
|
+
"stateMutability": "nonpayable",
|
|
708
|
+
"type": "function"
|
|
709
|
+
},
|
|
710
|
+
{
|
|
711
|
+
"inputs": [
|
|
712
|
+
{
|
|
713
|
+
"internalType": "bytes32",
|
|
714
|
+
"name": "node",
|
|
715
|
+
"type": "bytes32"
|
|
716
|
+
}
|
|
717
|
+
],
|
|
718
|
+
"name": "name",
|
|
719
|
+
"outputs": [
|
|
720
|
+
{
|
|
721
|
+
"internalType": "string",
|
|
722
|
+
"name": "",
|
|
723
|
+
"type": "string"
|
|
724
|
+
}
|
|
725
|
+
],
|
|
726
|
+
"stateMutability": "view",
|
|
727
|
+
"type": "function"
|
|
728
|
+
},
|
|
729
|
+
{
|
|
730
|
+
"inputs": [
|
|
731
|
+
{
|
|
732
|
+
"internalType": "bytes32",
|
|
733
|
+
"name": "node",
|
|
734
|
+
"type": "bytes32"
|
|
735
|
+
}
|
|
736
|
+
],
|
|
737
|
+
"name": "pubkey",
|
|
738
|
+
"outputs": [
|
|
739
|
+
{
|
|
740
|
+
"internalType": "bytes32",
|
|
741
|
+
"name": "x",
|
|
742
|
+
"type": "bytes32"
|
|
743
|
+
},
|
|
744
|
+
{
|
|
745
|
+
"internalType": "bytes32",
|
|
746
|
+
"name": "y",
|
|
747
|
+
"type": "bytes32"
|
|
748
|
+
}
|
|
749
|
+
],
|
|
750
|
+
"stateMutability": "view",
|
|
751
|
+
"type": "function"
|
|
752
|
+
},
|
|
753
|
+
{
|
|
754
|
+
"inputs": [
|
|
755
|
+
{
|
|
756
|
+
"internalType": "bytes32",
|
|
757
|
+
"name": "",
|
|
758
|
+
"type": "bytes32"
|
|
759
|
+
}
|
|
760
|
+
],
|
|
761
|
+
"name": "recordVersions",
|
|
762
|
+
"outputs": [
|
|
763
|
+
{
|
|
764
|
+
"internalType": "uint64",
|
|
765
|
+
"name": "",
|
|
766
|
+
"type": "uint64"
|
|
767
|
+
}
|
|
768
|
+
],
|
|
769
|
+
"stateMutability": "view",
|
|
770
|
+
"type": "function"
|
|
771
|
+
},
|
|
772
|
+
{
|
|
773
|
+
"inputs": [
|
|
774
|
+
{
|
|
775
|
+
"internalType": "bytes32",
|
|
776
|
+
"name": "node",
|
|
777
|
+
"type": "bytes32"
|
|
778
|
+
},
|
|
779
|
+
{
|
|
780
|
+
"internalType": "uint256",
|
|
781
|
+
"name": "contentType",
|
|
782
|
+
"type": "uint256"
|
|
783
|
+
},
|
|
784
|
+
{
|
|
785
|
+
"internalType": "bytes",
|
|
786
|
+
"name": "data",
|
|
787
|
+
"type": "bytes"
|
|
788
|
+
}
|
|
789
|
+
],
|
|
790
|
+
"name": "setABI",
|
|
791
|
+
"outputs": [],
|
|
792
|
+
"stateMutability": "nonpayable",
|
|
793
|
+
"type": "function"
|
|
794
|
+
},
|
|
795
|
+
{
|
|
796
|
+
"inputs": [
|
|
797
|
+
{
|
|
798
|
+
"internalType": "bytes32",
|
|
799
|
+
"name": "node",
|
|
800
|
+
"type": "bytes32"
|
|
801
|
+
},
|
|
802
|
+
{
|
|
803
|
+
"internalType": "uint256",
|
|
804
|
+
"name": "coinType",
|
|
805
|
+
"type": "uint256"
|
|
806
|
+
},
|
|
807
|
+
{
|
|
808
|
+
"internalType": "bytes",
|
|
809
|
+
"name": "addressBytes",
|
|
810
|
+
"type": "bytes"
|
|
811
|
+
}
|
|
812
|
+
],
|
|
813
|
+
"name": "setAddr",
|
|
814
|
+
"outputs": [],
|
|
815
|
+
"stateMutability": "nonpayable",
|
|
816
|
+
"type": "function"
|
|
817
|
+
},
|
|
818
|
+
{
|
|
819
|
+
"inputs": [
|
|
820
|
+
{
|
|
821
|
+
"internalType": "bytes32",
|
|
822
|
+
"name": "node",
|
|
823
|
+
"type": "bytes32"
|
|
824
|
+
},
|
|
825
|
+
{
|
|
826
|
+
"internalType": "address",
|
|
827
|
+
"name": "_addr",
|
|
828
|
+
"type": "address"
|
|
829
|
+
}
|
|
830
|
+
],
|
|
831
|
+
"name": "setAddr",
|
|
832
|
+
"outputs": [],
|
|
833
|
+
"stateMutability": "nonpayable",
|
|
834
|
+
"type": "function"
|
|
835
|
+
},
|
|
836
|
+
{
|
|
837
|
+
"inputs": [
|
|
838
|
+
{
|
|
839
|
+
"internalType": "address",
|
|
840
|
+
"name": "operator",
|
|
841
|
+
"type": "address"
|
|
842
|
+
},
|
|
843
|
+
{
|
|
844
|
+
"internalType": "bool",
|
|
845
|
+
"name": "approved",
|
|
846
|
+
"type": "bool"
|
|
847
|
+
}
|
|
848
|
+
],
|
|
849
|
+
"name": "setApprovalForAll",
|
|
850
|
+
"outputs": [],
|
|
851
|
+
"stateMutability": "nonpayable",
|
|
852
|
+
"type": "function"
|
|
853
|
+
},
|
|
854
|
+
{
|
|
855
|
+
"inputs": [
|
|
856
|
+
{
|
|
857
|
+
"internalType": "bytes32",
|
|
858
|
+
"name": "node",
|
|
859
|
+
"type": "bytes32"
|
|
860
|
+
},
|
|
861
|
+
{
|
|
862
|
+
"internalType": "bytes",
|
|
863
|
+
"name": "hash",
|
|
864
|
+
"type": "bytes"
|
|
865
|
+
}
|
|
866
|
+
],
|
|
867
|
+
"name": "setContenthash",
|
|
868
|
+
"outputs": [],
|
|
869
|
+
"stateMutability": "nonpayable",
|
|
870
|
+
"type": "function"
|
|
871
|
+
},
|
|
872
|
+
{
|
|
873
|
+
"inputs": [
|
|
874
|
+
{
|
|
875
|
+
"internalType": "bytes32",
|
|
876
|
+
"name": "node",
|
|
877
|
+
"type": "bytes32"
|
|
878
|
+
},
|
|
879
|
+
{
|
|
880
|
+
"internalType": "bytes",
|
|
881
|
+
"name": "data",
|
|
882
|
+
"type": "bytes"
|
|
883
|
+
}
|
|
884
|
+
],
|
|
885
|
+
"name": "setDNSRecords",
|
|
886
|
+
"outputs": [],
|
|
887
|
+
"stateMutability": "nonpayable",
|
|
888
|
+
"type": "function"
|
|
889
|
+
},
|
|
890
|
+
{
|
|
891
|
+
"inputs": [
|
|
892
|
+
{
|
|
893
|
+
"internalType": "bytes32",
|
|
894
|
+
"name": "node",
|
|
895
|
+
"type": "bytes32"
|
|
896
|
+
},
|
|
897
|
+
{
|
|
898
|
+
"internalType": "bytes4",
|
|
899
|
+
"name": "interfaceID",
|
|
900
|
+
"type": "bytes4"
|
|
901
|
+
},
|
|
902
|
+
{
|
|
903
|
+
"internalType": "address",
|
|
904
|
+
"name": "implementer",
|
|
905
|
+
"type": "address"
|
|
906
|
+
}
|
|
907
|
+
],
|
|
908
|
+
"name": "setInterface",
|
|
909
|
+
"outputs": [],
|
|
910
|
+
"stateMutability": "nonpayable",
|
|
911
|
+
"type": "function"
|
|
912
|
+
},
|
|
913
|
+
{
|
|
914
|
+
"inputs": [
|
|
915
|
+
{
|
|
916
|
+
"internalType": "bytes32",
|
|
917
|
+
"name": "node",
|
|
918
|
+
"type": "bytes32"
|
|
919
|
+
},
|
|
920
|
+
{
|
|
921
|
+
"internalType": "string",
|
|
922
|
+
"name": "newName",
|
|
923
|
+
"type": "string"
|
|
924
|
+
}
|
|
925
|
+
],
|
|
926
|
+
"name": "setName",
|
|
927
|
+
"outputs": [],
|
|
928
|
+
"stateMutability": "nonpayable",
|
|
929
|
+
"type": "function"
|
|
930
|
+
},
|
|
931
|
+
{
|
|
932
|
+
"inputs": [
|
|
933
|
+
{
|
|
934
|
+
"internalType": "bytes32",
|
|
935
|
+
"name": "node",
|
|
936
|
+
"type": "bytes32"
|
|
937
|
+
},
|
|
938
|
+
{
|
|
939
|
+
"internalType": "bytes32",
|
|
940
|
+
"name": "x",
|
|
941
|
+
"type": "bytes32"
|
|
942
|
+
},
|
|
943
|
+
{
|
|
944
|
+
"internalType": "bytes32",
|
|
945
|
+
"name": "y",
|
|
946
|
+
"type": "bytes32"
|
|
947
|
+
}
|
|
948
|
+
],
|
|
949
|
+
"name": "setPubkey",
|
|
950
|
+
"outputs": [],
|
|
951
|
+
"stateMutability": "nonpayable",
|
|
952
|
+
"type": "function"
|
|
953
|
+
},
|
|
954
|
+
{
|
|
955
|
+
"inputs": [
|
|
956
|
+
{
|
|
957
|
+
"internalType": "bytes32",
|
|
958
|
+
"name": "node",
|
|
959
|
+
"type": "bytes32"
|
|
960
|
+
},
|
|
961
|
+
{
|
|
962
|
+
"internalType": "string",
|
|
963
|
+
"name": "key",
|
|
964
|
+
"type": "string"
|
|
965
|
+
},
|
|
966
|
+
{
|
|
967
|
+
"internalType": "string",
|
|
968
|
+
"name": "value",
|
|
969
|
+
"type": "string"
|
|
970
|
+
}
|
|
971
|
+
],
|
|
972
|
+
"name": "setText",
|
|
973
|
+
"outputs": [],
|
|
974
|
+
"stateMutability": "nonpayable",
|
|
975
|
+
"type": "function"
|
|
976
|
+
},
|
|
977
|
+
{
|
|
978
|
+
"inputs": [
|
|
979
|
+
{
|
|
980
|
+
"internalType": "bytes32",
|
|
981
|
+
"name": "node",
|
|
982
|
+
"type": "bytes32"
|
|
983
|
+
},
|
|
984
|
+
{
|
|
985
|
+
"internalType": "bytes",
|
|
986
|
+
"name": "hash",
|
|
987
|
+
"type": "bytes"
|
|
988
|
+
}
|
|
989
|
+
],
|
|
990
|
+
"name": "setZonehash",
|
|
991
|
+
"outputs": [],
|
|
992
|
+
"stateMutability": "nonpayable",
|
|
993
|
+
"type": "function"
|
|
994
|
+
},
|
|
995
|
+
{
|
|
996
|
+
"inputs": [
|
|
997
|
+
{
|
|
998
|
+
"internalType": "bytes4",
|
|
999
|
+
"name": "interfaceID",
|
|
1000
|
+
"type": "bytes4"
|
|
1001
|
+
}
|
|
1002
|
+
],
|
|
1003
|
+
"name": "supportsInterface",
|
|
1004
|
+
"outputs": [
|
|
1005
|
+
{
|
|
1006
|
+
"internalType": "bool",
|
|
1007
|
+
"name": "",
|
|
1008
|
+
"type": "bool"
|
|
1009
|
+
}
|
|
1010
|
+
],
|
|
1011
|
+
"stateMutability": "view",
|
|
1012
|
+
"type": "function"
|
|
1013
|
+
},
|
|
1014
|
+
{
|
|
1015
|
+
"inputs": [
|
|
1016
|
+
{
|
|
1017
|
+
"internalType": "bytes32",
|
|
1018
|
+
"name": "node",
|
|
1019
|
+
"type": "bytes32"
|
|
1020
|
+
},
|
|
1021
|
+
{
|
|
1022
|
+
"internalType": "string",
|
|
1023
|
+
"name": "key",
|
|
1024
|
+
"type": "string"
|
|
1025
|
+
}
|
|
1026
|
+
],
|
|
1027
|
+
"name": "text",
|
|
1028
|
+
"outputs": [
|
|
1029
|
+
{
|
|
1030
|
+
"internalType": "string",
|
|
1031
|
+
"name": "",
|
|
1032
|
+
"type": "string"
|
|
1033
|
+
}
|
|
1034
|
+
],
|
|
1035
|
+
"stateMutability": "view",
|
|
1036
|
+
"type": "function"
|
|
1037
|
+
},
|
|
1038
|
+
{
|
|
1039
|
+
"inputs": [
|
|
1040
|
+
{
|
|
1041
|
+
"internalType": "bytes32",
|
|
1042
|
+
"name": "node",
|
|
1043
|
+
"type": "bytes32"
|
|
1044
|
+
}
|
|
1045
|
+
],
|
|
1046
|
+
"name": "zonehash",
|
|
1047
|
+
"outputs": [
|
|
1048
|
+
{
|
|
1049
|
+
"internalType": "bytes",
|
|
1050
|
+
"name": "",
|
|
1051
|
+
"type": "bytes"
|
|
1052
|
+
}
|
|
1053
|
+
],
|
|
1054
|
+
"stateMutability": "view",
|
|
1055
|
+
"type": "function"
|
|
1056
|
+
}
|
|
1057
|
+
];
|
|
1058
|
+
/**
|
|
1059
|
+
* PublicResolver_json Contract Class
|
|
1060
|
+
*
|
|
1061
|
+
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
1062
|
+
*
|
|
1063
|
+
* @example
|
|
1064
|
+
* ```typescript
|
|
1065
|
+
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
1066
|
+
* import { mainnet } from 'viem/chains';
|
|
1067
|
+
* import { PublicResolver_json } from 'PublicResolver_json';
|
|
1068
|
+
*
|
|
1069
|
+
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
1070
|
+
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
1071
|
+
*
|
|
1072
|
+
* const contract = new PublicResolver_json('0x...', { publicClient, walletClient });
|
|
1073
|
+
*
|
|
1074
|
+
* // Read functions
|
|
1075
|
+
* const result = await contract.balanceOf('0x...');
|
|
1076
|
+
*
|
|
1077
|
+
* // Write functions
|
|
1078
|
+
* const hash = await contract.transfer('0x...', 1000n);
|
|
1079
|
+
*
|
|
1080
|
+
* // Simulate transactions (dry-run)
|
|
1081
|
+
* const simulation = await contract.simulate.transfer('0x...', 1000n);
|
|
1082
|
+
* console.log('Gas estimate:', simulation.request.gas);
|
|
1083
|
+
*
|
|
1084
|
+
* // Watch events
|
|
1085
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1086
|
+
* console.log('Transfer event:', event);
|
|
1087
|
+
* });
|
|
1088
|
+
* ```
|
|
1089
|
+
*/
|
|
1090
|
+
class PublicResolver_json {
|
|
1091
|
+
constructor(address, clients) {
|
|
1092
|
+
this.contractAddress = address;
|
|
1093
|
+
this.publicClient = clients.publicClient;
|
|
1094
|
+
this.contract = (0, viem_1.getContract)({
|
|
1095
|
+
address,
|
|
1096
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1097
|
+
client: {
|
|
1098
|
+
public: clients.publicClient,
|
|
1099
|
+
wallet: clients.walletClient,
|
|
1100
|
+
},
|
|
1101
|
+
});
|
|
1102
|
+
}
|
|
1103
|
+
/**
|
|
1104
|
+
* Get the contract address
|
|
1105
|
+
*/
|
|
1106
|
+
get address() {
|
|
1107
|
+
return this.contractAddress;
|
|
1108
|
+
}
|
|
1109
|
+
/**
|
|
1110
|
+
* Get the underlying viem contract instance
|
|
1111
|
+
*/
|
|
1112
|
+
getContract() {
|
|
1113
|
+
return this.contract;
|
|
1114
|
+
}
|
|
1115
|
+
/**
|
|
1116
|
+
* ABI
|
|
1117
|
+
* view
|
|
1118
|
+
*/
|
|
1119
|
+
async ABI(node, contentTypes) {
|
|
1120
|
+
return this.contract.read.ABI([node, contentTypes]);
|
|
1121
|
+
}
|
|
1122
|
+
async addr(...args) {
|
|
1123
|
+
return this.contract.read.addr(args);
|
|
1124
|
+
}
|
|
1125
|
+
/**
|
|
1126
|
+
* contenthash
|
|
1127
|
+
* view
|
|
1128
|
+
*/
|
|
1129
|
+
async contenthash(node) {
|
|
1130
|
+
return this.contract.read.contenthash([node]);
|
|
1131
|
+
}
|
|
1132
|
+
/**
|
|
1133
|
+
* dnsRecord
|
|
1134
|
+
* view
|
|
1135
|
+
*/
|
|
1136
|
+
async dnsRecord(node, name, resource) {
|
|
1137
|
+
return this.contract.read.dnsRecord([node, name, resource]);
|
|
1138
|
+
}
|
|
1139
|
+
/**
|
|
1140
|
+
* hasAddr
|
|
1141
|
+
* view
|
|
1142
|
+
*/
|
|
1143
|
+
async hasAddr(node, coinType) {
|
|
1144
|
+
return this.contract.read.hasAddr([node, coinType]);
|
|
1145
|
+
}
|
|
1146
|
+
/**
|
|
1147
|
+
* hasDNSRecords
|
|
1148
|
+
* view
|
|
1149
|
+
*/
|
|
1150
|
+
async hasDNSRecords(node, name) {
|
|
1151
|
+
return this.contract.read.hasDNSRecords([node, name]);
|
|
1152
|
+
}
|
|
1153
|
+
/**
|
|
1154
|
+
* interfaceImplementer
|
|
1155
|
+
* view
|
|
1156
|
+
*/
|
|
1157
|
+
async interfaceImplementer(node, interfaceID) {
|
|
1158
|
+
return this.contract.read.interfaceImplementer([node, interfaceID]);
|
|
1159
|
+
}
|
|
1160
|
+
/**
|
|
1161
|
+
* isApprovedFor
|
|
1162
|
+
* view
|
|
1163
|
+
*/
|
|
1164
|
+
async isApprovedFor(owner, node, delegate) {
|
|
1165
|
+
return this.contract.read.isApprovedFor([owner, node, delegate]);
|
|
1166
|
+
}
|
|
1167
|
+
/**
|
|
1168
|
+
* isApprovedForAll
|
|
1169
|
+
* view
|
|
1170
|
+
*/
|
|
1171
|
+
async isApprovedForAll(account, operator) {
|
|
1172
|
+
return this.contract.read.isApprovedForAll([account, operator]);
|
|
1173
|
+
}
|
|
1174
|
+
/**
|
|
1175
|
+
* name
|
|
1176
|
+
* view
|
|
1177
|
+
*/
|
|
1178
|
+
async name(node) {
|
|
1179
|
+
return this.contract.read.name([node]);
|
|
1180
|
+
}
|
|
1181
|
+
/**
|
|
1182
|
+
* pubkey
|
|
1183
|
+
* view
|
|
1184
|
+
*/
|
|
1185
|
+
async pubkey(node) {
|
|
1186
|
+
return this.contract.read.pubkey([node]);
|
|
1187
|
+
}
|
|
1188
|
+
/**
|
|
1189
|
+
* recordVersions
|
|
1190
|
+
* view
|
|
1191
|
+
*/
|
|
1192
|
+
async recordVersions(arg0) {
|
|
1193
|
+
return this.contract.read.recordVersions([arg0]);
|
|
1194
|
+
}
|
|
1195
|
+
/**
|
|
1196
|
+
* supportsInterface
|
|
1197
|
+
* view
|
|
1198
|
+
*/
|
|
1199
|
+
async supportsInterface(interfaceID) {
|
|
1200
|
+
return this.contract.read.supportsInterface([interfaceID]);
|
|
1201
|
+
}
|
|
1202
|
+
/**
|
|
1203
|
+
* text
|
|
1204
|
+
* view
|
|
1205
|
+
*/
|
|
1206
|
+
async text(node, key) {
|
|
1207
|
+
return this.contract.read.text([node, key]);
|
|
1208
|
+
}
|
|
1209
|
+
/**
|
|
1210
|
+
* zonehash
|
|
1211
|
+
* view
|
|
1212
|
+
*/
|
|
1213
|
+
async zonehash(node) {
|
|
1214
|
+
return this.contract.read.zonehash([node]);
|
|
1215
|
+
}
|
|
1216
|
+
/**
|
|
1217
|
+
* approve
|
|
1218
|
+
* nonpayable
|
|
1219
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1220
|
+
*/
|
|
1221
|
+
async approve(node, delegate, approved, options) {
|
|
1222
|
+
if (!this.contract.write) {
|
|
1223
|
+
throw new Error('Wallet client is required for write operations');
|
|
1224
|
+
}
|
|
1225
|
+
return this.contract.write.approve([node, delegate, approved], options);
|
|
1226
|
+
}
|
|
1227
|
+
/**
|
|
1228
|
+
* clearRecords
|
|
1229
|
+
* nonpayable
|
|
1230
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1231
|
+
*/
|
|
1232
|
+
async clearRecords(node, options) {
|
|
1233
|
+
if (!this.contract.write) {
|
|
1234
|
+
throw new Error('Wallet client is required for write operations');
|
|
1235
|
+
}
|
|
1236
|
+
return this.contract.write.clearRecords([node], options);
|
|
1237
|
+
}
|
|
1238
|
+
/**
|
|
1239
|
+
* multicall
|
|
1240
|
+
* nonpayable
|
|
1241
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1242
|
+
*/
|
|
1243
|
+
async multicall(data, options) {
|
|
1244
|
+
if (!this.contract.write) {
|
|
1245
|
+
throw new Error('Wallet client is required for write operations');
|
|
1246
|
+
}
|
|
1247
|
+
return this.contract.write.multicall([data], options);
|
|
1248
|
+
}
|
|
1249
|
+
/**
|
|
1250
|
+
* multicallWithNodeCheck
|
|
1251
|
+
* nonpayable
|
|
1252
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1253
|
+
*/
|
|
1254
|
+
async multicallWithNodeCheck(nodehash, data, options) {
|
|
1255
|
+
if (!this.contract.write) {
|
|
1256
|
+
throw new Error('Wallet client is required for write operations');
|
|
1257
|
+
}
|
|
1258
|
+
return this.contract.write.multicallWithNodeCheck([nodehash, data], options);
|
|
1259
|
+
}
|
|
1260
|
+
/**
|
|
1261
|
+
* setABI
|
|
1262
|
+
* nonpayable
|
|
1263
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1264
|
+
*/
|
|
1265
|
+
async setABI(node, contentType, data, options) {
|
|
1266
|
+
if (!this.contract.write) {
|
|
1267
|
+
throw new Error('Wallet client is required for write operations');
|
|
1268
|
+
}
|
|
1269
|
+
return this.contract.write.setABI([node, contentType, data], options);
|
|
1270
|
+
}
|
|
1271
|
+
async setAddr(...args) {
|
|
1272
|
+
if (!this.contract.write) {
|
|
1273
|
+
throw new Error('Wallet client is required for write operations');
|
|
1274
|
+
}
|
|
1275
|
+
return this.contract.write.setAddr(args);
|
|
1276
|
+
}
|
|
1277
|
+
/**
|
|
1278
|
+
* setApprovalForAll
|
|
1279
|
+
* nonpayable
|
|
1280
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1281
|
+
*/
|
|
1282
|
+
async setApprovalForAll(operator, approved, options) {
|
|
1283
|
+
if (!this.contract.write) {
|
|
1284
|
+
throw new Error('Wallet client is required for write operations');
|
|
1285
|
+
}
|
|
1286
|
+
return this.contract.write.setApprovalForAll([operator, approved], options);
|
|
1287
|
+
}
|
|
1288
|
+
/**
|
|
1289
|
+
* setContenthash
|
|
1290
|
+
* nonpayable
|
|
1291
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1292
|
+
*/
|
|
1293
|
+
async setContenthash(node, hash, options) {
|
|
1294
|
+
if (!this.contract.write) {
|
|
1295
|
+
throw new Error('Wallet client is required for write operations');
|
|
1296
|
+
}
|
|
1297
|
+
return this.contract.write.setContenthash([node, hash], options);
|
|
1298
|
+
}
|
|
1299
|
+
/**
|
|
1300
|
+
* setDNSRecords
|
|
1301
|
+
* nonpayable
|
|
1302
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1303
|
+
*/
|
|
1304
|
+
async setDNSRecords(node, data, options) {
|
|
1305
|
+
if (!this.contract.write) {
|
|
1306
|
+
throw new Error('Wallet client is required for write operations');
|
|
1307
|
+
}
|
|
1308
|
+
return this.contract.write.setDNSRecords([node, data], options);
|
|
1309
|
+
}
|
|
1310
|
+
/**
|
|
1311
|
+
* setInterface
|
|
1312
|
+
* nonpayable
|
|
1313
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1314
|
+
*/
|
|
1315
|
+
async setInterface(node, interfaceID, implementer, options) {
|
|
1316
|
+
if (!this.contract.write) {
|
|
1317
|
+
throw new Error('Wallet client is required for write operations');
|
|
1318
|
+
}
|
|
1319
|
+
return this.contract.write.setInterface([node, interfaceID, implementer], options);
|
|
1320
|
+
}
|
|
1321
|
+
/**
|
|
1322
|
+
* setName
|
|
1323
|
+
* nonpayable
|
|
1324
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1325
|
+
*/
|
|
1326
|
+
async setName(node, newName, options) {
|
|
1327
|
+
if (!this.contract.write) {
|
|
1328
|
+
throw new Error('Wallet client is required for write operations');
|
|
1329
|
+
}
|
|
1330
|
+
return this.contract.write.setName([node, newName], options);
|
|
1331
|
+
}
|
|
1332
|
+
/**
|
|
1333
|
+
* setPubkey
|
|
1334
|
+
* nonpayable
|
|
1335
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1336
|
+
*/
|
|
1337
|
+
async setPubkey(node, x, y, options) {
|
|
1338
|
+
if (!this.contract.write) {
|
|
1339
|
+
throw new Error('Wallet client is required for write operations');
|
|
1340
|
+
}
|
|
1341
|
+
return this.contract.write.setPubkey([node, x, y], options);
|
|
1342
|
+
}
|
|
1343
|
+
/**
|
|
1344
|
+
* setText
|
|
1345
|
+
* nonpayable
|
|
1346
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1347
|
+
*/
|
|
1348
|
+
async setText(node, key, value, options) {
|
|
1349
|
+
if (!this.contract.write) {
|
|
1350
|
+
throw new Error('Wallet client is required for write operations');
|
|
1351
|
+
}
|
|
1352
|
+
return this.contract.write.setText([node, key, value], options);
|
|
1353
|
+
}
|
|
1354
|
+
/**
|
|
1355
|
+
* setZonehash
|
|
1356
|
+
* nonpayable
|
|
1357
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1358
|
+
*/
|
|
1359
|
+
async setZonehash(node, hash, options) {
|
|
1360
|
+
if (!this.contract.write) {
|
|
1361
|
+
throw new Error('Wallet client is required for write operations');
|
|
1362
|
+
}
|
|
1363
|
+
return this.contract.write.setZonehash([node, hash], options);
|
|
1364
|
+
}
|
|
1365
|
+
/**
|
|
1366
|
+
* Simulate contract write operations (dry-run without sending transaction)
|
|
1367
|
+
*
|
|
1368
|
+
* @example
|
|
1369
|
+
* const result = await contract.simulate.transfer('0x...', 1000n);
|
|
1370
|
+
* console.log('Gas estimate:', result.request.gas);
|
|
1371
|
+
* console.log('Would succeed:', result.result);
|
|
1372
|
+
*/
|
|
1373
|
+
get simulate() {
|
|
1374
|
+
const contract = this.contract;
|
|
1375
|
+
if (!contract.simulate) {
|
|
1376
|
+
throw new Error('Public client is required for simulation');
|
|
1377
|
+
}
|
|
1378
|
+
return {
|
|
1379
|
+
/**
|
|
1380
|
+
* Simulate approve
|
|
1381
|
+
* Returns gas estimate and result without sending transaction
|
|
1382
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1383
|
+
*/
|
|
1384
|
+
async approve(node, delegate, approved, options) {
|
|
1385
|
+
return contract.simulate.approve([node, delegate, approved], options);
|
|
1386
|
+
},
|
|
1387
|
+
/**
|
|
1388
|
+
* Simulate clearRecords
|
|
1389
|
+
* Returns gas estimate and result without sending transaction
|
|
1390
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1391
|
+
*/
|
|
1392
|
+
async clearRecords(node, options) {
|
|
1393
|
+
return contract.simulate.clearRecords([node], options);
|
|
1394
|
+
},
|
|
1395
|
+
/**
|
|
1396
|
+
* Simulate multicall
|
|
1397
|
+
* Returns gas estimate and result without sending transaction
|
|
1398
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1399
|
+
*/
|
|
1400
|
+
async multicall(data, options) {
|
|
1401
|
+
return contract.simulate.multicall([data], options);
|
|
1402
|
+
},
|
|
1403
|
+
/**
|
|
1404
|
+
* Simulate multicallWithNodeCheck
|
|
1405
|
+
* Returns gas estimate and result without sending transaction
|
|
1406
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1407
|
+
*/
|
|
1408
|
+
async multicallWithNodeCheck(nodehash, data, options) {
|
|
1409
|
+
return contract.simulate.multicallWithNodeCheck([nodehash, data], options);
|
|
1410
|
+
},
|
|
1411
|
+
/**
|
|
1412
|
+
* Simulate setABI
|
|
1413
|
+
* Returns gas estimate and result without sending transaction
|
|
1414
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1415
|
+
*/
|
|
1416
|
+
async setABI(node, contentType, data, options) {
|
|
1417
|
+
return contract.simulate.setABI([node, contentType, data], options);
|
|
1418
|
+
},
|
|
1419
|
+
/**
|
|
1420
|
+
* Simulate setAddr
|
|
1421
|
+
* Returns gas estimate and result without sending transaction
|
|
1422
|
+
* Supports multiple overloads: (bytes32, uint256, bytes), (bytes32, address)
|
|
1423
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1424
|
+
*/
|
|
1425
|
+
async setAddr(...args) {
|
|
1426
|
+
return contract.simulate.setAddr(args);
|
|
1427
|
+
},
|
|
1428
|
+
/**
|
|
1429
|
+
* Simulate setApprovalForAll
|
|
1430
|
+
* Returns gas estimate and result without sending transaction
|
|
1431
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1432
|
+
*/
|
|
1433
|
+
async setApprovalForAll(operator, approved, options) {
|
|
1434
|
+
return contract.simulate.setApprovalForAll([operator, approved], options);
|
|
1435
|
+
},
|
|
1436
|
+
/**
|
|
1437
|
+
* Simulate setContenthash
|
|
1438
|
+
* Returns gas estimate and result without sending transaction
|
|
1439
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1440
|
+
*/
|
|
1441
|
+
async setContenthash(node, hash, options) {
|
|
1442
|
+
return contract.simulate.setContenthash([node, hash], options);
|
|
1443
|
+
},
|
|
1444
|
+
/**
|
|
1445
|
+
* Simulate setDNSRecords
|
|
1446
|
+
* Returns gas estimate and result without sending transaction
|
|
1447
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1448
|
+
*/
|
|
1449
|
+
async setDNSRecords(node, data, options) {
|
|
1450
|
+
return contract.simulate.setDNSRecords([node, data], options);
|
|
1451
|
+
},
|
|
1452
|
+
/**
|
|
1453
|
+
* Simulate setInterface
|
|
1454
|
+
* Returns gas estimate and result without sending transaction
|
|
1455
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1456
|
+
*/
|
|
1457
|
+
async setInterface(node, interfaceID, implementer, options) {
|
|
1458
|
+
return contract.simulate.setInterface([node, interfaceID, implementer], options);
|
|
1459
|
+
},
|
|
1460
|
+
/**
|
|
1461
|
+
* Simulate setName
|
|
1462
|
+
* Returns gas estimate and result without sending transaction
|
|
1463
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1464
|
+
*/
|
|
1465
|
+
async setName(node, newName, options) {
|
|
1466
|
+
return contract.simulate.setName([node, newName], options);
|
|
1467
|
+
},
|
|
1468
|
+
/**
|
|
1469
|
+
* Simulate setPubkey
|
|
1470
|
+
* Returns gas estimate and result without sending transaction
|
|
1471
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1472
|
+
*/
|
|
1473
|
+
async setPubkey(node, x, y, options) {
|
|
1474
|
+
return contract.simulate.setPubkey([node, x, y], options);
|
|
1475
|
+
},
|
|
1476
|
+
/**
|
|
1477
|
+
* Simulate setText
|
|
1478
|
+
* Returns gas estimate and result without sending transaction
|
|
1479
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1480
|
+
*/
|
|
1481
|
+
async setText(node, key, value, options) {
|
|
1482
|
+
return contract.simulate.setText([node, key, value], options);
|
|
1483
|
+
},
|
|
1484
|
+
/**
|
|
1485
|
+
* Simulate setZonehash
|
|
1486
|
+
* Returns gas estimate and result without sending transaction
|
|
1487
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1488
|
+
*/
|
|
1489
|
+
async setZonehash(node, hash, options) {
|
|
1490
|
+
return contract.simulate.setZonehash([node, hash], options);
|
|
1491
|
+
}
|
|
1492
|
+
};
|
|
1493
|
+
}
|
|
1494
|
+
/**
|
|
1495
|
+
* Watch contract events
|
|
1496
|
+
*
|
|
1497
|
+
* @example
|
|
1498
|
+
* // Watch all Transfer events
|
|
1499
|
+
* const unwatch = contract.watch.Transfer((event) => {
|
|
1500
|
+
* console.log('Transfer:', event);
|
|
1501
|
+
* });
|
|
1502
|
+
*
|
|
1503
|
+
* // Stop watching
|
|
1504
|
+
* unwatch();
|
|
1505
|
+
*/
|
|
1506
|
+
get watch() {
|
|
1507
|
+
return {
|
|
1508
|
+
/**
|
|
1509
|
+
* Watch ABIChanged events
|
|
1510
|
+
* @param callback Function to call when event is emitted
|
|
1511
|
+
* @param filter Optional filter for indexed parameters
|
|
1512
|
+
* @returns Unwatch function to stop listening
|
|
1513
|
+
*/
|
|
1514
|
+
ABIChanged: (callback, filter) => {
|
|
1515
|
+
return this.publicClient.watchContractEvent({
|
|
1516
|
+
address: this.contractAddress,
|
|
1517
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1518
|
+
eventName: 'ABIChanged',
|
|
1519
|
+
args: filter,
|
|
1520
|
+
onLogs: (logs) => {
|
|
1521
|
+
logs.forEach((log) => {
|
|
1522
|
+
callback(log.args);
|
|
1523
|
+
});
|
|
1524
|
+
},
|
|
1525
|
+
});
|
|
1526
|
+
},
|
|
1527
|
+
/**
|
|
1528
|
+
* Watch AddrChanged events
|
|
1529
|
+
* @param callback Function to call when event is emitted
|
|
1530
|
+
* @param filter Optional filter for indexed parameters
|
|
1531
|
+
* @returns Unwatch function to stop listening
|
|
1532
|
+
*/
|
|
1533
|
+
AddrChanged: (callback, filter) => {
|
|
1534
|
+
return this.publicClient.watchContractEvent({
|
|
1535
|
+
address: this.contractAddress,
|
|
1536
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1537
|
+
eventName: 'AddrChanged',
|
|
1538
|
+
args: filter,
|
|
1539
|
+
onLogs: (logs) => {
|
|
1540
|
+
logs.forEach((log) => {
|
|
1541
|
+
callback(log.args);
|
|
1542
|
+
});
|
|
1543
|
+
},
|
|
1544
|
+
});
|
|
1545
|
+
},
|
|
1546
|
+
/**
|
|
1547
|
+
* Watch AddressChanged events
|
|
1548
|
+
* @param callback Function to call when event is emitted
|
|
1549
|
+
* @param filter Optional filter for indexed parameters
|
|
1550
|
+
* @returns Unwatch function to stop listening
|
|
1551
|
+
*/
|
|
1552
|
+
AddressChanged: (callback, filter) => {
|
|
1553
|
+
return this.publicClient.watchContractEvent({
|
|
1554
|
+
address: this.contractAddress,
|
|
1555
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1556
|
+
eventName: 'AddressChanged',
|
|
1557
|
+
args: filter,
|
|
1558
|
+
onLogs: (logs) => {
|
|
1559
|
+
logs.forEach((log) => {
|
|
1560
|
+
callback(log.args);
|
|
1561
|
+
});
|
|
1562
|
+
},
|
|
1563
|
+
});
|
|
1564
|
+
},
|
|
1565
|
+
/**
|
|
1566
|
+
* Watch ApprovalForAll events
|
|
1567
|
+
* @param callback Function to call when event is emitted
|
|
1568
|
+
* @param filter Optional filter for indexed parameters
|
|
1569
|
+
* @returns Unwatch function to stop listening
|
|
1570
|
+
*/
|
|
1571
|
+
ApprovalForAll: (callback, filter) => {
|
|
1572
|
+
return this.publicClient.watchContractEvent({
|
|
1573
|
+
address: this.contractAddress,
|
|
1574
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1575
|
+
eventName: 'ApprovalForAll',
|
|
1576
|
+
args: filter,
|
|
1577
|
+
onLogs: (logs) => {
|
|
1578
|
+
logs.forEach((log) => {
|
|
1579
|
+
callback(log.args);
|
|
1580
|
+
});
|
|
1581
|
+
},
|
|
1582
|
+
});
|
|
1583
|
+
},
|
|
1584
|
+
/**
|
|
1585
|
+
* Watch Approved events
|
|
1586
|
+
* @param callback Function to call when event is emitted
|
|
1587
|
+
* @param filter Optional filter for indexed parameters
|
|
1588
|
+
* @returns Unwatch function to stop listening
|
|
1589
|
+
*/
|
|
1590
|
+
Approved: (callback, filter) => {
|
|
1591
|
+
return this.publicClient.watchContractEvent({
|
|
1592
|
+
address: this.contractAddress,
|
|
1593
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1594
|
+
eventName: 'Approved',
|
|
1595
|
+
args: filter,
|
|
1596
|
+
onLogs: (logs) => {
|
|
1597
|
+
logs.forEach((log) => {
|
|
1598
|
+
callback(log.args);
|
|
1599
|
+
});
|
|
1600
|
+
},
|
|
1601
|
+
});
|
|
1602
|
+
},
|
|
1603
|
+
/**
|
|
1604
|
+
* Watch ContenthashChanged events
|
|
1605
|
+
* @param callback Function to call when event is emitted
|
|
1606
|
+
* @param filter Optional filter for indexed parameters
|
|
1607
|
+
* @returns Unwatch function to stop listening
|
|
1608
|
+
*/
|
|
1609
|
+
ContenthashChanged: (callback, filter) => {
|
|
1610
|
+
return this.publicClient.watchContractEvent({
|
|
1611
|
+
address: this.contractAddress,
|
|
1612
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1613
|
+
eventName: 'ContenthashChanged',
|
|
1614
|
+
args: filter,
|
|
1615
|
+
onLogs: (logs) => {
|
|
1616
|
+
logs.forEach((log) => {
|
|
1617
|
+
callback(log.args);
|
|
1618
|
+
});
|
|
1619
|
+
},
|
|
1620
|
+
});
|
|
1621
|
+
},
|
|
1622
|
+
/**
|
|
1623
|
+
* Watch DNSRecordChanged events
|
|
1624
|
+
* @param callback Function to call when event is emitted
|
|
1625
|
+
* @param filter Optional filter for indexed parameters
|
|
1626
|
+
* @returns Unwatch function to stop listening
|
|
1627
|
+
*/
|
|
1628
|
+
DNSRecordChanged: (callback, filter) => {
|
|
1629
|
+
return this.publicClient.watchContractEvent({
|
|
1630
|
+
address: this.contractAddress,
|
|
1631
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1632
|
+
eventName: 'DNSRecordChanged',
|
|
1633
|
+
args: filter,
|
|
1634
|
+
onLogs: (logs) => {
|
|
1635
|
+
logs.forEach((log) => {
|
|
1636
|
+
callback(log.args);
|
|
1637
|
+
});
|
|
1638
|
+
},
|
|
1639
|
+
});
|
|
1640
|
+
},
|
|
1641
|
+
/**
|
|
1642
|
+
* Watch DNSRecordDeleted events
|
|
1643
|
+
* @param callback Function to call when event is emitted
|
|
1644
|
+
* @param filter Optional filter for indexed parameters
|
|
1645
|
+
* @returns Unwatch function to stop listening
|
|
1646
|
+
*/
|
|
1647
|
+
DNSRecordDeleted: (callback, filter) => {
|
|
1648
|
+
return this.publicClient.watchContractEvent({
|
|
1649
|
+
address: this.contractAddress,
|
|
1650
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1651
|
+
eventName: 'DNSRecordDeleted',
|
|
1652
|
+
args: filter,
|
|
1653
|
+
onLogs: (logs) => {
|
|
1654
|
+
logs.forEach((log) => {
|
|
1655
|
+
callback(log.args);
|
|
1656
|
+
});
|
|
1657
|
+
},
|
|
1658
|
+
});
|
|
1659
|
+
},
|
|
1660
|
+
/**
|
|
1661
|
+
* Watch DNSZonehashChanged events
|
|
1662
|
+
* @param callback Function to call when event is emitted
|
|
1663
|
+
* @param filter Optional filter for indexed parameters
|
|
1664
|
+
* @returns Unwatch function to stop listening
|
|
1665
|
+
*/
|
|
1666
|
+
DNSZonehashChanged: (callback, filter) => {
|
|
1667
|
+
return this.publicClient.watchContractEvent({
|
|
1668
|
+
address: this.contractAddress,
|
|
1669
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1670
|
+
eventName: 'DNSZonehashChanged',
|
|
1671
|
+
args: filter,
|
|
1672
|
+
onLogs: (logs) => {
|
|
1673
|
+
logs.forEach((log) => {
|
|
1674
|
+
callback(log.args);
|
|
1675
|
+
});
|
|
1676
|
+
},
|
|
1677
|
+
});
|
|
1678
|
+
},
|
|
1679
|
+
/**
|
|
1680
|
+
* Watch InterfaceChanged events
|
|
1681
|
+
* @param callback Function to call when event is emitted
|
|
1682
|
+
* @param filter Optional filter for indexed parameters
|
|
1683
|
+
* @returns Unwatch function to stop listening
|
|
1684
|
+
*/
|
|
1685
|
+
InterfaceChanged: (callback, filter) => {
|
|
1686
|
+
return this.publicClient.watchContractEvent({
|
|
1687
|
+
address: this.contractAddress,
|
|
1688
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1689
|
+
eventName: 'InterfaceChanged',
|
|
1690
|
+
args: filter,
|
|
1691
|
+
onLogs: (logs) => {
|
|
1692
|
+
logs.forEach((log) => {
|
|
1693
|
+
callback(log.args);
|
|
1694
|
+
});
|
|
1695
|
+
},
|
|
1696
|
+
});
|
|
1697
|
+
},
|
|
1698
|
+
/**
|
|
1699
|
+
* Watch NameChanged events
|
|
1700
|
+
* @param callback Function to call when event is emitted
|
|
1701
|
+
* @param filter Optional filter for indexed parameters
|
|
1702
|
+
* @returns Unwatch function to stop listening
|
|
1703
|
+
*/
|
|
1704
|
+
NameChanged: (callback, filter) => {
|
|
1705
|
+
return this.publicClient.watchContractEvent({
|
|
1706
|
+
address: this.contractAddress,
|
|
1707
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1708
|
+
eventName: 'NameChanged',
|
|
1709
|
+
args: filter,
|
|
1710
|
+
onLogs: (logs) => {
|
|
1711
|
+
logs.forEach((log) => {
|
|
1712
|
+
callback(log.args);
|
|
1713
|
+
});
|
|
1714
|
+
},
|
|
1715
|
+
});
|
|
1716
|
+
},
|
|
1717
|
+
/**
|
|
1718
|
+
* Watch PubkeyChanged events
|
|
1719
|
+
* @param callback Function to call when event is emitted
|
|
1720
|
+
* @param filter Optional filter for indexed parameters
|
|
1721
|
+
* @returns Unwatch function to stop listening
|
|
1722
|
+
*/
|
|
1723
|
+
PubkeyChanged: (callback, filter) => {
|
|
1724
|
+
return this.publicClient.watchContractEvent({
|
|
1725
|
+
address: this.contractAddress,
|
|
1726
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1727
|
+
eventName: 'PubkeyChanged',
|
|
1728
|
+
args: filter,
|
|
1729
|
+
onLogs: (logs) => {
|
|
1730
|
+
logs.forEach((log) => {
|
|
1731
|
+
callback(log.args);
|
|
1732
|
+
});
|
|
1733
|
+
},
|
|
1734
|
+
});
|
|
1735
|
+
},
|
|
1736
|
+
/**
|
|
1737
|
+
* Watch TextChanged events
|
|
1738
|
+
* @param callback Function to call when event is emitted
|
|
1739
|
+
* @param filter Optional filter for indexed parameters
|
|
1740
|
+
* @returns Unwatch function to stop listening
|
|
1741
|
+
*/
|
|
1742
|
+
TextChanged: (callback, filter) => {
|
|
1743
|
+
return this.publicClient.watchContractEvent({
|
|
1744
|
+
address: this.contractAddress,
|
|
1745
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1746
|
+
eventName: 'TextChanged',
|
|
1747
|
+
args: filter,
|
|
1748
|
+
onLogs: (logs) => {
|
|
1749
|
+
logs.forEach((log) => {
|
|
1750
|
+
callback(log.args);
|
|
1751
|
+
});
|
|
1752
|
+
},
|
|
1753
|
+
});
|
|
1754
|
+
},
|
|
1755
|
+
/**
|
|
1756
|
+
* Watch VersionChanged events
|
|
1757
|
+
* @param callback Function to call when event is emitted
|
|
1758
|
+
* @param filter Optional filter for indexed parameters
|
|
1759
|
+
* @returns Unwatch function to stop listening
|
|
1760
|
+
*/
|
|
1761
|
+
VersionChanged: (callback, filter) => {
|
|
1762
|
+
return this.publicClient.watchContractEvent({
|
|
1763
|
+
address: this.contractAddress,
|
|
1764
|
+
abi: exports.PublicResolver_jsonAbi,
|
|
1765
|
+
eventName: 'VersionChanged',
|
|
1766
|
+
args: filter,
|
|
1767
|
+
onLogs: (logs) => {
|
|
1768
|
+
logs.forEach((log) => {
|
|
1769
|
+
callback(log.args);
|
|
1770
|
+
});
|
|
1771
|
+
},
|
|
1772
|
+
});
|
|
1773
|
+
}
|
|
1774
|
+
};
|
|
1775
|
+
}
|
|
1776
|
+
}
|
|
1777
|
+
exports.PublicResolver_json = PublicResolver_json;
|