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