@gitmyabi/xai 1.0.0 → 1.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 +4 -4
- package/contracts/{SDSHD_json.d.ts → XAI_json.d.ts} +481 -218
- package/contracts/{SDSHD_json.js → XAI_json.js} +464 -271
- package/contracts/{SDSHD_json.ts → XAI_json.ts} +622 -286
- package/contracts/index.d.ts +2 -2
- package/contracts/index.js +4 -4
- package/contracts/index.ts +2 -2
- package/package.json +3 -3
|
@@ -2,153 +2,52 @@ import type { Abi, Address, PublicClient, WalletClient, GetContractReturnType }
|
|
|
2
2
|
import { getContract } from 'viem';
|
|
3
3
|
|
|
4
4
|
/**
|
|
5
|
-
*
|
|
5
|
+
* XAI_json ABI
|
|
6
6
|
*
|
|
7
7
|
* This ABI is typed using viem's type system for full type safety.
|
|
8
8
|
*/
|
|
9
|
-
export const
|
|
9
|
+
export const XAI_jsonAbi = [
|
|
10
10
|
{
|
|
11
|
-
"inputs": [
|
|
12
|
-
{
|
|
13
|
-
"internalType": "address",
|
|
14
|
-
"name": "swapRouter_",
|
|
15
|
-
"type": "address"
|
|
16
|
-
}
|
|
17
|
-
],
|
|
11
|
+
"inputs": [],
|
|
18
12
|
"stateMutability": "nonpayable",
|
|
19
13
|
"type": "constructor"
|
|
20
14
|
},
|
|
21
15
|
{
|
|
16
|
+
"anonymous": false,
|
|
22
17
|
"inputs": [
|
|
23
18
|
{
|
|
19
|
+
"indexed": true,
|
|
24
20
|
"internalType": "address",
|
|
25
|
-
"name": "
|
|
21
|
+
"name": "owner",
|
|
26
22
|
"type": "address"
|
|
27
23
|
},
|
|
28
24
|
{
|
|
29
|
-
"
|
|
30
|
-
"name": "allowance",
|
|
31
|
-
"type": "uint256"
|
|
32
|
-
},
|
|
33
|
-
{
|
|
34
|
-
"internalType": "uint256",
|
|
35
|
-
"name": "needed",
|
|
36
|
-
"type": "uint256"
|
|
37
|
-
}
|
|
38
|
-
],
|
|
39
|
-
"name": "ERC20InsufficientAllowance",
|
|
40
|
-
"type": "error"
|
|
41
|
-
},
|
|
42
|
-
{
|
|
43
|
-
"inputs": [
|
|
44
|
-
{
|
|
25
|
+
"indexed": true,
|
|
45
26
|
"internalType": "address",
|
|
46
|
-
"name": "
|
|
27
|
+
"name": "spender",
|
|
47
28
|
"type": "address"
|
|
48
29
|
},
|
|
49
30
|
{
|
|
31
|
+
"indexed": false,
|
|
50
32
|
"internalType": "uint256",
|
|
51
|
-
"name": "
|
|
52
|
-
"type": "uint256"
|
|
53
|
-
},
|
|
54
|
-
{
|
|
55
|
-
"internalType": "uint256",
|
|
56
|
-
"name": "needed",
|
|
33
|
+
"name": "value",
|
|
57
34
|
"type": "uint256"
|
|
58
35
|
}
|
|
59
36
|
],
|
|
60
|
-
"name": "
|
|
61
|
-
"type": "
|
|
62
|
-
},
|
|
63
|
-
{
|
|
64
|
-
"inputs": [
|
|
65
|
-
{
|
|
66
|
-
"internalType": "address",
|
|
67
|
-
"name": "approver",
|
|
68
|
-
"type": "address"
|
|
69
|
-
}
|
|
70
|
-
],
|
|
71
|
-
"name": "ERC20InvalidApprover",
|
|
72
|
-
"type": "error"
|
|
73
|
-
},
|
|
74
|
-
{
|
|
75
|
-
"inputs": [
|
|
76
|
-
{
|
|
77
|
-
"internalType": "address",
|
|
78
|
-
"name": "receiver",
|
|
79
|
-
"type": "address"
|
|
80
|
-
}
|
|
81
|
-
],
|
|
82
|
-
"name": "ERC20InvalidReceiver",
|
|
83
|
-
"type": "error"
|
|
84
|
-
},
|
|
85
|
-
{
|
|
86
|
-
"inputs": [
|
|
87
|
-
{
|
|
88
|
-
"internalType": "address",
|
|
89
|
-
"name": "sender",
|
|
90
|
-
"type": "address"
|
|
91
|
-
}
|
|
92
|
-
],
|
|
93
|
-
"name": "ERC20InvalidSender",
|
|
94
|
-
"type": "error"
|
|
95
|
-
},
|
|
96
|
-
{
|
|
97
|
-
"inputs": [
|
|
98
|
-
{
|
|
99
|
-
"internalType": "address",
|
|
100
|
-
"name": "spender",
|
|
101
|
-
"type": "address"
|
|
102
|
-
}
|
|
103
|
-
],
|
|
104
|
-
"name": "ERC20InvalidSpender",
|
|
105
|
-
"type": "error"
|
|
106
|
-
},
|
|
107
|
-
{
|
|
108
|
-
"inputs": [
|
|
109
|
-
{
|
|
110
|
-
"internalType": "address",
|
|
111
|
-
"name": "owner",
|
|
112
|
-
"type": "address"
|
|
113
|
-
}
|
|
114
|
-
],
|
|
115
|
-
"name": "OwnableInvalidOwner",
|
|
116
|
-
"type": "error"
|
|
117
|
-
},
|
|
118
|
-
{
|
|
119
|
-
"inputs": [
|
|
120
|
-
{
|
|
121
|
-
"internalType": "address",
|
|
122
|
-
"name": "account",
|
|
123
|
-
"type": "address"
|
|
124
|
-
}
|
|
125
|
-
],
|
|
126
|
-
"name": "OwnableUnauthorizedAccount",
|
|
127
|
-
"type": "error"
|
|
37
|
+
"name": "Approval",
|
|
38
|
+
"type": "event"
|
|
128
39
|
},
|
|
129
40
|
{
|
|
130
41
|
"anonymous": false,
|
|
131
42
|
"inputs": [
|
|
132
|
-
{
|
|
133
|
-
"indexed": true,
|
|
134
|
-
"internalType": "address",
|
|
135
|
-
"name": "owner",
|
|
136
|
-
"type": "address"
|
|
137
|
-
},
|
|
138
|
-
{
|
|
139
|
-
"indexed": true,
|
|
140
|
-
"internalType": "address",
|
|
141
|
-
"name": "spender",
|
|
142
|
-
"type": "address"
|
|
143
|
-
},
|
|
144
43
|
{
|
|
145
44
|
"indexed": false,
|
|
146
45
|
"internalType": "uint256",
|
|
147
|
-
"name": "
|
|
46
|
+
"name": "_maxTxAmount",
|
|
148
47
|
"type": "uint256"
|
|
149
48
|
}
|
|
150
49
|
],
|
|
151
|
-
"name": "
|
|
50
|
+
"name": "MaxTxAmountUpdated",
|
|
152
51
|
"type": "event"
|
|
153
52
|
},
|
|
154
53
|
{
|
|
@@ -198,26 +97,71 @@ export const SDSHD_jsonAbi = [
|
|
|
198
97
|
{
|
|
199
98
|
"inputs": [
|
|
200
99
|
{
|
|
201
|
-
"internalType": "address
|
|
202
|
-
"name": "
|
|
203
|
-
"type": "address
|
|
100
|
+
"internalType": "address",
|
|
101
|
+
"name": "",
|
|
102
|
+
"type": "address"
|
|
204
103
|
}
|
|
205
104
|
],
|
|
206
|
-
"name": "
|
|
207
|
-
"outputs": [
|
|
208
|
-
|
|
105
|
+
"name": "_buyMap",
|
|
106
|
+
"outputs": [
|
|
107
|
+
{
|
|
108
|
+
"internalType": "uint256",
|
|
109
|
+
"name": "",
|
|
110
|
+
"type": "uint256"
|
|
111
|
+
}
|
|
112
|
+
],
|
|
113
|
+
"stateMutability": "view",
|
|
114
|
+
"type": "function"
|
|
115
|
+
},
|
|
116
|
+
{
|
|
117
|
+
"inputs": [],
|
|
118
|
+
"name": "_maxTxAmount",
|
|
119
|
+
"outputs": [
|
|
120
|
+
{
|
|
121
|
+
"internalType": "uint256",
|
|
122
|
+
"name": "",
|
|
123
|
+
"type": "uint256"
|
|
124
|
+
}
|
|
125
|
+
],
|
|
126
|
+
"stateMutability": "view",
|
|
127
|
+
"type": "function"
|
|
128
|
+
},
|
|
129
|
+
{
|
|
130
|
+
"inputs": [],
|
|
131
|
+
"name": "_maxWalletSize",
|
|
132
|
+
"outputs": [
|
|
133
|
+
{
|
|
134
|
+
"internalType": "uint256",
|
|
135
|
+
"name": "",
|
|
136
|
+
"type": "uint256"
|
|
137
|
+
}
|
|
138
|
+
],
|
|
139
|
+
"stateMutability": "view",
|
|
140
|
+
"type": "function"
|
|
141
|
+
},
|
|
142
|
+
{
|
|
143
|
+
"inputs": [],
|
|
144
|
+
"name": "_swapTokensAtAmount",
|
|
145
|
+
"outputs": [
|
|
146
|
+
{
|
|
147
|
+
"internalType": "uint256",
|
|
148
|
+
"name": "",
|
|
149
|
+
"type": "uint256"
|
|
150
|
+
}
|
|
151
|
+
],
|
|
152
|
+
"stateMutability": "view",
|
|
209
153
|
"type": "function"
|
|
210
154
|
},
|
|
211
155
|
{
|
|
212
156
|
"inputs": [
|
|
213
157
|
{
|
|
214
158
|
"internalType": "address",
|
|
215
|
-
"name": "
|
|
159
|
+
"name": "owner",
|
|
216
160
|
"type": "address"
|
|
217
161
|
},
|
|
218
162
|
{
|
|
219
163
|
"internalType": "address",
|
|
220
|
-
"name": "
|
|
164
|
+
"name": "spender",
|
|
221
165
|
"type": "address"
|
|
222
166
|
}
|
|
223
167
|
],
|
|
@@ -241,7 +185,7 @@ export const SDSHD_jsonAbi = [
|
|
|
241
185
|
},
|
|
242
186
|
{
|
|
243
187
|
"internalType": "uint256",
|
|
244
|
-
"name": "
|
|
188
|
+
"name": "amount",
|
|
245
189
|
"type": "uint256"
|
|
246
190
|
}
|
|
247
191
|
],
|
|
@@ -275,22 +219,36 @@ export const SDSHD_jsonAbi = [
|
|
|
275
219
|
"stateMutability": "view",
|
|
276
220
|
"type": "function"
|
|
277
221
|
},
|
|
222
|
+
{
|
|
223
|
+
"inputs": [
|
|
224
|
+
{
|
|
225
|
+
"internalType": "address[]",
|
|
226
|
+
"name": "bots_",
|
|
227
|
+
"type": "address[]"
|
|
228
|
+
}
|
|
229
|
+
],
|
|
230
|
+
"name": "blockBots",
|
|
231
|
+
"outputs": [],
|
|
232
|
+
"stateMutability": "nonpayable",
|
|
233
|
+
"type": "function"
|
|
234
|
+
},
|
|
278
235
|
{
|
|
279
236
|
"inputs": [
|
|
280
237
|
{
|
|
281
238
|
"internalType": "address",
|
|
282
|
-
"name": "
|
|
239
|
+
"name": "",
|
|
283
240
|
"type": "address"
|
|
284
|
-
}
|
|
241
|
+
}
|
|
242
|
+
],
|
|
243
|
+
"name": "bots",
|
|
244
|
+
"outputs": [
|
|
285
245
|
{
|
|
286
|
-
"internalType": "
|
|
287
|
-
"name": "
|
|
288
|
-
"type": "
|
|
246
|
+
"internalType": "bool",
|
|
247
|
+
"name": "",
|
|
248
|
+
"type": "bool"
|
|
289
249
|
}
|
|
290
250
|
],
|
|
291
|
-
"
|
|
292
|
-
"outputs": [],
|
|
293
|
-
"stateMutability": "nonpayable",
|
|
251
|
+
"stateMutability": "view",
|
|
294
252
|
"type": "function"
|
|
295
253
|
},
|
|
296
254
|
{
|
|
@@ -303,26 +261,39 @@ export const SDSHD_jsonAbi = [
|
|
|
303
261
|
"type": "uint8"
|
|
304
262
|
}
|
|
305
263
|
],
|
|
306
|
-
"stateMutability": "
|
|
264
|
+
"stateMutability": "pure",
|
|
307
265
|
"type": "function"
|
|
308
266
|
},
|
|
309
267
|
{
|
|
310
268
|
"inputs": [
|
|
311
269
|
{
|
|
312
|
-
"internalType": "address",
|
|
313
|
-
"name": "
|
|
314
|
-
"type": "address"
|
|
315
|
-
}
|
|
316
|
-
],
|
|
317
|
-
"name": "isInBlackList",
|
|
318
|
-
"outputs": [
|
|
270
|
+
"internalType": "address[]",
|
|
271
|
+
"name": "accounts",
|
|
272
|
+
"type": "address[]"
|
|
273
|
+
},
|
|
319
274
|
{
|
|
320
275
|
"internalType": "bool",
|
|
321
|
-
"name": "",
|
|
276
|
+
"name": "excluded",
|
|
322
277
|
"type": "bool"
|
|
323
278
|
}
|
|
324
279
|
],
|
|
325
|
-
"
|
|
280
|
+
"name": "excludeMultipleAccountsFromFees",
|
|
281
|
+
"outputs": [],
|
|
282
|
+
"stateMutability": "nonpayable",
|
|
283
|
+
"type": "function"
|
|
284
|
+
},
|
|
285
|
+
{
|
|
286
|
+
"inputs": [],
|
|
287
|
+
"name": "manualsend",
|
|
288
|
+
"outputs": [],
|
|
289
|
+
"stateMutability": "nonpayable",
|
|
290
|
+
"type": "function"
|
|
291
|
+
},
|
|
292
|
+
{
|
|
293
|
+
"inputs": [],
|
|
294
|
+
"name": "manualswap",
|
|
295
|
+
"outputs": [],
|
|
296
|
+
"stateMutability": "nonpayable",
|
|
326
297
|
"type": "function"
|
|
327
298
|
},
|
|
328
299
|
{
|
|
@@ -335,7 +306,7 @@ export const SDSHD_jsonAbi = [
|
|
|
335
306
|
"type": "string"
|
|
336
307
|
}
|
|
337
308
|
],
|
|
338
|
-
"stateMutability": "
|
|
309
|
+
"stateMutability": "pure",
|
|
339
310
|
"type": "function"
|
|
340
311
|
},
|
|
341
312
|
{
|
|
@@ -353,33 +324,87 @@ export const SDSHD_jsonAbi = [
|
|
|
353
324
|
},
|
|
354
325
|
{
|
|
355
326
|
"inputs": [],
|
|
356
|
-
"name": "
|
|
357
|
-
"outputs": [
|
|
327
|
+
"name": "renounceOwnership",
|
|
328
|
+
"outputs": [],
|
|
329
|
+
"stateMutability": "nonpayable",
|
|
330
|
+
"type": "function"
|
|
331
|
+
},
|
|
332
|
+
{
|
|
333
|
+
"inputs": [
|
|
358
334
|
{
|
|
359
|
-
"internalType": "
|
|
360
|
-
"name": "",
|
|
361
|
-
"type": "
|
|
335
|
+
"internalType": "uint256",
|
|
336
|
+
"name": "redisFeeOnBuy",
|
|
337
|
+
"type": "uint256"
|
|
338
|
+
},
|
|
339
|
+
{
|
|
340
|
+
"internalType": "uint256",
|
|
341
|
+
"name": "redisFeeOnSell",
|
|
342
|
+
"type": "uint256"
|
|
343
|
+
},
|
|
344
|
+
{
|
|
345
|
+
"internalType": "uint256",
|
|
346
|
+
"name": "taxFeeOnBuy",
|
|
347
|
+
"type": "uint256"
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
"internalType": "uint256",
|
|
351
|
+
"name": "taxFeeOnSell",
|
|
352
|
+
"type": "uint256"
|
|
362
353
|
}
|
|
363
354
|
],
|
|
364
|
-
"
|
|
355
|
+
"name": "setFee",
|
|
356
|
+
"outputs": [],
|
|
357
|
+
"stateMutability": "nonpayable",
|
|
365
358
|
"type": "function"
|
|
366
359
|
},
|
|
367
360
|
{
|
|
368
361
|
"inputs": [
|
|
369
362
|
{
|
|
370
|
-
"internalType": "
|
|
371
|
-
"name": "
|
|
372
|
-
"type": "
|
|
363
|
+
"internalType": "uint256",
|
|
364
|
+
"name": "maxTxAmount",
|
|
365
|
+
"type": "uint256"
|
|
373
366
|
}
|
|
374
367
|
],
|
|
375
|
-
"name": "
|
|
368
|
+
"name": "setMaxTxnAmount",
|
|
376
369
|
"outputs": [],
|
|
377
370
|
"stateMutability": "nonpayable",
|
|
378
371
|
"type": "function"
|
|
379
372
|
},
|
|
380
373
|
{
|
|
381
|
-
"inputs": [
|
|
382
|
-
|
|
374
|
+
"inputs": [
|
|
375
|
+
{
|
|
376
|
+
"internalType": "uint256",
|
|
377
|
+
"name": "maxWalletSize",
|
|
378
|
+
"type": "uint256"
|
|
379
|
+
}
|
|
380
|
+
],
|
|
381
|
+
"name": "setMaxWalletSize",
|
|
382
|
+
"outputs": [],
|
|
383
|
+
"stateMutability": "nonpayable",
|
|
384
|
+
"type": "function"
|
|
385
|
+
},
|
|
386
|
+
{
|
|
387
|
+
"inputs": [
|
|
388
|
+
{
|
|
389
|
+
"internalType": "uint256",
|
|
390
|
+
"name": "swapTokensAtAmount",
|
|
391
|
+
"type": "uint256"
|
|
392
|
+
}
|
|
393
|
+
],
|
|
394
|
+
"name": "setMinSwapTokensThreshold",
|
|
395
|
+
"outputs": [],
|
|
396
|
+
"stateMutability": "nonpayable",
|
|
397
|
+
"type": "function"
|
|
398
|
+
},
|
|
399
|
+
{
|
|
400
|
+
"inputs": [
|
|
401
|
+
{
|
|
402
|
+
"internalType": "bool",
|
|
403
|
+
"name": "_tradingOpen",
|
|
404
|
+
"type": "bool"
|
|
405
|
+
}
|
|
406
|
+
],
|
|
407
|
+
"name": "setTrading",
|
|
383
408
|
"outputs": [],
|
|
384
409
|
"stateMutability": "nonpayable",
|
|
385
410
|
"type": "function"
|
|
@@ -394,20 +419,20 @@ export const SDSHD_jsonAbi = [
|
|
|
394
419
|
"type": "string"
|
|
395
420
|
}
|
|
396
421
|
],
|
|
397
|
-
"stateMutability": "
|
|
422
|
+
"stateMutability": "pure",
|
|
398
423
|
"type": "function"
|
|
399
424
|
},
|
|
400
425
|
{
|
|
401
|
-
"inputs": [
|
|
402
|
-
"name": "taxReceiver",
|
|
403
|
-
"outputs": [
|
|
426
|
+
"inputs": [
|
|
404
427
|
{
|
|
405
|
-
"internalType": "
|
|
406
|
-
"name": "",
|
|
407
|
-
"type": "
|
|
428
|
+
"internalType": "bool",
|
|
429
|
+
"name": "_swapEnabled",
|
|
430
|
+
"type": "bool"
|
|
408
431
|
}
|
|
409
432
|
],
|
|
410
|
-
"
|
|
433
|
+
"name": "toggleSwap",
|
|
434
|
+
"outputs": [],
|
|
435
|
+
"stateMutability": "nonpayable",
|
|
411
436
|
"type": "function"
|
|
412
437
|
},
|
|
413
438
|
{
|
|
@@ -420,19 +445,19 @@ export const SDSHD_jsonAbi = [
|
|
|
420
445
|
"type": "uint256"
|
|
421
446
|
}
|
|
422
447
|
],
|
|
423
|
-
"stateMutability": "
|
|
448
|
+
"stateMutability": "pure",
|
|
424
449
|
"type": "function"
|
|
425
450
|
},
|
|
426
451
|
{
|
|
427
452
|
"inputs": [
|
|
428
453
|
{
|
|
429
454
|
"internalType": "address",
|
|
430
|
-
"name": "
|
|
455
|
+
"name": "recipient",
|
|
431
456
|
"type": "address"
|
|
432
457
|
},
|
|
433
458
|
{
|
|
434
459
|
"internalType": "uint256",
|
|
435
|
-
"name": "
|
|
460
|
+
"name": "amount",
|
|
436
461
|
"type": "uint256"
|
|
437
462
|
}
|
|
438
463
|
],
|
|
@@ -451,17 +476,17 @@ export const SDSHD_jsonAbi = [
|
|
|
451
476
|
"inputs": [
|
|
452
477
|
{
|
|
453
478
|
"internalType": "address",
|
|
454
|
-
"name": "
|
|
479
|
+
"name": "sender",
|
|
455
480
|
"type": "address"
|
|
456
481
|
},
|
|
457
482
|
{
|
|
458
483
|
"internalType": "address",
|
|
459
|
-
"name": "
|
|
484
|
+
"name": "recipient",
|
|
460
485
|
"type": "address"
|
|
461
486
|
},
|
|
462
487
|
{
|
|
463
488
|
"internalType": "uint256",
|
|
464
|
-
"name": "
|
|
489
|
+
"name": "amount",
|
|
465
490
|
"type": "uint256"
|
|
466
491
|
}
|
|
467
492
|
],
|
|
@@ -492,32 +517,40 @@ export const SDSHD_jsonAbi = [
|
|
|
492
517
|
{
|
|
493
518
|
"inputs": [
|
|
494
519
|
{
|
|
495
|
-
"internalType": "address
|
|
496
|
-
"name": "
|
|
497
|
-
"type": "address
|
|
498
|
-
},
|
|
499
|
-
{
|
|
500
|
-
"internalType": "bool[]",
|
|
501
|
-
"name": "values",
|
|
502
|
-
"type": "bool[]"
|
|
520
|
+
"internalType": "address",
|
|
521
|
+
"name": "notbot",
|
|
522
|
+
"type": "address"
|
|
503
523
|
}
|
|
504
524
|
],
|
|
505
|
-
"name": "
|
|
525
|
+
"name": "unblockBot",
|
|
506
526
|
"outputs": [],
|
|
507
527
|
"stateMutability": "nonpayable",
|
|
508
528
|
"type": "function"
|
|
509
529
|
},
|
|
510
530
|
{
|
|
511
|
-
"inputs": [
|
|
531
|
+
"inputs": [],
|
|
532
|
+
"name": "uniswapV2Pair",
|
|
533
|
+
"outputs": [
|
|
512
534
|
{
|
|
513
535
|
"internalType": "address",
|
|
514
|
-
"name": "
|
|
536
|
+
"name": "",
|
|
515
537
|
"type": "address"
|
|
516
538
|
}
|
|
517
539
|
],
|
|
518
|
-
"
|
|
519
|
-
"
|
|
520
|
-
|
|
540
|
+
"stateMutability": "view",
|
|
541
|
+
"type": "function"
|
|
542
|
+
},
|
|
543
|
+
{
|
|
544
|
+
"inputs": [],
|
|
545
|
+
"name": "uniswapV2Router",
|
|
546
|
+
"outputs": [
|
|
547
|
+
{
|
|
548
|
+
"internalType": "contract IUniswapV2Router02",
|
|
549
|
+
"name": "",
|
|
550
|
+
"type": "address"
|
|
551
|
+
}
|
|
552
|
+
],
|
|
553
|
+
"stateMutability": "view",
|
|
521
554
|
"type": "function"
|
|
522
555
|
},
|
|
523
556
|
{
|
|
@@ -527,19 +560,19 @@ export const SDSHD_jsonAbi = [
|
|
|
527
560
|
] as const satisfies Abi;
|
|
528
561
|
|
|
529
562
|
/**
|
|
530
|
-
* Type-safe ABI for
|
|
563
|
+
* Type-safe ABI for XAI_json
|
|
531
564
|
*/
|
|
532
|
-
export type
|
|
565
|
+
export type XAI_jsonAbi = typeof XAI_jsonAbi;
|
|
533
566
|
|
|
534
567
|
/**
|
|
535
|
-
* Contract instance type for
|
|
568
|
+
* Contract instance type for XAI_json
|
|
536
569
|
*/
|
|
537
570
|
// Use any for contract type to avoid complex viem type issues
|
|
538
571
|
// The runtime behavior is type-safe through viem's ABI typing
|
|
539
|
-
export type
|
|
572
|
+
export type XAI_jsonContract = any;
|
|
540
573
|
|
|
541
574
|
/**
|
|
542
|
-
*
|
|
575
|
+
* XAI_json Contract Class
|
|
543
576
|
*
|
|
544
577
|
* Provides a class-based API similar to TypeChain for interacting with the contract.
|
|
545
578
|
*
|
|
@@ -547,12 +580,12 @@ export type SDSHD_jsonContract = any;
|
|
|
547
580
|
* ```typescript
|
|
548
581
|
* import { createPublicClient, createWalletClient, http } from 'viem';
|
|
549
582
|
* import { mainnet } from 'viem/chains';
|
|
550
|
-
* import {
|
|
583
|
+
* import { XAI_json } from 'XAI_json';
|
|
551
584
|
*
|
|
552
585
|
* const publicClient = createPublicClient({ chain: mainnet, transport: http() });
|
|
553
586
|
* const walletClient = createWalletClient({ chain: mainnet, transport: http() });
|
|
554
587
|
*
|
|
555
|
-
* const contract = new
|
|
588
|
+
* const contract = new XAI_json('0x...', { publicClient, walletClient });
|
|
556
589
|
*
|
|
557
590
|
* // Read functions
|
|
558
591
|
* const result = await contract.balanceOf('0x...');
|
|
@@ -570,8 +603,8 @@ export type SDSHD_jsonContract = any;
|
|
|
570
603
|
* });
|
|
571
604
|
* ```
|
|
572
605
|
*/
|
|
573
|
-
export class
|
|
574
|
-
private contract:
|
|
606
|
+
export class XAI_json {
|
|
607
|
+
private contract: XAI_jsonContract;
|
|
575
608
|
private contractAddress: Address;
|
|
576
609
|
private publicClient: PublicClient;
|
|
577
610
|
|
|
@@ -586,7 +619,7 @@ export class SDSHD_json {
|
|
|
586
619
|
this.publicClient = clients.publicClient;
|
|
587
620
|
this.contract = getContract({
|
|
588
621
|
address,
|
|
589
|
-
abi:
|
|
622
|
+
abi: XAI_jsonAbi,
|
|
590
623
|
client: {
|
|
591
624
|
public: clients.publicClient,
|
|
592
625
|
wallet: clients.walletClient,
|
|
@@ -604,16 +637,48 @@ export class SDSHD_json {
|
|
|
604
637
|
/**
|
|
605
638
|
* Get the underlying viem contract instance
|
|
606
639
|
*/
|
|
607
|
-
getContract():
|
|
640
|
+
getContract(): XAI_jsonContract {
|
|
608
641
|
return this.contract;
|
|
609
642
|
}
|
|
610
643
|
|
|
644
|
+
/**
|
|
645
|
+
* _buyMap
|
|
646
|
+
* view
|
|
647
|
+
*/
|
|
648
|
+
async _buyMap(arg0: `0x${string}`): Promise<bigint> {
|
|
649
|
+
return this.contract.read._buyMap([arg0] as const) as Promise<bigint>;
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
/**
|
|
653
|
+
* _maxTxAmount
|
|
654
|
+
* view
|
|
655
|
+
*/
|
|
656
|
+
async _maxTxAmount(): Promise<bigint> {
|
|
657
|
+
return this.contract.read._maxTxAmount() as Promise<bigint>;
|
|
658
|
+
}
|
|
659
|
+
|
|
660
|
+
/**
|
|
661
|
+
* _maxWalletSize
|
|
662
|
+
* view
|
|
663
|
+
*/
|
|
664
|
+
async _maxWalletSize(): Promise<bigint> {
|
|
665
|
+
return this.contract.read._maxWalletSize() as Promise<bigint>;
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
/**
|
|
669
|
+
* _swapTokensAtAmount
|
|
670
|
+
* view
|
|
671
|
+
*/
|
|
672
|
+
async _swapTokensAtAmount(): Promise<bigint> {
|
|
673
|
+
return this.contract.read._swapTokensAtAmount() as Promise<bigint>;
|
|
674
|
+
}
|
|
675
|
+
|
|
611
676
|
/**
|
|
612
677
|
* allowance
|
|
613
678
|
* view
|
|
614
679
|
*/
|
|
615
|
-
async allowance(
|
|
616
|
-
return this.contract.read.allowance([
|
|
680
|
+
async allowance(owner: `0x${string}`, spender: `0x${string}`): Promise<bigint> {
|
|
681
|
+
return this.contract.read.allowance([owner, spender] as const) as Promise<bigint>;
|
|
617
682
|
}
|
|
618
683
|
|
|
619
684
|
/**
|
|
@@ -625,75 +690,213 @@ export class SDSHD_json {
|
|
|
625
690
|
}
|
|
626
691
|
|
|
627
692
|
/**
|
|
628
|
-
*
|
|
693
|
+
* bots
|
|
629
694
|
* view
|
|
630
695
|
*/
|
|
696
|
+
async bots(arg0: `0x${string}`): Promise<boolean> {
|
|
697
|
+
return this.contract.read.bots([arg0] as const) as Promise<boolean>;
|
|
698
|
+
}
|
|
699
|
+
|
|
700
|
+
/**
|
|
701
|
+
* decimals
|
|
702
|
+
* pure
|
|
703
|
+
*/
|
|
631
704
|
async decimals(): Promise<bigint> {
|
|
632
705
|
return this.contract.read.decimals() as Promise<bigint>;
|
|
633
706
|
}
|
|
634
707
|
|
|
635
708
|
/**
|
|
636
|
-
*
|
|
709
|
+
* name
|
|
710
|
+
* pure
|
|
711
|
+
*/
|
|
712
|
+
async name(): Promise<string> {
|
|
713
|
+
return this.contract.read.name() as Promise<string>;
|
|
714
|
+
}
|
|
715
|
+
|
|
716
|
+
/**
|
|
717
|
+
* owner
|
|
637
718
|
* view
|
|
638
719
|
*/
|
|
639
|
-
async
|
|
640
|
-
return this.contract.read.
|
|
720
|
+
async owner(): Promise<`0x${string}`> {
|
|
721
|
+
return this.contract.read.owner() as Promise<`0x${string}`>;
|
|
641
722
|
}
|
|
642
723
|
|
|
643
724
|
/**
|
|
644
|
-
*
|
|
725
|
+
* symbol
|
|
726
|
+
* pure
|
|
727
|
+
*/
|
|
728
|
+
async symbol(): Promise<string> {
|
|
729
|
+
return this.contract.read.symbol() as Promise<string>;
|
|
730
|
+
}
|
|
731
|
+
|
|
732
|
+
/**
|
|
733
|
+
* totalSupply
|
|
734
|
+
* pure
|
|
735
|
+
*/
|
|
736
|
+
async totalSupply(): Promise<bigint> {
|
|
737
|
+
return this.contract.read.totalSupply() as Promise<bigint>;
|
|
738
|
+
}
|
|
739
|
+
|
|
740
|
+
/**
|
|
741
|
+
* uniswapV2Pair
|
|
645
742
|
* view
|
|
646
743
|
*/
|
|
647
|
-
async
|
|
648
|
-
return this.contract.read.
|
|
744
|
+
async uniswapV2Pair(): Promise<`0x${string}`> {
|
|
745
|
+
return this.contract.read.uniswapV2Pair() as Promise<`0x${string}`>;
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
/**
|
|
749
|
+
* uniswapV2Router
|
|
750
|
+
* view
|
|
751
|
+
*/
|
|
752
|
+
async uniswapV2Router(): Promise<`0x${string}`> {
|
|
753
|
+
return this.contract.read.uniswapV2Router() as Promise<`0x${string}`>;
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
/**
|
|
757
|
+
* approve
|
|
758
|
+
* nonpayable
|
|
759
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
760
|
+
*/
|
|
761
|
+
async approve(spender: `0x${string}`, amount: bigint, options?: {
|
|
762
|
+
accessList?: import('viem').AccessList;
|
|
763
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
764
|
+
chain?: import('viem').Chain | null;
|
|
765
|
+
dataSuffix?: `0x${string}`;
|
|
766
|
+
gas?: bigint;
|
|
767
|
+
gasPrice?: bigint;
|
|
768
|
+
maxFeePerGas?: bigint;
|
|
769
|
+
maxPriorityFeePerGas?: bigint;
|
|
770
|
+
nonce?: number;
|
|
771
|
+
value?: bigint;
|
|
772
|
+
}): Promise<`0x${string}`> {
|
|
773
|
+
if (!this.contract.write) {
|
|
774
|
+
throw new Error('Wallet client is required for write operations');
|
|
775
|
+
}
|
|
776
|
+
return this.contract.write.approve([spender, amount] as const, options) as Promise<`0x${string}`>;
|
|
649
777
|
}
|
|
650
778
|
|
|
651
779
|
/**
|
|
652
|
-
*
|
|
653
|
-
*
|
|
780
|
+
* blockBots
|
|
781
|
+
* nonpayable
|
|
782
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
654
783
|
*/
|
|
655
|
-
async
|
|
656
|
-
|
|
784
|
+
async blockBots(bots_: `0x${string}`[], options?: {
|
|
785
|
+
accessList?: import('viem').AccessList;
|
|
786
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
787
|
+
chain?: import('viem').Chain | null;
|
|
788
|
+
dataSuffix?: `0x${string}`;
|
|
789
|
+
gas?: bigint;
|
|
790
|
+
gasPrice?: bigint;
|
|
791
|
+
maxFeePerGas?: bigint;
|
|
792
|
+
maxPriorityFeePerGas?: bigint;
|
|
793
|
+
nonce?: number;
|
|
794
|
+
value?: bigint;
|
|
795
|
+
}): Promise<`0x${string}`> {
|
|
796
|
+
if (!this.contract.write) {
|
|
797
|
+
throw new Error('Wallet client is required for write operations');
|
|
798
|
+
}
|
|
799
|
+
return this.contract.write.blockBots([bots_] as const, options) as Promise<`0x${string}`>;
|
|
657
800
|
}
|
|
658
801
|
|
|
659
802
|
/**
|
|
660
|
-
*
|
|
661
|
-
*
|
|
803
|
+
* excludeMultipleAccountsFromFees
|
|
804
|
+
* nonpayable
|
|
805
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
662
806
|
*/
|
|
663
|
-
async
|
|
664
|
-
|
|
807
|
+
async excludeMultipleAccountsFromFees(accounts: `0x${string}`[], excluded: boolean, options?: {
|
|
808
|
+
accessList?: import('viem').AccessList;
|
|
809
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
810
|
+
chain?: import('viem').Chain | null;
|
|
811
|
+
dataSuffix?: `0x${string}`;
|
|
812
|
+
gas?: bigint;
|
|
813
|
+
gasPrice?: bigint;
|
|
814
|
+
maxFeePerGas?: bigint;
|
|
815
|
+
maxPriorityFeePerGas?: bigint;
|
|
816
|
+
nonce?: number;
|
|
817
|
+
value?: bigint;
|
|
818
|
+
}): Promise<`0x${string}`> {
|
|
819
|
+
if (!this.contract.write) {
|
|
820
|
+
throw new Error('Wallet client is required for write operations');
|
|
821
|
+
}
|
|
822
|
+
return this.contract.write.excludeMultipleAccountsFromFees([accounts, excluded] as const, options) as Promise<`0x${string}`>;
|
|
665
823
|
}
|
|
666
824
|
|
|
667
825
|
/**
|
|
668
|
-
*
|
|
669
|
-
*
|
|
826
|
+
* manualsend
|
|
827
|
+
* nonpayable
|
|
828
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
670
829
|
*/
|
|
671
|
-
async
|
|
672
|
-
|
|
830
|
+
async manualsend(options?: {
|
|
831
|
+
accessList?: import('viem').AccessList;
|
|
832
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
833
|
+
chain?: import('viem').Chain | null;
|
|
834
|
+
dataSuffix?: `0x${string}`;
|
|
835
|
+
gas?: bigint;
|
|
836
|
+
gasPrice?: bigint;
|
|
837
|
+
maxFeePerGas?: bigint;
|
|
838
|
+
maxPriorityFeePerGas?: bigint;
|
|
839
|
+
nonce?: number;
|
|
840
|
+
value?: bigint;
|
|
841
|
+
}): Promise<`0x${string}`> {
|
|
842
|
+
if (!this.contract.write) {
|
|
843
|
+
throw new Error('Wallet client is required for write operations');
|
|
844
|
+
}
|
|
845
|
+
return this.contract.write.manualsend(options) as Promise<`0x${string}`>;
|
|
673
846
|
}
|
|
674
847
|
|
|
675
848
|
/**
|
|
676
|
-
*
|
|
677
|
-
*
|
|
849
|
+
* manualswap
|
|
850
|
+
* nonpayable
|
|
851
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
678
852
|
*/
|
|
679
|
-
async
|
|
680
|
-
|
|
853
|
+
async manualswap(options?: {
|
|
854
|
+
accessList?: import('viem').AccessList;
|
|
855
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
856
|
+
chain?: import('viem').Chain | null;
|
|
857
|
+
dataSuffix?: `0x${string}`;
|
|
858
|
+
gas?: bigint;
|
|
859
|
+
gasPrice?: bigint;
|
|
860
|
+
maxFeePerGas?: bigint;
|
|
861
|
+
maxPriorityFeePerGas?: bigint;
|
|
862
|
+
nonce?: number;
|
|
863
|
+
value?: bigint;
|
|
864
|
+
}): Promise<`0x${string}`> {
|
|
865
|
+
if (!this.contract.write) {
|
|
866
|
+
throw new Error('Wallet client is required for write operations');
|
|
867
|
+
}
|
|
868
|
+
return this.contract.write.manualswap(options) as Promise<`0x${string}`>;
|
|
681
869
|
}
|
|
682
870
|
|
|
683
871
|
/**
|
|
684
|
-
*
|
|
685
|
-
*
|
|
872
|
+
* renounceOwnership
|
|
873
|
+
* nonpayable
|
|
874
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
686
875
|
*/
|
|
687
|
-
async
|
|
688
|
-
|
|
876
|
+
async renounceOwnership(options?: {
|
|
877
|
+
accessList?: import('viem').AccessList;
|
|
878
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
879
|
+
chain?: import('viem').Chain | null;
|
|
880
|
+
dataSuffix?: `0x${string}`;
|
|
881
|
+
gas?: bigint;
|
|
882
|
+
gasPrice?: bigint;
|
|
883
|
+
maxFeePerGas?: bigint;
|
|
884
|
+
maxPriorityFeePerGas?: bigint;
|
|
885
|
+
nonce?: number;
|
|
886
|
+
value?: bigint;
|
|
887
|
+
}): Promise<`0x${string}`> {
|
|
888
|
+
if (!this.contract.write) {
|
|
889
|
+
throw new Error('Wallet client is required for write operations');
|
|
890
|
+
}
|
|
891
|
+
return this.contract.write.renounceOwnership(options) as Promise<`0x${string}`>;
|
|
689
892
|
}
|
|
690
893
|
|
|
691
894
|
/**
|
|
692
|
-
*
|
|
895
|
+
* setFee
|
|
693
896
|
* nonpayable
|
|
694
897
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
695
898
|
*/
|
|
696
|
-
async
|
|
899
|
+
async setFee(redisFeeOnBuy: bigint, redisFeeOnSell: bigint, taxFeeOnBuy: bigint, taxFeeOnSell: bigint, options?: {
|
|
697
900
|
accessList?: import('viem').AccessList;
|
|
698
901
|
authorizationList?: import('viem').AuthorizationList;
|
|
699
902
|
chain?: import('viem').Chain | null;
|
|
@@ -708,15 +911,15 @@ export class SDSHD_json {
|
|
|
708
911
|
if (!this.contract.write) {
|
|
709
912
|
throw new Error('Wallet client is required for write operations');
|
|
710
913
|
}
|
|
711
|
-
return this.contract.write.
|
|
914
|
+
return this.contract.write.setFee([redisFeeOnBuy, redisFeeOnSell, taxFeeOnBuy, taxFeeOnSell] as const, options) as Promise<`0x${string}`>;
|
|
712
915
|
}
|
|
713
916
|
|
|
714
917
|
/**
|
|
715
|
-
*
|
|
918
|
+
* setMaxTxnAmount
|
|
716
919
|
* nonpayable
|
|
717
920
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
718
921
|
*/
|
|
719
|
-
async
|
|
922
|
+
async setMaxTxnAmount(maxTxAmount: bigint, options?: {
|
|
720
923
|
accessList?: import('viem').AccessList;
|
|
721
924
|
authorizationList?: import('viem').AuthorizationList;
|
|
722
925
|
chain?: import('viem').Chain | null;
|
|
@@ -731,15 +934,15 @@ export class SDSHD_json {
|
|
|
731
934
|
if (!this.contract.write) {
|
|
732
935
|
throw new Error('Wallet client is required for write operations');
|
|
733
936
|
}
|
|
734
|
-
return this.contract.write.
|
|
937
|
+
return this.contract.write.setMaxTxnAmount([maxTxAmount] as const, options) as Promise<`0x${string}`>;
|
|
735
938
|
}
|
|
736
939
|
|
|
737
940
|
/**
|
|
738
|
-
*
|
|
941
|
+
* setMaxWalletSize
|
|
739
942
|
* nonpayable
|
|
740
943
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
741
944
|
*/
|
|
742
|
-
async
|
|
945
|
+
async setMaxWalletSize(maxWalletSize: bigint, options?: {
|
|
743
946
|
accessList?: import('viem').AccessList;
|
|
744
947
|
authorizationList?: import('viem').AuthorizationList;
|
|
745
948
|
chain?: import('viem').Chain | null;
|
|
@@ -754,15 +957,15 @@ export class SDSHD_json {
|
|
|
754
957
|
if (!this.contract.write) {
|
|
755
958
|
throw new Error('Wallet client is required for write operations');
|
|
756
959
|
}
|
|
757
|
-
return this.contract.write.
|
|
960
|
+
return this.contract.write.setMaxWalletSize([maxWalletSize] as const, options) as Promise<`0x${string}`>;
|
|
758
961
|
}
|
|
759
962
|
|
|
760
963
|
/**
|
|
761
|
-
*
|
|
964
|
+
* setMinSwapTokensThreshold
|
|
762
965
|
* nonpayable
|
|
763
966
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
764
967
|
*/
|
|
765
|
-
async
|
|
968
|
+
async setMinSwapTokensThreshold(swapTokensAtAmount: bigint, options?: {
|
|
766
969
|
accessList?: import('viem').AccessList;
|
|
767
970
|
authorizationList?: import('viem').AuthorizationList;
|
|
768
971
|
chain?: import('viem').Chain | null;
|
|
@@ -777,15 +980,15 @@ export class SDSHD_json {
|
|
|
777
980
|
if (!this.contract.write) {
|
|
778
981
|
throw new Error('Wallet client is required for write operations');
|
|
779
982
|
}
|
|
780
|
-
return this.contract.write.
|
|
983
|
+
return this.contract.write.setMinSwapTokensThreshold([swapTokensAtAmount] as const, options) as Promise<`0x${string}`>;
|
|
781
984
|
}
|
|
782
985
|
|
|
783
986
|
/**
|
|
784
|
-
*
|
|
987
|
+
* setTrading
|
|
785
988
|
* nonpayable
|
|
786
989
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
787
990
|
*/
|
|
788
|
-
async
|
|
991
|
+
async setTrading(_tradingOpen: boolean, options?: {
|
|
789
992
|
accessList?: import('viem').AccessList;
|
|
790
993
|
authorizationList?: import('viem').AuthorizationList;
|
|
791
994
|
chain?: import('viem').Chain | null;
|
|
@@ -800,15 +1003,15 @@ export class SDSHD_json {
|
|
|
800
1003
|
if (!this.contract.write) {
|
|
801
1004
|
throw new Error('Wallet client is required for write operations');
|
|
802
1005
|
}
|
|
803
|
-
return this.contract.write.
|
|
1006
|
+
return this.contract.write.setTrading([_tradingOpen] as const, options) as Promise<`0x${string}`>;
|
|
804
1007
|
}
|
|
805
1008
|
|
|
806
1009
|
/**
|
|
807
|
-
*
|
|
1010
|
+
* toggleSwap
|
|
808
1011
|
* nonpayable
|
|
809
1012
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
810
1013
|
*/
|
|
811
|
-
async
|
|
1014
|
+
async toggleSwap(_swapEnabled: boolean, options?: {
|
|
812
1015
|
accessList?: import('viem').AccessList;
|
|
813
1016
|
authorizationList?: import('viem').AuthorizationList;
|
|
814
1017
|
chain?: import('viem').Chain | null;
|
|
@@ -823,15 +1026,15 @@ export class SDSHD_json {
|
|
|
823
1026
|
if (!this.contract.write) {
|
|
824
1027
|
throw new Error('Wallet client is required for write operations');
|
|
825
1028
|
}
|
|
826
|
-
return this.contract.write.
|
|
1029
|
+
return this.contract.write.toggleSwap([_swapEnabled] as const, options) as Promise<`0x${string}`>;
|
|
827
1030
|
}
|
|
828
1031
|
|
|
829
1032
|
/**
|
|
830
|
-
*
|
|
1033
|
+
* transfer
|
|
831
1034
|
* nonpayable
|
|
832
1035
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
833
1036
|
*/
|
|
834
|
-
async
|
|
1037
|
+
async transfer(recipient: `0x${string}`, amount: bigint, options?: {
|
|
835
1038
|
accessList?: import('viem').AccessList;
|
|
836
1039
|
authorizationList?: import('viem').AuthorizationList;
|
|
837
1040
|
chain?: import('viem').Chain | null;
|
|
@@ -846,15 +1049,15 @@ export class SDSHD_json {
|
|
|
846
1049
|
if (!this.contract.write) {
|
|
847
1050
|
throw new Error('Wallet client is required for write operations');
|
|
848
1051
|
}
|
|
849
|
-
return this.contract.write.
|
|
1052
|
+
return this.contract.write.transfer([recipient, amount] as const, options) as Promise<`0x${string}`>;
|
|
850
1053
|
}
|
|
851
1054
|
|
|
852
1055
|
/**
|
|
853
|
-
*
|
|
1056
|
+
* transferFrom
|
|
854
1057
|
* nonpayable
|
|
855
1058
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
856
1059
|
*/
|
|
857
|
-
async
|
|
1060
|
+
async transferFrom(sender: `0x${string}`, recipient: `0x${string}`, amount: bigint, options?: {
|
|
858
1061
|
accessList?: import('viem').AccessList;
|
|
859
1062
|
authorizationList?: import('viem').AuthorizationList;
|
|
860
1063
|
chain?: import('viem').Chain | null;
|
|
@@ -869,15 +1072,15 @@ export class SDSHD_json {
|
|
|
869
1072
|
if (!this.contract.write) {
|
|
870
1073
|
throw new Error('Wallet client is required for write operations');
|
|
871
1074
|
}
|
|
872
|
-
return this.contract.write.
|
|
1075
|
+
return this.contract.write.transferFrom([sender, recipient, amount] as const, options) as Promise<`0x${string}`>;
|
|
873
1076
|
}
|
|
874
1077
|
|
|
875
1078
|
/**
|
|
876
|
-
*
|
|
1079
|
+
* transferOwnership
|
|
877
1080
|
* nonpayable
|
|
878
1081
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
879
1082
|
*/
|
|
880
|
-
async
|
|
1083
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
881
1084
|
accessList?: import('viem').AccessList;
|
|
882
1085
|
authorizationList?: import('viem').AuthorizationList;
|
|
883
1086
|
chain?: import('viem').Chain | null;
|
|
@@ -892,15 +1095,15 @@ export class SDSHD_json {
|
|
|
892
1095
|
if (!this.contract.write) {
|
|
893
1096
|
throw new Error('Wallet client is required for write operations');
|
|
894
1097
|
}
|
|
895
|
-
return this.contract.write.
|
|
1098
|
+
return this.contract.write.transferOwnership([newOwner] as const, options) as Promise<`0x${string}`>;
|
|
896
1099
|
}
|
|
897
1100
|
|
|
898
1101
|
/**
|
|
899
|
-
*
|
|
1102
|
+
* unblockBot
|
|
900
1103
|
* nonpayable
|
|
901
1104
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
902
1105
|
*/
|
|
903
|
-
async
|
|
1106
|
+
async unblockBot(notbot: `0x${string}`, options?: {
|
|
904
1107
|
accessList?: import('viem').AccessList;
|
|
905
1108
|
authorizationList?: import('viem').AuthorizationList;
|
|
906
1109
|
chain?: import('viem').Chain | null;
|
|
@@ -915,7 +1118,7 @@ export class SDSHD_json {
|
|
|
915
1118
|
if (!this.contract.write) {
|
|
916
1119
|
throw new Error('Wallet client is required for write operations');
|
|
917
1120
|
}
|
|
918
|
-
return this.contract.write.
|
|
1121
|
+
return this.contract.write.unblockBot([notbot] as const, options) as Promise<`0x${string}`>;
|
|
919
1122
|
}
|
|
920
1123
|
|
|
921
1124
|
|
|
@@ -935,11 +1138,30 @@ export class SDSHD_json {
|
|
|
935
1138
|
}
|
|
936
1139
|
return {
|
|
937
1140
|
/**
|
|
938
|
-
* Simulate
|
|
1141
|
+
* Simulate approve
|
|
1142
|
+
* Returns gas estimate and result without sending transaction
|
|
1143
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1144
|
+
*/
|
|
1145
|
+
async approve(spender: `0x${string}`, amount: bigint, options?: {
|
|
1146
|
+
accessList?: import('viem').AccessList;
|
|
1147
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1148
|
+
chain?: import('viem').Chain | null;
|
|
1149
|
+
dataSuffix?: `0x${string}`;
|
|
1150
|
+
gas?: bigint;
|
|
1151
|
+
gasPrice?: bigint;
|
|
1152
|
+
maxFeePerGas?: bigint;
|
|
1153
|
+
maxPriorityFeePerGas?: bigint;
|
|
1154
|
+
nonce?: number;
|
|
1155
|
+
value?: bigint;
|
|
1156
|
+
}): Promise<boolean> {
|
|
1157
|
+
return contract.simulate.approve([spender, amount] as const, options) as Promise<boolean>;
|
|
1158
|
+
},
|
|
1159
|
+
/**
|
|
1160
|
+
* Simulate blockBots
|
|
939
1161
|
* Returns gas estimate and result without sending transaction
|
|
940
1162
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
941
1163
|
*/
|
|
942
|
-
async
|
|
1164
|
+
async blockBots(bots_: `0x${string}`[], options?: {
|
|
943
1165
|
accessList?: import('viem').AccessList;
|
|
944
1166
|
authorizationList?: import('viem').AuthorizationList;
|
|
945
1167
|
chain?: import('viem').Chain | null;
|
|
@@ -951,14 +1173,14 @@ export class SDSHD_json {
|
|
|
951
1173
|
nonce?: number;
|
|
952
1174
|
value?: bigint;
|
|
953
1175
|
}): Promise<void> {
|
|
954
|
-
return contract.simulate.
|
|
1176
|
+
return contract.simulate.blockBots([bots_] as const, options) as Promise<void>;
|
|
955
1177
|
},
|
|
956
1178
|
/**
|
|
957
|
-
* Simulate
|
|
1179
|
+
* Simulate excludeMultipleAccountsFromFees
|
|
958
1180
|
* Returns gas estimate and result without sending transaction
|
|
959
1181
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
960
1182
|
*/
|
|
961
|
-
async
|
|
1183
|
+
async excludeMultipleAccountsFromFees(accounts: `0x${string}`[], excluded: boolean, options?: {
|
|
962
1184
|
accessList?: import('viem').AccessList;
|
|
963
1185
|
authorizationList?: import('viem').AuthorizationList;
|
|
964
1186
|
chain?: import('viem').Chain | null;
|
|
@@ -969,15 +1191,15 @@ export class SDSHD_json {
|
|
|
969
1191
|
maxPriorityFeePerGas?: bigint;
|
|
970
1192
|
nonce?: number;
|
|
971
1193
|
value?: bigint;
|
|
972
|
-
}): Promise<
|
|
973
|
-
return contract.simulate.
|
|
1194
|
+
}): Promise<void> {
|
|
1195
|
+
return contract.simulate.excludeMultipleAccountsFromFees([accounts, excluded] as const, options) as Promise<void>;
|
|
974
1196
|
},
|
|
975
1197
|
/**
|
|
976
|
-
* Simulate
|
|
1198
|
+
* Simulate manualsend
|
|
977
1199
|
* Returns gas estimate and result without sending transaction
|
|
978
1200
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
979
1201
|
*/
|
|
980
|
-
async
|
|
1202
|
+
async manualsend(options?: {
|
|
981
1203
|
accessList?: import('viem').AccessList;
|
|
982
1204
|
authorizationList?: import('viem').AuthorizationList;
|
|
983
1205
|
chain?: import('viem').Chain | null;
|
|
@@ -989,14 +1211,14 @@ export class SDSHD_json {
|
|
|
989
1211
|
nonce?: number;
|
|
990
1212
|
value?: bigint;
|
|
991
1213
|
}): Promise<void> {
|
|
992
|
-
return contract.simulate.
|
|
1214
|
+
return contract.simulate.manualsend(options) as Promise<void>;
|
|
993
1215
|
},
|
|
994
1216
|
/**
|
|
995
|
-
* Simulate
|
|
1217
|
+
* Simulate manualswap
|
|
996
1218
|
* Returns gas estimate and result without sending transaction
|
|
997
1219
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
998
1220
|
*/
|
|
999
|
-
async
|
|
1221
|
+
async manualswap(options?: {
|
|
1000
1222
|
accessList?: import('viem').AccessList;
|
|
1001
1223
|
authorizationList?: import('viem').AuthorizationList;
|
|
1002
1224
|
chain?: import('viem').Chain | null;
|
|
@@ -1008,7 +1230,7 @@ export class SDSHD_json {
|
|
|
1008
1230
|
nonce?: number;
|
|
1009
1231
|
value?: bigint;
|
|
1010
1232
|
}): Promise<void> {
|
|
1011
|
-
return contract.simulate.
|
|
1233
|
+
return contract.simulate.manualswap(options) as Promise<void>;
|
|
1012
1234
|
},
|
|
1013
1235
|
/**
|
|
1014
1236
|
* Simulate renounceOwnership
|
|
@@ -1030,11 +1252,11 @@ export class SDSHD_json {
|
|
|
1030
1252
|
return contract.simulate.renounceOwnership(options) as Promise<void>;
|
|
1031
1253
|
},
|
|
1032
1254
|
/**
|
|
1033
|
-
* Simulate
|
|
1255
|
+
* Simulate setFee
|
|
1034
1256
|
* Returns gas estimate and result without sending transaction
|
|
1035
1257
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1036
1258
|
*/
|
|
1037
|
-
async
|
|
1259
|
+
async setFee(redisFeeOnBuy: bigint, redisFeeOnSell: bigint, taxFeeOnBuy: bigint, taxFeeOnSell: bigint, options?: {
|
|
1038
1260
|
accessList?: import('viem').AccessList;
|
|
1039
1261
|
authorizationList?: import('viem').AuthorizationList;
|
|
1040
1262
|
chain?: import('viem').Chain | null;
|
|
@@ -1045,15 +1267,15 @@ export class SDSHD_json {
|
|
|
1045
1267
|
maxPriorityFeePerGas?: bigint;
|
|
1046
1268
|
nonce?: number;
|
|
1047
1269
|
value?: bigint;
|
|
1048
|
-
}): Promise<
|
|
1049
|
-
return contract.simulate.
|
|
1270
|
+
}): Promise<void> {
|
|
1271
|
+
return contract.simulate.setFee([redisFeeOnBuy, redisFeeOnSell, taxFeeOnBuy, taxFeeOnSell] as const, options) as Promise<void>;
|
|
1050
1272
|
},
|
|
1051
1273
|
/**
|
|
1052
|
-
* Simulate
|
|
1274
|
+
* Simulate setMaxTxnAmount
|
|
1053
1275
|
* Returns gas estimate and result without sending transaction
|
|
1054
1276
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1055
1277
|
*/
|
|
1056
|
-
async
|
|
1278
|
+
async setMaxTxnAmount(maxTxAmount: bigint, options?: {
|
|
1057
1279
|
accessList?: import('viem').AccessList;
|
|
1058
1280
|
authorizationList?: import('viem').AuthorizationList;
|
|
1059
1281
|
chain?: import('viem').Chain | null;
|
|
@@ -1064,15 +1286,15 @@ export class SDSHD_json {
|
|
|
1064
1286
|
maxPriorityFeePerGas?: bigint;
|
|
1065
1287
|
nonce?: number;
|
|
1066
1288
|
value?: bigint;
|
|
1067
|
-
}): Promise<
|
|
1068
|
-
return contract.simulate.
|
|
1289
|
+
}): Promise<void> {
|
|
1290
|
+
return contract.simulate.setMaxTxnAmount([maxTxAmount] as const, options) as Promise<void>;
|
|
1069
1291
|
},
|
|
1070
1292
|
/**
|
|
1071
|
-
* Simulate
|
|
1293
|
+
* Simulate setMaxWalletSize
|
|
1072
1294
|
* Returns gas estimate and result without sending transaction
|
|
1073
1295
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1074
1296
|
*/
|
|
1075
|
-
async
|
|
1297
|
+
async setMaxWalletSize(maxWalletSize: bigint, options?: {
|
|
1076
1298
|
accessList?: import('viem').AccessList;
|
|
1077
1299
|
authorizationList?: import('viem').AuthorizationList;
|
|
1078
1300
|
chain?: import('viem').Chain | null;
|
|
@@ -1084,14 +1306,109 @@ export class SDSHD_json {
|
|
|
1084
1306
|
nonce?: number;
|
|
1085
1307
|
value?: bigint;
|
|
1086
1308
|
}): Promise<void> {
|
|
1087
|
-
return contract.simulate.
|
|
1309
|
+
return contract.simulate.setMaxWalletSize([maxWalletSize] as const, options) as Promise<void>;
|
|
1310
|
+
},
|
|
1311
|
+
/**
|
|
1312
|
+
* Simulate setMinSwapTokensThreshold
|
|
1313
|
+
* Returns gas estimate and result without sending transaction
|
|
1314
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1315
|
+
*/
|
|
1316
|
+
async setMinSwapTokensThreshold(swapTokensAtAmount: bigint, options?: {
|
|
1317
|
+
accessList?: import('viem').AccessList;
|
|
1318
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1319
|
+
chain?: import('viem').Chain | null;
|
|
1320
|
+
dataSuffix?: `0x${string}`;
|
|
1321
|
+
gas?: bigint;
|
|
1322
|
+
gasPrice?: bigint;
|
|
1323
|
+
maxFeePerGas?: bigint;
|
|
1324
|
+
maxPriorityFeePerGas?: bigint;
|
|
1325
|
+
nonce?: number;
|
|
1326
|
+
value?: bigint;
|
|
1327
|
+
}): Promise<void> {
|
|
1328
|
+
return contract.simulate.setMinSwapTokensThreshold([swapTokensAtAmount] as const, options) as Promise<void>;
|
|
1329
|
+
},
|
|
1330
|
+
/**
|
|
1331
|
+
* Simulate setTrading
|
|
1332
|
+
* Returns gas estimate and result without sending transaction
|
|
1333
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1334
|
+
*/
|
|
1335
|
+
async setTrading(_tradingOpen: boolean, options?: {
|
|
1336
|
+
accessList?: import('viem').AccessList;
|
|
1337
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1338
|
+
chain?: import('viem').Chain | null;
|
|
1339
|
+
dataSuffix?: `0x${string}`;
|
|
1340
|
+
gas?: bigint;
|
|
1341
|
+
gasPrice?: bigint;
|
|
1342
|
+
maxFeePerGas?: bigint;
|
|
1343
|
+
maxPriorityFeePerGas?: bigint;
|
|
1344
|
+
nonce?: number;
|
|
1345
|
+
value?: bigint;
|
|
1346
|
+
}): Promise<void> {
|
|
1347
|
+
return contract.simulate.setTrading([_tradingOpen] as const, options) as Promise<void>;
|
|
1348
|
+
},
|
|
1349
|
+
/**
|
|
1350
|
+
* Simulate toggleSwap
|
|
1351
|
+
* Returns gas estimate and result without sending transaction
|
|
1352
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1353
|
+
*/
|
|
1354
|
+
async toggleSwap(_swapEnabled: boolean, options?: {
|
|
1355
|
+
accessList?: import('viem').AccessList;
|
|
1356
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1357
|
+
chain?: import('viem').Chain | null;
|
|
1358
|
+
dataSuffix?: `0x${string}`;
|
|
1359
|
+
gas?: bigint;
|
|
1360
|
+
gasPrice?: bigint;
|
|
1361
|
+
maxFeePerGas?: bigint;
|
|
1362
|
+
maxPriorityFeePerGas?: bigint;
|
|
1363
|
+
nonce?: number;
|
|
1364
|
+
value?: bigint;
|
|
1365
|
+
}): Promise<void> {
|
|
1366
|
+
return contract.simulate.toggleSwap([_swapEnabled] as const, options) as Promise<void>;
|
|
1367
|
+
},
|
|
1368
|
+
/**
|
|
1369
|
+
* Simulate transfer
|
|
1370
|
+
* Returns gas estimate and result without sending transaction
|
|
1371
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1372
|
+
*/
|
|
1373
|
+
async transfer(recipient: `0x${string}`, amount: bigint, options?: {
|
|
1374
|
+
accessList?: import('viem').AccessList;
|
|
1375
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1376
|
+
chain?: import('viem').Chain | null;
|
|
1377
|
+
dataSuffix?: `0x${string}`;
|
|
1378
|
+
gas?: bigint;
|
|
1379
|
+
gasPrice?: bigint;
|
|
1380
|
+
maxFeePerGas?: bigint;
|
|
1381
|
+
maxPriorityFeePerGas?: bigint;
|
|
1382
|
+
nonce?: number;
|
|
1383
|
+
value?: bigint;
|
|
1384
|
+
}): Promise<boolean> {
|
|
1385
|
+
return contract.simulate.transfer([recipient, amount] as const, options) as Promise<boolean>;
|
|
1386
|
+
},
|
|
1387
|
+
/**
|
|
1388
|
+
* Simulate transferFrom
|
|
1389
|
+
* Returns gas estimate and result without sending transaction
|
|
1390
|
+
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1391
|
+
*/
|
|
1392
|
+
async transferFrom(sender: `0x${string}`, recipient: `0x${string}`, amount: bigint, options?: {
|
|
1393
|
+
accessList?: import('viem').AccessList;
|
|
1394
|
+
authorizationList?: import('viem').AuthorizationList;
|
|
1395
|
+
chain?: import('viem').Chain | null;
|
|
1396
|
+
dataSuffix?: `0x${string}`;
|
|
1397
|
+
gas?: bigint;
|
|
1398
|
+
gasPrice?: bigint;
|
|
1399
|
+
maxFeePerGas?: bigint;
|
|
1400
|
+
maxPriorityFeePerGas?: bigint;
|
|
1401
|
+
nonce?: number;
|
|
1402
|
+
value?: bigint;
|
|
1403
|
+
}): Promise<boolean> {
|
|
1404
|
+
return contract.simulate.transferFrom([sender, recipient, amount] as const, options) as Promise<boolean>;
|
|
1088
1405
|
},
|
|
1089
1406
|
/**
|
|
1090
|
-
* Simulate
|
|
1407
|
+
* Simulate transferOwnership
|
|
1091
1408
|
* Returns gas estimate and result without sending transaction
|
|
1092
1409
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1093
1410
|
*/
|
|
1094
|
-
async
|
|
1411
|
+
async transferOwnership(newOwner: `0x${string}`, options?: {
|
|
1095
1412
|
accessList?: import('viem').AccessList;
|
|
1096
1413
|
authorizationList?: import('viem').AuthorizationList;
|
|
1097
1414
|
chain?: import('viem').Chain | null;
|
|
@@ -1103,14 +1420,14 @@ export class SDSHD_json {
|
|
|
1103
1420
|
nonce?: number;
|
|
1104
1421
|
value?: bigint;
|
|
1105
1422
|
}): Promise<void> {
|
|
1106
|
-
return contract.simulate.
|
|
1423
|
+
return contract.simulate.transferOwnership([newOwner] as const, options) as Promise<void>;
|
|
1107
1424
|
},
|
|
1108
1425
|
/**
|
|
1109
|
-
* Simulate
|
|
1426
|
+
* Simulate unblockBot
|
|
1110
1427
|
* Returns gas estimate and result without sending transaction
|
|
1111
1428
|
* @param options Optional transaction parameters (value, gas, nonce, etc.)
|
|
1112
1429
|
*/
|
|
1113
|
-
async
|
|
1430
|
+
async unblockBot(notbot: `0x${string}`, options?: {
|
|
1114
1431
|
accessList?: import('viem').AccessList;
|
|
1115
1432
|
authorizationList?: import('viem').AuthorizationList;
|
|
1116
1433
|
chain?: import('viem').Chain | null;
|
|
@@ -1122,7 +1439,7 @@ export class SDSHD_json {
|
|
|
1122
1439
|
nonce?: number;
|
|
1123
1440
|
value?: bigint;
|
|
1124
1441
|
}): Promise<void> {
|
|
1125
|
-
return contract.simulate.
|
|
1442
|
+
return contract.simulate.unblockBot([notbot] as const, options) as Promise<void>;
|
|
1126
1443
|
}
|
|
1127
1444
|
};
|
|
1128
1445
|
}
|
|
@@ -1150,7 +1467,7 @@ export class SDSHD_json {
|
|
|
1150
1467
|
Approval: (callback: (event: { owner: `0x${string}`; spender: `0x${string}`; value: bigint }) => void, filter?: { owner: `0x${string}`; spender: `0x${string}` }) => {
|
|
1151
1468
|
return this.publicClient.watchContractEvent({
|
|
1152
1469
|
address: this.contractAddress,
|
|
1153
|
-
abi:
|
|
1470
|
+
abi: XAI_jsonAbi,
|
|
1154
1471
|
eventName: 'Approval',
|
|
1155
1472
|
args: filter,
|
|
1156
1473
|
onLogs: (logs: any[]) => {
|
|
@@ -1160,6 +1477,25 @@ export class SDSHD_json {
|
|
|
1160
1477
|
},
|
|
1161
1478
|
}) as () => void;
|
|
1162
1479
|
},
|
|
1480
|
+
/**
|
|
1481
|
+
* Watch MaxTxAmountUpdated events
|
|
1482
|
+
* @param callback Function to call when event is emitted
|
|
1483
|
+
* @param filter Optional filter for indexed parameters
|
|
1484
|
+
* @returns Unwatch function to stop listening
|
|
1485
|
+
*/
|
|
1486
|
+
MaxTxAmountUpdated: (callback: (event: { _maxTxAmount: bigint }) => void) => {
|
|
1487
|
+
return this.publicClient.watchContractEvent({
|
|
1488
|
+
address: this.contractAddress,
|
|
1489
|
+
abi: XAI_jsonAbi,
|
|
1490
|
+
eventName: 'MaxTxAmountUpdated',
|
|
1491
|
+
|
|
1492
|
+
onLogs: (logs: any[]) => {
|
|
1493
|
+
logs.forEach((log: any) => {
|
|
1494
|
+
callback(log.args as any);
|
|
1495
|
+
});
|
|
1496
|
+
},
|
|
1497
|
+
}) as () => void;
|
|
1498
|
+
},
|
|
1163
1499
|
/**
|
|
1164
1500
|
* Watch OwnershipTransferred events
|
|
1165
1501
|
* @param callback Function to call when event is emitted
|
|
@@ -1169,7 +1505,7 @@ export class SDSHD_json {
|
|
|
1169
1505
|
OwnershipTransferred: (callback: (event: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => void, filter?: { previousOwner: `0x${string}`; newOwner: `0x${string}` }) => {
|
|
1170
1506
|
return this.publicClient.watchContractEvent({
|
|
1171
1507
|
address: this.contractAddress,
|
|
1172
|
-
abi:
|
|
1508
|
+
abi: XAI_jsonAbi,
|
|
1173
1509
|
eventName: 'OwnershipTransferred',
|
|
1174
1510
|
args: filter,
|
|
1175
1511
|
onLogs: (logs: any[]) => {
|
|
@@ -1188,7 +1524,7 @@ export class SDSHD_json {
|
|
|
1188
1524
|
Transfer: (callback: (event: { from: `0x${string}`; to: `0x${string}`; value: bigint }) => void, filter?: { from: `0x${string}`; to: `0x${string}` }) => {
|
|
1189
1525
|
return this.publicClient.watchContractEvent({
|
|
1190
1526
|
address: this.contractAddress,
|
|
1191
|
-
abi:
|
|
1527
|
+
abi: XAI_jsonAbi,
|
|
1192
1528
|
eventName: 'Transfer',
|
|
1193
1529
|
args: filter,
|
|
1194
1530
|
onLogs: (logs: any[]) => {
|