@cofhe/mock-contracts 0.3.2 → 0.5.0

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.
Files changed (20) hide show
  1. package/CHANGELOG.md +28 -0
  2. package/contracts/MockACL.sol +12 -34
  3. package/contracts/MockCoFHE.sol +5 -2
  4. package/contracts/MockTaskManager.sol +25 -1
  5. package/dist/index.d.mts +2173 -244
  6. package/dist/index.d.ts +2173 -244
  7. package/dist/index.js +5 -10
  8. package/dist/index.js.map +1 -1
  9. package/dist/index.mjs +5 -10
  10. package/dist/index.mjs.map +1 -1
  11. package/package.json +15 -15
  12. package/src/MockACL.ts +1 -3
  13. package/src/MockTaskManager.ts +1 -3
  14. package/src/MockThresholdNetwork.ts +1 -3
  15. package/src/MockZkVerifier.ts +1 -3
  16. package/src/TestBed.ts +1 -3
  17. package/src/types.ts +0 -2
  18. package/contracts/foundry/CoFheTest.sol +0 -452
  19. package/contracts/foundry/MockZkVerifierSigner.sol +0 -40
  20. package/test/TestBed.t.sol +0 -71
package/dist/index.d.mts CHANGED
@@ -6,267 +6,2196 @@ type MockArtifact = {
6
6
  } & ({
7
7
  isFixed: true;
8
8
  fixedAddress: string;
9
- deployedBytecode: string;
10
9
  } | {
11
10
  isFixed: false;
12
- bytecode: string;
13
11
  });
14
12
 
15
13
  declare const MockTaskManagerArtifact: {
16
- contractName: string;
17
- isFixed: true;
18
- fixedAddress: string;
19
- abi: ({
20
- type: string;
21
- inputs: never[];
22
- stateMutability: string;
23
- name?: undefined;
24
- outputs?: undefined;
25
- anonymous?: undefined;
26
- } | {
27
- type: string;
28
- name: string;
29
- inputs: ({
30
- name: string;
31
- type: string;
32
- internalType: string;
33
- components: {
34
- name: string;
35
- type: string;
36
- internalType: string;
37
- }[];
38
- } | {
39
- name: string;
40
- type: string;
41
- internalType: string;
42
- components?: undefined;
43
- })[];
44
- outputs: {
45
- name: string;
46
- type: string;
47
- internalType: string;
48
- }[];
49
- stateMutability: string;
50
- anonymous?: undefined;
51
- } | {
52
- type: string;
53
- name: string;
54
- inputs: {
55
- name: string;
56
- type: string;
57
- indexed: boolean;
58
- internalType: string;
59
- }[];
60
- anonymous: boolean;
61
- stateMutability?: undefined;
62
- outputs?: undefined;
63
- } | {
64
- type: string;
65
- name: string;
66
- inputs: {
67
- name: string;
68
- type: string;
69
- internalType: string;
70
- }[];
71
- stateMutability?: undefined;
72
- outputs?: undefined;
73
- anonymous?: undefined;
74
- })[];
75
- deployedBytecode: string;
14
+ readonly contractName: "MockTaskManager";
15
+ readonly isFixed: true;
16
+ readonly fixedAddress: "0xeA30c4B8b44078Bbf8a6ef5b9f1eC1626C7848D9";
17
+ readonly abi: readonly [{
18
+ readonly type: "constructor";
19
+ readonly inputs: readonly [];
20
+ readonly stateMutability: "nonpayable";
21
+ }, {
22
+ readonly type: "function";
23
+ readonly name: "MOCK_logAllow";
24
+ readonly inputs: readonly [{
25
+ readonly name: "operation";
26
+ readonly type: "string";
27
+ readonly internalType: "string";
28
+ }, {
29
+ readonly name: "ctHash";
30
+ readonly type: "uint256";
31
+ readonly internalType: "uint256";
32
+ }, {
33
+ readonly name: "account";
34
+ readonly type: "address";
35
+ readonly internalType: "address";
36
+ }];
37
+ readonly outputs: readonly [];
38
+ readonly stateMutability: "view";
39
+ }, {
40
+ readonly type: "function";
41
+ readonly name: "MOCK_setInEuintKey";
42
+ readonly inputs: readonly [{
43
+ readonly name: "ctHash";
44
+ readonly type: "uint256";
45
+ readonly internalType: "uint256";
46
+ }, {
47
+ readonly name: "value";
48
+ readonly type: "uint256";
49
+ readonly internalType: "uint256";
50
+ }];
51
+ readonly outputs: readonly [];
52
+ readonly stateMutability: "nonpayable";
53
+ }, {
54
+ readonly type: "function";
55
+ readonly name: "acl";
56
+ readonly inputs: readonly [];
57
+ readonly outputs: readonly [{
58
+ readonly name: "";
59
+ readonly type: "address";
60
+ readonly internalType: "contract MockACL";
61
+ }];
62
+ readonly stateMutability: "view";
63
+ }, {
64
+ readonly type: "function";
65
+ readonly name: "aggregator";
66
+ readonly inputs: readonly [];
67
+ readonly outputs: readonly [{
68
+ readonly name: "";
69
+ readonly type: "address";
70
+ readonly internalType: "address";
71
+ }];
72
+ readonly stateMutability: "view";
73
+ }, {
74
+ readonly type: "function";
75
+ readonly name: "allow";
76
+ readonly inputs: readonly [{
77
+ readonly name: "ctHash";
78
+ readonly type: "uint256";
79
+ readonly internalType: "uint256";
80
+ }, {
81
+ readonly name: "account";
82
+ readonly type: "address";
83
+ readonly internalType: "address";
84
+ }];
85
+ readonly outputs: readonly [];
86
+ readonly stateMutability: "nonpayable";
87
+ }, {
88
+ readonly type: "function";
89
+ readonly name: "allowForDecryption";
90
+ readonly inputs: readonly [{
91
+ readonly name: "ctHash";
92
+ readonly type: "uint256";
93
+ readonly internalType: "uint256";
94
+ }];
95
+ readonly outputs: readonly [];
96
+ readonly stateMutability: "nonpayable";
97
+ }, {
98
+ readonly type: "function";
99
+ readonly name: "allowGlobal";
100
+ readonly inputs: readonly [{
101
+ readonly name: "ctHash";
102
+ readonly type: "uint256";
103
+ readonly internalType: "uint256";
104
+ }];
105
+ readonly outputs: readonly [];
106
+ readonly stateMutability: "nonpayable";
107
+ }, {
108
+ readonly type: "function";
109
+ readonly name: "allowTransient";
110
+ readonly inputs: readonly [{
111
+ readonly name: "ctHash";
112
+ readonly type: "uint256";
113
+ readonly internalType: "uint256";
114
+ }, {
115
+ readonly name: "account";
116
+ readonly type: "address";
117
+ readonly internalType: "address";
118
+ }];
119
+ readonly outputs: readonly [];
120
+ readonly stateMutability: "nonpayable";
121
+ }, {
122
+ readonly type: "function";
123
+ readonly name: "createDecryptTask";
124
+ readonly inputs: readonly [{
125
+ readonly name: "ctHash";
126
+ readonly type: "uint256";
127
+ readonly internalType: "uint256";
128
+ }, {
129
+ readonly name: "";
130
+ readonly type: "address";
131
+ readonly internalType: "address";
132
+ }];
133
+ readonly outputs: readonly [];
134
+ readonly stateMutability: "nonpayable";
135
+ }, {
136
+ readonly type: "function";
137
+ readonly name: "createRandomTask";
138
+ readonly inputs: readonly [{
139
+ readonly name: "returnType";
140
+ readonly type: "uint8";
141
+ readonly internalType: "uint8";
142
+ }, {
143
+ readonly name: "seed";
144
+ readonly type: "uint256";
145
+ readonly internalType: "uint256";
146
+ }, {
147
+ readonly name: "securityZone";
148
+ readonly type: "int32";
149
+ readonly internalType: "int32";
150
+ }];
151
+ readonly outputs: readonly [{
152
+ readonly name: "";
153
+ readonly type: "uint256";
154
+ readonly internalType: "uint256";
155
+ }];
156
+ readonly stateMutability: "nonpayable";
157
+ }, {
158
+ readonly type: "function";
159
+ readonly name: "createTask";
160
+ readonly inputs: readonly [{
161
+ readonly name: "returnType";
162
+ readonly type: "uint8";
163
+ readonly internalType: "uint8";
164
+ }, {
165
+ readonly name: "funcId";
166
+ readonly type: "uint8";
167
+ readonly internalType: "enum FunctionId";
168
+ }, {
169
+ readonly name: "encryptedHashes";
170
+ readonly type: "uint256[]";
171
+ readonly internalType: "uint256[]";
172
+ }, {
173
+ readonly name: "extraInputs";
174
+ readonly type: "uint256[]";
175
+ readonly internalType: "uint256[]";
176
+ }];
177
+ readonly outputs: readonly [{
178
+ readonly name: "";
179
+ readonly type: "uint256";
180
+ readonly internalType: "uint256";
181
+ }];
182
+ readonly stateMutability: "nonpayable";
183
+ }, {
184
+ readonly type: "function";
185
+ readonly name: "decryptResultSigner";
186
+ readonly inputs: readonly [];
187
+ readonly outputs: readonly [{
188
+ readonly name: "";
189
+ readonly type: "address";
190
+ readonly internalType: "address";
191
+ }];
192
+ readonly stateMutability: "view";
193
+ }, {
194
+ readonly type: "function";
195
+ readonly name: "exists";
196
+ readonly inputs: readonly [];
197
+ readonly outputs: readonly [{
198
+ readonly name: "";
199
+ readonly type: "bool";
200
+ readonly internalType: "bool";
201
+ }];
202
+ readonly stateMutability: "pure";
203
+ }, {
204
+ readonly type: "function";
205
+ readonly name: "getDecryptResult";
206
+ readonly inputs: readonly [{
207
+ readonly name: "ctHash";
208
+ readonly type: "uint256";
209
+ readonly internalType: "uint256";
210
+ }];
211
+ readonly outputs: readonly [{
212
+ readonly name: "";
213
+ readonly type: "uint256";
214
+ readonly internalType: "uint256";
215
+ }];
216
+ readonly stateMutability: "view";
217
+ }, {
218
+ readonly type: "function";
219
+ readonly name: "getDecryptResultSafe";
220
+ readonly inputs: readonly [{
221
+ readonly name: "ctHash";
222
+ readonly type: "uint256";
223
+ readonly internalType: "uint256";
224
+ }];
225
+ readonly outputs: readonly [{
226
+ readonly name: "result";
227
+ readonly type: "uint256";
228
+ readonly internalType: "uint256";
229
+ }, {
230
+ readonly name: "decrypted";
231
+ readonly type: "bool";
232
+ readonly internalType: "bool";
233
+ }];
234
+ readonly stateMutability: "view";
235
+ }, {
236
+ readonly type: "function";
237
+ readonly name: "handleDecryptResult";
238
+ readonly inputs: readonly [{
239
+ readonly name: "ctHash";
240
+ readonly type: "uint256";
241
+ readonly internalType: "uint256";
242
+ }, {
243
+ readonly name: "result";
244
+ readonly type: "uint256";
245
+ readonly internalType: "uint256";
246
+ }, {
247
+ readonly name: "";
248
+ readonly type: "address[]";
249
+ readonly internalType: "address[]";
250
+ }];
251
+ readonly outputs: readonly [];
252
+ readonly stateMutability: "nonpayable";
253
+ }, {
254
+ readonly type: "function";
255
+ readonly name: "handleError";
256
+ readonly inputs: readonly [{
257
+ readonly name: "ctHash";
258
+ readonly type: "uint256";
259
+ readonly internalType: "uint256";
260
+ }, {
261
+ readonly name: "operation";
262
+ readonly type: "string";
263
+ readonly internalType: "string";
264
+ }, {
265
+ readonly name: "errorMessage";
266
+ readonly type: "string";
267
+ readonly internalType: "string";
268
+ }];
269
+ readonly outputs: readonly [];
270
+ readonly stateMutability: "nonpayable";
271
+ }, {
272
+ readonly type: "function";
273
+ readonly name: "inMockStorage";
274
+ readonly inputs: readonly [{
275
+ readonly name: "";
276
+ readonly type: "uint256";
277
+ readonly internalType: "uint256";
278
+ }];
279
+ readonly outputs: readonly [{
280
+ readonly name: "";
281
+ readonly type: "bool";
282
+ readonly internalType: "bool";
283
+ }];
284
+ readonly stateMutability: "view";
285
+ }, {
286
+ readonly type: "function";
287
+ readonly name: "initialize";
288
+ readonly inputs: readonly [{
289
+ readonly name: "initialOwner";
290
+ readonly type: "address";
291
+ readonly internalType: "address";
292
+ }];
293
+ readonly outputs: readonly [];
294
+ readonly stateMutability: "nonpayable";
295
+ }, {
296
+ readonly type: "function";
297
+ readonly name: "isAllowed";
298
+ readonly inputs: readonly [{
299
+ readonly name: "ctHash";
300
+ readonly type: "uint256";
301
+ readonly internalType: "uint256";
302
+ }, {
303
+ readonly name: "account";
304
+ readonly type: "address";
305
+ readonly internalType: "address";
306
+ }];
307
+ readonly outputs: readonly [{
308
+ readonly name: "";
309
+ readonly type: "bool";
310
+ readonly internalType: "bool";
311
+ }];
312
+ readonly stateMutability: "view";
313
+ }, {
314
+ readonly type: "function";
315
+ readonly name: "isAllowedWithPermission";
316
+ readonly inputs: readonly [{
317
+ readonly name: "permission";
318
+ readonly type: "tuple";
319
+ readonly internalType: "struct Permission";
320
+ readonly components: readonly [{
321
+ readonly name: "issuer";
322
+ readonly type: "address";
323
+ readonly internalType: "address";
324
+ }, {
325
+ readonly name: "expiration";
326
+ readonly type: "uint64";
327
+ readonly internalType: "uint64";
328
+ }, {
329
+ readonly name: "recipient";
330
+ readonly type: "address";
331
+ readonly internalType: "address";
332
+ }, {
333
+ readonly name: "validatorId";
334
+ readonly type: "uint256";
335
+ readonly internalType: "uint256";
336
+ }, {
337
+ readonly name: "validatorContract";
338
+ readonly type: "address";
339
+ readonly internalType: "address";
340
+ }, {
341
+ readonly name: "sealingKey";
342
+ readonly type: "bytes32";
343
+ readonly internalType: "bytes32";
344
+ }, {
345
+ readonly name: "issuerSignature";
346
+ readonly type: "bytes";
347
+ readonly internalType: "bytes";
348
+ }, {
349
+ readonly name: "recipientSignature";
350
+ readonly type: "bytes";
351
+ readonly internalType: "bytes";
352
+ }];
353
+ }, {
354
+ readonly name: "handle";
355
+ readonly type: "uint256";
356
+ readonly internalType: "uint256";
357
+ }];
358
+ readonly outputs: readonly [{
359
+ readonly name: "";
360
+ readonly type: "bool";
361
+ readonly internalType: "bool";
362
+ }];
363
+ readonly stateMutability: "view";
364
+ }, {
365
+ readonly type: "function";
366
+ readonly name: "isInitialized";
367
+ readonly inputs: readonly [];
368
+ readonly outputs: readonly [{
369
+ readonly name: "";
370
+ readonly type: "bool";
371
+ readonly internalType: "bool";
372
+ }];
373
+ readonly stateMutability: "view";
374
+ }, {
375
+ readonly type: "function";
376
+ readonly name: "isPubliclyAllowed";
377
+ readonly inputs: readonly [{
378
+ readonly name: "ctHash";
379
+ readonly type: "uint256";
380
+ readonly internalType: "uint256";
381
+ }];
382
+ readonly outputs: readonly [{
383
+ readonly name: "";
384
+ readonly type: "bool";
385
+ readonly internalType: "bool";
386
+ }];
387
+ readonly stateMutability: "view";
388
+ }, {
389
+ readonly type: "function";
390
+ readonly name: "logOps";
391
+ readonly inputs: readonly [];
392
+ readonly outputs: readonly [{
393
+ readonly name: "";
394
+ readonly type: "bool";
395
+ readonly internalType: "bool";
396
+ }];
397
+ readonly stateMutability: "view";
398
+ }, {
399
+ readonly type: "function";
400
+ readonly name: "mockStorage";
401
+ readonly inputs: readonly [{
402
+ readonly name: "";
403
+ readonly type: "uint256";
404
+ readonly internalType: "uint256";
405
+ }];
406
+ readonly outputs: readonly [{
407
+ readonly name: "";
408
+ readonly type: "uint256";
409
+ readonly internalType: "uint256";
410
+ }];
411
+ readonly stateMutability: "view";
412
+ }, {
413
+ readonly type: "function";
414
+ readonly name: "publishDecryptResult";
415
+ readonly inputs: readonly [{
416
+ readonly name: "ctHash";
417
+ readonly type: "uint256";
418
+ readonly internalType: "uint256";
419
+ }, {
420
+ readonly name: "result";
421
+ readonly type: "uint256";
422
+ readonly internalType: "uint256";
423
+ }, {
424
+ readonly name: "signature";
425
+ readonly type: "bytes";
426
+ readonly internalType: "bytes";
427
+ }];
428
+ readonly outputs: readonly [];
429
+ readonly stateMutability: "nonpayable";
430
+ }, {
431
+ readonly type: "function";
432
+ readonly name: "publishDecryptResultBatch";
433
+ readonly inputs: readonly [{
434
+ readonly name: "ctHashes";
435
+ readonly type: "uint256[]";
436
+ readonly internalType: "uint256[]";
437
+ }, {
438
+ readonly name: "results";
439
+ readonly type: "uint256[]";
440
+ readonly internalType: "uint256[]";
441
+ }, {
442
+ readonly name: "signatures";
443
+ readonly type: "bytes[]";
444
+ readonly internalType: "bytes[]";
445
+ }];
446
+ readonly outputs: readonly [];
447
+ readonly stateMutability: "nonpayable";
448
+ }, {
449
+ readonly type: "function";
450
+ readonly name: "removeFirstLetter";
451
+ readonly inputs: readonly [{
452
+ readonly name: "str";
453
+ readonly type: "string";
454
+ readonly internalType: "string";
455
+ }];
456
+ readonly outputs: readonly [{
457
+ readonly name: "";
458
+ readonly type: "string";
459
+ readonly internalType: "string";
460
+ }];
461
+ readonly stateMutability: "pure";
462
+ }, {
463
+ readonly type: "function";
464
+ readonly name: "setACLContract";
465
+ readonly inputs: readonly [{
466
+ readonly name: "_aclAddress";
467
+ readonly type: "address";
468
+ readonly internalType: "address";
469
+ }];
470
+ readonly outputs: readonly [];
471
+ readonly stateMutability: "nonpayable";
472
+ }, {
473
+ readonly type: "function";
474
+ readonly name: "setAggregator";
475
+ readonly inputs: readonly [{
476
+ readonly name: "_aggregatorAddress";
477
+ readonly type: "address";
478
+ readonly internalType: "address";
479
+ }];
480
+ readonly outputs: readonly [];
481
+ readonly stateMutability: "nonpayable";
482
+ }, {
483
+ readonly type: "function";
484
+ readonly name: "setDecryptResultSigner";
485
+ readonly inputs: readonly [{
486
+ readonly name: "signer";
487
+ readonly type: "address";
488
+ readonly internalType: "address";
489
+ }];
490
+ readonly outputs: readonly [];
491
+ readonly stateMutability: "nonpayable";
492
+ }, {
493
+ readonly type: "function";
494
+ readonly name: "setLogOps";
495
+ readonly inputs: readonly [{
496
+ readonly name: "_logOps";
497
+ readonly type: "bool";
498
+ readonly internalType: "bool";
499
+ }];
500
+ readonly outputs: readonly [];
501
+ readonly stateMutability: "nonpayable";
502
+ }, {
503
+ readonly type: "function";
504
+ readonly name: "setSecurityZoneMax";
505
+ readonly inputs: readonly [{
506
+ readonly name: "securityZone";
507
+ readonly type: "int32";
508
+ readonly internalType: "int32";
509
+ }];
510
+ readonly outputs: readonly [];
511
+ readonly stateMutability: "nonpayable";
512
+ }, {
513
+ readonly type: "function";
514
+ readonly name: "setSecurityZoneMin";
515
+ readonly inputs: readonly [{
516
+ readonly name: "securityZone";
517
+ readonly type: "int32";
518
+ readonly internalType: "int32";
519
+ }];
520
+ readonly outputs: readonly [];
521
+ readonly stateMutability: "nonpayable";
522
+ }, {
523
+ readonly type: "function";
524
+ readonly name: "setSecurityZones";
525
+ readonly inputs: readonly [{
526
+ readonly name: "minSZ";
527
+ readonly type: "int32";
528
+ readonly internalType: "int32";
529
+ }, {
530
+ readonly name: "maxSZ";
531
+ readonly type: "int32";
532
+ readonly internalType: "int32";
533
+ }];
534
+ readonly outputs: readonly [];
535
+ readonly stateMutability: "nonpayable";
536
+ }, {
537
+ readonly type: "function";
538
+ readonly name: "setVerifierSigner";
539
+ readonly inputs: readonly [{
540
+ readonly name: "signer";
541
+ readonly type: "address";
542
+ readonly internalType: "address";
543
+ }];
544
+ readonly outputs: readonly [];
545
+ readonly stateMutability: "nonpayable";
546
+ }, {
547
+ readonly type: "function";
548
+ readonly name: "sliceString";
549
+ readonly inputs: readonly [{
550
+ readonly name: "str";
551
+ readonly type: "string";
552
+ readonly internalType: "string";
553
+ }, {
554
+ readonly name: "start";
555
+ readonly type: "uint256";
556
+ readonly internalType: "uint256";
557
+ }, {
558
+ readonly name: "length";
559
+ readonly type: "uint256";
560
+ readonly internalType: "uint256";
561
+ }];
562
+ readonly outputs: readonly [{
563
+ readonly name: "";
564
+ readonly type: "string";
565
+ readonly internalType: "string";
566
+ }];
567
+ readonly stateMutability: "pure";
568
+ }, {
569
+ readonly type: "function";
570
+ readonly name: "verifyDecryptResult";
571
+ readonly inputs: readonly [{
572
+ readonly name: "ctHash";
573
+ readonly type: "uint256";
574
+ readonly internalType: "uint256";
575
+ }, {
576
+ readonly name: "result";
577
+ readonly type: "uint256";
578
+ readonly internalType: "uint256";
579
+ }, {
580
+ readonly name: "signature";
581
+ readonly type: "bytes";
582
+ readonly internalType: "bytes";
583
+ }];
584
+ readonly outputs: readonly [{
585
+ readonly name: "";
586
+ readonly type: "bool";
587
+ readonly internalType: "bool";
588
+ }];
589
+ readonly stateMutability: "view";
590
+ }, {
591
+ readonly type: "function";
592
+ readonly name: "verifyDecryptResultSafe";
593
+ readonly inputs: readonly [{
594
+ readonly name: "ctHash";
595
+ readonly type: "uint256";
596
+ readonly internalType: "uint256";
597
+ }, {
598
+ readonly name: "result";
599
+ readonly type: "uint256";
600
+ readonly internalType: "uint256";
601
+ }, {
602
+ readonly name: "signature";
603
+ readonly type: "bytes";
604
+ readonly internalType: "bytes";
605
+ }];
606
+ readonly outputs: readonly [{
607
+ readonly name: "";
608
+ readonly type: "bool";
609
+ readonly internalType: "bool";
610
+ }];
611
+ readonly stateMutability: "view";
612
+ }, {
613
+ readonly type: "function";
614
+ readonly name: "verifyInput";
615
+ readonly inputs: readonly [{
616
+ readonly name: "input";
617
+ readonly type: "tuple";
618
+ readonly internalType: "struct EncryptedInput";
619
+ readonly components: readonly [{
620
+ readonly name: "ctHash";
621
+ readonly type: "uint256";
622
+ readonly internalType: "uint256";
623
+ }, {
624
+ readonly name: "securityZone";
625
+ readonly type: "uint8";
626
+ readonly internalType: "uint8";
627
+ }, {
628
+ readonly name: "utype";
629
+ readonly type: "uint8";
630
+ readonly internalType: "uint8";
631
+ }, {
632
+ readonly name: "signature";
633
+ readonly type: "bytes";
634
+ readonly internalType: "bytes";
635
+ }];
636
+ }, {
637
+ readonly name: "sender";
638
+ readonly type: "address";
639
+ readonly internalType: "address";
640
+ }];
641
+ readonly outputs: readonly [{
642
+ readonly name: "";
643
+ readonly type: "uint256";
644
+ readonly internalType: "uint256";
645
+ }];
646
+ readonly stateMutability: "nonpayable";
647
+ }, {
648
+ readonly type: "event";
649
+ readonly name: "DecryptionResult";
650
+ readonly inputs: readonly [{
651
+ readonly name: "ctHash";
652
+ readonly type: "uint256";
653
+ readonly indexed: false;
654
+ readonly internalType: "uint256";
655
+ }, {
656
+ readonly name: "result";
657
+ readonly type: "uint256";
658
+ readonly indexed: false;
659
+ readonly internalType: "uint256";
660
+ }, {
661
+ readonly name: "requestor";
662
+ readonly type: "address";
663
+ readonly indexed: true;
664
+ readonly internalType: "address";
665
+ }];
666
+ readonly anonymous: false;
667
+ }, {
668
+ readonly type: "event";
669
+ readonly name: "ProtocolNotification";
670
+ readonly inputs: readonly [{
671
+ readonly name: "ctHash";
672
+ readonly type: "uint256";
673
+ readonly indexed: false;
674
+ readonly internalType: "uint256";
675
+ }, {
676
+ readonly name: "operation";
677
+ readonly type: "string";
678
+ readonly indexed: false;
679
+ readonly internalType: "string";
680
+ }, {
681
+ readonly name: "errorMessage";
682
+ readonly type: "string";
683
+ readonly indexed: false;
684
+ readonly internalType: "string";
685
+ }];
686
+ readonly anonymous: false;
687
+ }, {
688
+ readonly type: "event";
689
+ readonly name: "TaskCreated";
690
+ readonly inputs: readonly [{
691
+ readonly name: "ctHash";
692
+ readonly type: "uint256";
693
+ readonly indexed: false;
694
+ readonly internalType: "uint256";
695
+ }, {
696
+ readonly name: "operation";
697
+ readonly type: "string";
698
+ readonly indexed: false;
699
+ readonly internalType: "string";
700
+ }, {
701
+ readonly name: "input1";
702
+ readonly type: "uint256";
703
+ readonly indexed: false;
704
+ readonly internalType: "uint256";
705
+ }, {
706
+ readonly name: "input2";
707
+ readonly type: "uint256";
708
+ readonly indexed: false;
709
+ readonly internalType: "uint256";
710
+ }, {
711
+ readonly name: "input3";
712
+ readonly type: "uint256";
713
+ readonly indexed: false;
714
+ readonly internalType: "uint256";
715
+ }];
716
+ readonly anonymous: false;
717
+ }, {
718
+ readonly type: "error";
719
+ readonly name: "ACLNotAllowed";
720
+ readonly inputs: readonly [{
721
+ readonly name: "handle";
722
+ readonly type: "uint256";
723
+ readonly internalType: "uint256";
724
+ }, {
725
+ readonly name: "account";
726
+ readonly type: "address";
727
+ readonly internalType: "address";
728
+ }];
729
+ }, {
730
+ readonly type: "error";
731
+ readonly name: "DecryptionResultNotReady";
732
+ readonly inputs: readonly [{
733
+ readonly name: "ctHash";
734
+ readonly type: "uint256";
735
+ readonly internalType: "uint256";
736
+ }];
737
+ }, {
738
+ readonly type: "error";
739
+ readonly name: "ECDSAInvalidSignature";
740
+ readonly inputs: readonly [];
741
+ }, {
742
+ readonly type: "error";
743
+ readonly name: "ECDSAInvalidSignatureLength";
744
+ readonly inputs: readonly [{
745
+ readonly name: "length";
746
+ readonly type: "uint256";
747
+ readonly internalType: "uint256";
748
+ }];
749
+ }, {
750
+ readonly type: "error";
751
+ readonly name: "ECDSAInvalidSignatureS";
752
+ readonly inputs: readonly [{
753
+ readonly name: "s";
754
+ readonly type: "bytes32";
755
+ readonly internalType: "bytes32";
756
+ }];
757
+ }, {
758
+ readonly type: "error";
759
+ readonly name: "InputNotInMockStorage";
760
+ readonly inputs: readonly [{
761
+ readonly name: "ctHash";
762
+ readonly type: "uint256";
763
+ readonly internalType: "uint256";
764
+ }];
765
+ }, {
766
+ readonly type: "error";
767
+ readonly name: "InvalidAddress";
768
+ readonly inputs: readonly [];
769
+ }, {
770
+ readonly type: "error";
771
+ readonly name: "InvalidInputForFunction";
772
+ readonly inputs: readonly [{
773
+ readonly name: "functionName";
774
+ readonly type: "string";
775
+ readonly internalType: "string";
776
+ }, {
777
+ readonly name: "inputType";
778
+ readonly type: "uint8";
779
+ readonly internalType: "uint8";
780
+ }];
781
+ }, {
782
+ readonly type: "error";
783
+ readonly name: "InvalidInputType";
784
+ readonly inputs: readonly [{
785
+ readonly name: "actual";
786
+ readonly type: "uint8";
787
+ readonly internalType: "uint8";
788
+ }, {
789
+ readonly name: "expected";
790
+ readonly type: "uint8";
791
+ readonly internalType: "uint8";
792
+ }];
793
+ }, {
794
+ readonly type: "error";
795
+ readonly name: "InvalidInputsAmount";
796
+ readonly inputs: readonly [{
797
+ readonly name: "operation";
798
+ readonly type: "string";
799
+ readonly internalType: "string";
800
+ }, {
801
+ readonly name: "got";
802
+ readonly type: "uint256";
803
+ readonly internalType: "uint256";
804
+ }, {
805
+ readonly name: "expected";
806
+ readonly type: "uint256";
807
+ readonly internalType: "uint256";
808
+ }];
809
+ }, {
810
+ readonly type: "error";
811
+ readonly name: "InvalidOperationInputs";
812
+ readonly inputs: readonly [{
813
+ readonly name: "operation";
814
+ readonly type: "string";
815
+ readonly internalType: "string";
816
+ }];
817
+ }, {
818
+ readonly type: "error";
819
+ readonly name: "InvalidSecurityZone";
820
+ readonly inputs: readonly [{
821
+ readonly name: "zone";
822
+ readonly type: "int32";
823
+ readonly internalType: "int32";
824
+ }, {
825
+ readonly name: "min";
826
+ readonly type: "int32";
827
+ readonly internalType: "int32";
828
+ }, {
829
+ readonly name: "max";
830
+ readonly type: "int32";
831
+ readonly internalType: "int32";
832
+ }];
833
+ }, {
834
+ readonly type: "error";
835
+ readonly name: "InvalidSignature";
836
+ readonly inputs: readonly [];
837
+ }, {
838
+ readonly type: "error";
839
+ readonly name: "InvalidSigner";
840
+ readonly inputs: readonly [{
841
+ readonly name: "signer";
842
+ readonly type: "address";
843
+ readonly internalType: "address";
844
+ }, {
845
+ readonly name: "expectedSigner";
846
+ readonly type: "address";
847
+ readonly internalType: "address";
848
+ }];
849
+ }, {
850
+ readonly type: "error";
851
+ readonly name: "InvalidThreeInputOperation";
852
+ readonly inputs: readonly [{
853
+ readonly name: "operation";
854
+ readonly type: "string";
855
+ readonly internalType: "string";
856
+ }];
857
+ }, {
858
+ readonly type: "error";
859
+ readonly name: "InvalidTwoInputOperation";
860
+ readonly inputs: readonly [{
861
+ readonly name: "operation";
862
+ readonly type: "string";
863
+ readonly internalType: "string";
864
+ }];
865
+ }, {
866
+ readonly type: "error";
867
+ readonly name: "InvalidTypeOrSecurityZone";
868
+ readonly inputs: readonly [{
869
+ readonly name: "operation";
870
+ readonly type: "string";
871
+ readonly internalType: "string";
872
+ }];
873
+ }, {
874
+ readonly type: "error";
875
+ readonly name: "InvalidUnaryOperation";
876
+ readonly inputs: readonly [{
877
+ readonly name: "operation";
878
+ readonly type: "string";
879
+ readonly internalType: "string";
880
+ }];
881
+ }, {
882
+ readonly type: "error";
883
+ readonly name: "NotImplemented";
884
+ readonly inputs: readonly [];
885
+ }, {
886
+ readonly type: "error";
887
+ readonly name: "OnlyAggregatorAllowed";
888
+ readonly inputs: readonly [{
889
+ readonly name: "caller";
890
+ readonly type: "address";
891
+ readonly internalType: "address";
892
+ }];
893
+ }, {
894
+ readonly type: "error";
895
+ readonly name: "OnlyOwnerAllowed";
896
+ readonly inputs: readonly [{
897
+ readonly name: "caller";
898
+ readonly type: "address";
899
+ readonly internalType: "address";
900
+ }];
901
+ }, {
902
+ readonly type: "error";
903
+ readonly name: "RandomFunctionNotSupported";
904
+ readonly inputs: readonly [];
905
+ }, {
906
+ readonly type: "error";
907
+ readonly name: "StringsInsufficientHexLength";
908
+ readonly inputs: readonly [{
909
+ readonly name: "value";
910
+ readonly type: "uint256";
911
+ readonly internalType: "uint256";
912
+ }, {
913
+ readonly name: "length";
914
+ readonly type: "uint256";
915
+ readonly internalType: "uint256";
916
+ }];
917
+ }, {
918
+ readonly type: "error";
919
+ readonly name: "TooManyInputs";
920
+ readonly inputs: readonly [{
921
+ readonly name: "operation";
922
+ readonly type: "string";
923
+ readonly internalType: "string";
924
+ }, {
925
+ readonly name: "got";
926
+ readonly type: "uint256";
927
+ readonly internalType: "uint256";
928
+ }, {
929
+ readonly name: "maxAllowed";
930
+ readonly type: "uint256";
931
+ readonly internalType: "uint256";
932
+ }];
933
+ }];
76
934
  };
77
935
 
78
936
  declare const MockACLArtifact: {
79
- contractName: string;
80
- isFixed: false;
81
- abi: ({
82
- type: string;
83
- inputs: never[];
84
- stateMutability: string;
85
- name?: undefined;
86
- outputs?: undefined;
87
- anonymous?: undefined;
88
- } | {
89
- type: string;
90
- name: string;
91
- inputs: ({
92
- name: string;
93
- type: string;
94
- internalType: string;
95
- components: {
96
- name: string;
97
- type: string;
98
- internalType: string;
99
- }[];
100
- } | {
101
- name: string;
102
- type: string;
103
- internalType: string;
104
- components?: undefined;
105
- })[];
106
- outputs: {
107
- name: string;
108
- type: string;
109
- internalType: string;
110
- }[];
111
- stateMutability: string;
112
- anonymous?: undefined;
113
- } | {
114
- type: string;
115
- name: string;
116
- inputs: {
117
- name: string;
118
- type: string;
119
- indexed: boolean;
120
- internalType: string;
121
- }[];
122
- anonymous: boolean;
123
- stateMutability?: undefined;
124
- outputs?: undefined;
125
- } | {
126
- type: string;
127
- name: string;
128
- inputs: {
129
- name: string;
130
- type: string;
131
- internalType: string;
132
- }[];
133
- stateMutability?: undefined;
134
- outputs?: undefined;
135
- anonymous?: undefined;
136
- })[];
137
- bytecode: string;
937
+ readonly contractName: "MockACL";
938
+ readonly isFixed: false;
939
+ readonly abi: readonly [{
940
+ readonly type: "constructor";
941
+ readonly inputs: readonly [];
942
+ readonly stateMutability: "nonpayable";
943
+ }, {
944
+ readonly type: "function";
945
+ readonly name: "TASK_MANAGER_ADDRESS_";
946
+ readonly inputs: readonly [];
947
+ readonly outputs: readonly [{
948
+ readonly name: "";
949
+ readonly type: "address";
950
+ readonly internalType: "address";
951
+ }];
952
+ readonly stateMutability: "view";
953
+ }, {
954
+ readonly type: "function";
955
+ readonly name: "allow";
956
+ readonly inputs: readonly [{
957
+ readonly name: "handle";
958
+ readonly type: "uint256";
959
+ readonly internalType: "uint256";
960
+ }, {
961
+ readonly name: "account";
962
+ readonly type: "address";
963
+ readonly internalType: "address";
964
+ }, {
965
+ readonly name: "requester";
966
+ readonly type: "address";
967
+ readonly internalType: "address";
968
+ }];
969
+ readonly outputs: readonly [];
970
+ readonly stateMutability: "nonpayable";
971
+ }, {
972
+ readonly type: "function";
973
+ readonly name: "allowForDecryption";
974
+ readonly inputs: readonly [{
975
+ readonly name: "handlesList";
976
+ readonly type: "uint256[]";
977
+ readonly internalType: "uint256[]";
978
+ }, {
979
+ readonly name: "requester";
980
+ readonly type: "address";
981
+ readonly internalType: "address";
982
+ }];
983
+ readonly outputs: readonly [];
984
+ readonly stateMutability: "nonpayable";
985
+ }, {
986
+ readonly type: "function";
987
+ readonly name: "allowGlobal";
988
+ readonly inputs: readonly [{
989
+ readonly name: "handle";
990
+ readonly type: "uint256";
991
+ readonly internalType: "uint256";
992
+ }, {
993
+ readonly name: "requester";
994
+ readonly type: "address";
995
+ readonly internalType: "address";
996
+ }];
997
+ readonly outputs: readonly [];
998
+ readonly stateMutability: "nonpayable";
999
+ }, {
1000
+ readonly type: "function";
1001
+ readonly name: "allowTransient";
1002
+ readonly inputs: readonly [{
1003
+ readonly name: "handle";
1004
+ readonly type: "uint256";
1005
+ readonly internalType: "uint256";
1006
+ }, {
1007
+ readonly name: "account";
1008
+ readonly type: "address";
1009
+ readonly internalType: "address";
1010
+ }, {
1011
+ readonly name: "requester";
1012
+ readonly type: "address";
1013
+ readonly internalType: "address";
1014
+ }];
1015
+ readonly outputs: readonly [];
1016
+ readonly stateMutability: "nonpayable";
1017
+ }, {
1018
+ readonly type: "function";
1019
+ readonly name: "allowedOnBehalf";
1020
+ readonly inputs: readonly [{
1021
+ readonly name: "delegatee";
1022
+ readonly type: "address";
1023
+ readonly internalType: "address";
1024
+ }, {
1025
+ readonly name: "handle";
1026
+ readonly type: "uint256";
1027
+ readonly internalType: "uint256";
1028
+ }, {
1029
+ readonly name: "contractAddress";
1030
+ readonly type: "address";
1031
+ readonly internalType: "address";
1032
+ }, {
1033
+ readonly name: "account";
1034
+ readonly type: "address";
1035
+ readonly internalType: "address";
1036
+ }];
1037
+ readonly outputs: readonly [{
1038
+ readonly name: "";
1039
+ readonly type: "bool";
1040
+ readonly internalType: "bool";
1041
+ }];
1042
+ readonly stateMutability: "view";
1043
+ }, {
1044
+ readonly type: "function";
1045
+ readonly name: "allowedTransient";
1046
+ readonly inputs: readonly [{
1047
+ readonly name: "handle";
1048
+ readonly type: "uint256";
1049
+ readonly internalType: "uint256";
1050
+ }, {
1051
+ readonly name: "account";
1052
+ readonly type: "address";
1053
+ readonly internalType: "address";
1054
+ }];
1055
+ readonly outputs: readonly [{
1056
+ readonly name: "";
1057
+ readonly type: "bool";
1058
+ readonly internalType: "bool";
1059
+ }];
1060
+ readonly stateMutability: "view";
1061
+ }, {
1062
+ readonly type: "function";
1063
+ readonly name: "checkPermitValidity";
1064
+ readonly inputs: readonly [{
1065
+ readonly name: "permission";
1066
+ readonly type: "tuple";
1067
+ readonly internalType: "struct Permission";
1068
+ readonly components: readonly [{
1069
+ readonly name: "issuer";
1070
+ readonly type: "address";
1071
+ readonly internalType: "address";
1072
+ }, {
1073
+ readonly name: "expiration";
1074
+ readonly type: "uint64";
1075
+ readonly internalType: "uint64";
1076
+ }, {
1077
+ readonly name: "recipient";
1078
+ readonly type: "address";
1079
+ readonly internalType: "address";
1080
+ }, {
1081
+ readonly name: "validatorId";
1082
+ readonly type: "uint256";
1083
+ readonly internalType: "uint256";
1084
+ }, {
1085
+ readonly name: "validatorContract";
1086
+ readonly type: "address";
1087
+ readonly internalType: "address";
1088
+ }, {
1089
+ readonly name: "sealingKey";
1090
+ readonly type: "bytes32";
1091
+ readonly internalType: "bytes32";
1092
+ }, {
1093
+ readonly name: "issuerSignature";
1094
+ readonly type: "bytes";
1095
+ readonly internalType: "bytes";
1096
+ }, {
1097
+ readonly name: "recipientSignature";
1098
+ readonly type: "bytes";
1099
+ readonly internalType: "bytes";
1100
+ }];
1101
+ }];
1102
+ readonly outputs: readonly [{
1103
+ readonly name: "";
1104
+ readonly type: "bool";
1105
+ readonly internalType: "bool";
1106
+ }];
1107
+ readonly stateMutability: "view";
1108
+ }, {
1109
+ readonly type: "function";
1110
+ readonly name: "cleanTransientStorage";
1111
+ readonly inputs: readonly [];
1112
+ readonly outputs: readonly [];
1113
+ readonly stateMutability: "nonpayable";
1114
+ }, {
1115
+ readonly type: "function";
1116
+ readonly name: "delegateAccount";
1117
+ readonly inputs: readonly [{
1118
+ readonly name: "delegatee";
1119
+ readonly type: "address";
1120
+ readonly internalType: "address";
1121
+ }, {
1122
+ readonly name: "delegateeContract";
1123
+ readonly type: "address";
1124
+ readonly internalType: "address";
1125
+ }];
1126
+ readonly outputs: readonly [];
1127
+ readonly stateMutability: "nonpayable";
1128
+ }, {
1129
+ readonly type: "function";
1130
+ readonly name: "eip712Domain";
1131
+ readonly inputs: readonly [];
1132
+ readonly outputs: readonly [{
1133
+ readonly name: "fields";
1134
+ readonly type: "bytes1";
1135
+ readonly internalType: "bytes1";
1136
+ }, {
1137
+ readonly name: "name";
1138
+ readonly type: "string";
1139
+ readonly internalType: "string";
1140
+ }, {
1141
+ readonly name: "version";
1142
+ readonly type: "string";
1143
+ readonly internalType: "string";
1144
+ }, {
1145
+ readonly name: "chainId";
1146
+ readonly type: "uint256";
1147
+ readonly internalType: "uint256";
1148
+ }, {
1149
+ readonly name: "verifyingContract";
1150
+ readonly type: "address";
1151
+ readonly internalType: "address";
1152
+ }, {
1153
+ readonly name: "salt";
1154
+ readonly type: "bytes32";
1155
+ readonly internalType: "bytes32";
1156
+ }, {
1157
+ readonly name: "extensions";
1158
+ readonly type: "uint256[]";
1159
+ readonly internalType: "uint256[]";
1160
+ }];
1161
+ readonly stateMutability: "view";
1162
+ }, {
1163
+ readonly type: "function";
1164
+ readonly name: "exists";
1165
+ readonly inputs: readonly [];
1166
+ readonly outputs: readonly [{
1167
+ readonly name: "";
1168
+ readonly type: "bool";
1169
+ readonly internalType: "bool";
1170
+ }];
1171
+ readonly stateMutability: "pure";
1172
+ }, {
1173
+ readonly type: "function";
1174
+ readonly name: "getTaskManagerAddress";
1175
+ readonly inputs: readonly [];
1176
+ readonly outputs: readonly [{
1177
+ readonly name: "";
1178
+ readonly type: "address";
1179
+ readonly internalType: "address";
1180
+ }];
1181
+ readonly stateMutability: "view";
1182
+ }, {
1183
+ readonly type: "function";
1184
+ readonly name: "getVersion";
1185
+ readonly inputs: readonly [];
1186
+ readonly outputs: readonly [{
1187
+ readonly name: "";
1188
+ readonly type: "string";
1189
+ readonly internalType: "string";
1190
+ }];
1191
+ readonly stateMutability: "pure";
1192
+ }, {
1193
+ readonly type: "function";
1194
+ readonly name: "globalAllowed";
1195
+ readonly inputs: readonly [{
1196
+ readonly name: "handle";
1197
+ readonly type: "uint256";
1198
+ readonly internalType: "uint256";
1199
+ }];
1200
+ readonly outputs: readonly [{
1201
+ readonly name: "";
1202
+ readonly type: "bool";
1203
+ readonly internalType: "bool";
1204
+ }];
1205
+ readonly stateMutability: "view";
1206
+ }, {
1207
+ readonly type: "function";
1208
+ readonly name: "hashTypedDataV4";
1209
+ readonly inputs: readonly [{
1210
+ readonly name: "structHash";
1211
+ readonly type: "bytes32";
1212
+ readonly internalType: "bytes32";
1213
+ }];
1214
+ readonly outputs: readonly [{
1215
+ readonly name: "";
1216
+ readonly type: "bytes32";
1217
+ readonly internalType: "bytes32";
1218
+ }];
1219
+ readonly stateMutability: "view";
1220
+ }, {
1221
+ readonly type: "function";
1222
+ readonly name: "isAllowed";
1223
+ readonly inputs: readonly [{
1224
+ readonly name: "handle";
1225
+ readonly type: "uint256";
1226
+ readonly internalType: "uint256";
1227
+ }, {
1228
+ readonly name: "account";
1229
+ readonly type: "address";
1230
+ readonly internalType: "address";
1231
+ }];
1232
+ readonly outputs: readonly [{
1233
+ readonly name: "";
1234
+ readonly type: "bool";
1235
+ readonly internalType: "bool";
1236
+ }];
1237
+ readonly stateMutability: "view";
1238
+ }, {
1239
+ readonly type: "function";
1240
+ readonly name: "isAllowedForDecryption";
1241
+ readonly inputs: readonly [{
1242
+ readonly name: "handle";
1243
+ readonly type: "uint256";
1244
+ readonly internalType: "uint256";
1245
+ }];
1246
+ readonly outputs: readonly [{
1247
+ readonly name: "";
1248
+ readonly type: "bool";
1249
+ readonly internalType: "bool";
1250
+ }];
1251
+ readonly stateMutability: "view";
1252
+ }, {
1253
+ readonly type: "function";
1254
+ readonly name: "isAllowedWithPermission";
1255
+ readonly inputs: readonly [{
1256
+ readonly name: "permission";
1257
+ readonly type: "tuple";
1258
+ readonly internalType: "struct Permission";
1259
+ readonly components: readonly [{
1260
+ readonly name: "issuer";
1261
+ readonly type: "address";
1262
+ readonly internalType: "address";
1263
+ }, {
1264
+ readonly name: "expiration";
1265
+ readonly type: "uint64";
1266
+ readonly internalType: "uint64";
1267
+ }, {
1268
+ readonly name: "recipient";
1269
+ readonly type: "address";
1270
+ readonly internalType: "address";
1271
+ }, {
1272
+ readonly name: "validatorId";
1273
+ readonly type: "uint256";
1274
+ readonly internalType: "uint256";
1275
+ }, {
1276
+ readonly name: "validatorContract";
1277
+ readonly type: "address";
1278
+ readonly internalType: "address";
1279
+ }, {
1280
+ readonly name: "sealingKey";
1281
+ readonly type: "bytes32";
1282
+ readonly internalType: "bytes32";
1283
+ }, {
1284
+ readonly name: "issuerSignature";
1285
+ readonly type: "bytes";
1286
+ readonly internalType: "bytes";
1287
+ }, {
1288
+ readonly name: "recipientSignature";
1289
+ readonly type: "bytes";
1290
+ readonly internalType: "bytes";
1291
+ }];
1292
+ }, {
1293
+ readonly name: "handle";
1294
+ readonly type: "uint256";
1295
+ readonly internalType: "uint256";
1296
+ }];
1297
+ readonly outputs: readonly [{
1298
+ readonly name: "";
1299
+ readonly type: "bool";
1300
+ readonly internalType: "bool";
1301
+ }];
1302
+ readonly stateMutability: "view";
1303
+ }, {
1304
+ readonly type: "function";
1305
+ readonly name: "persistAllowed";
1306
+ readonly inputs: readonly [{
1307
+ readonly name: "handle";
1308
+ readonly type: "uint256";
1309
+ readonly internalType: "uint256";
1310
+ }, {
1311
+ readonly name: "account";
1312
+ readonly type: "address";
1313
+ readonly internalType: "address";
1314
+ }];
1315
+ readonly outputs: readonly [{
1316
+ readonly name: "";
1317
+ readonly type: "bool";
1318
+ readonly internalType: "bool";
1319
+ }];
1320
+ readonly stateMutability: "view";
1321
+ }, {
1322
+ readonly type: "event";
1323
+ readonly name: "AllowedForDecryption";
1324
+ readonly inputs: readonly [{
1325
+ readonly name: "handlesList";
1326
+ readonly type: "uint256[]";
1327
+ readonly indexed: false;
1328
+ readonly internalType: "uint256[]";
1329
+ }];
1330
+ readonly anonymous: false;
1331
+ }, {
1332
+ readonly type: "event";
1333
+ readonly name: "EIP712DomainChanged";
1334
+ readonly inputs: readonly [];
1335
+ readonly anonymous: false;
1336
+ }, {
1337
+ readonly type: "event";
1338
+ readonly name: "NewDelegation";
1339
+ readonly inputs: readonly [{
1340
+ readonly name: "sender";
1341
+ readonly type: "address";
1342
+ readonly indexed: true;
1343
+ readonly internalType: "address";
1344
+ }, {
1345
+ readonly name: "delegatee";
1346
+ readonly type: "address";
1347
+ readonly indexed: true;
1348
+ readonly internalType: "address";
1349
+ }, {
1350
+ readonly name: "contractAddress";
1351
+ readonly type: "address";
1352
+ readonly indexed: true;
1353
+ readonly internalType: "address";
1354
+ }];
1355
+ readonly anonymous: false;
1356
+ }, {
1357
+ readonly type: "error";
1358
+ readonly name: "AlreadyDelegated";
1359
+ readonly inputs: readonly [];
1360
+ }, {
1361
+ readonly type: "error";
1362
+ readonly name: "DirectAllowForbidden";
1363
+ readonly inputs: readonly [{
1364
+ readonly name: "sender";
1365
+ readonly type: "address";
1366
+ readonly internalType: "address";
1367
+ }];
1368
+ }, {
1369
+ readonly type: "error";
1370
+ readonly name: "InvalidShortString";
1371
+ readonly inputs: readonly [];
1372
+ }, {
1373
+ readonly type: "error";
1374
+ readonly name: "PermissionInvalid_Disabled";
1375
+ readonly inputs: readonly [];
1376
+ }, {
1377
+ readonly type: "error";
1378
+ readonly name: "PermissionInvalid_Expired";
1379
+ readonly inputs: readonly [];
1380
+ }, {
1381
+ readonly type: "error";
1382
+ readonly name: "PermissionInvalid_IssuerSignature";
1383
+ readonly inputs: readonly [];
1384
+ }, {
1385
+ readonly type: "error";
1386
+ readonly name: "PermissionInvalid_RecipientSignature";
1387
+ readonly inputs: readonly [];
1388
+ }, {
1389
+ readonly type: "error";
1390
+ readonly name: "SenderCannotBeDelegateeAddress";
1391
+ readonly inputs: readonly [];
1392
+ }, {
1393
+ readonly type: "error";
1394
+ readonly name: "SenderNotAllowed";
1395
+ readonly inputs: readonly [{
1396
+ readonly name: "sender";
1397
+ readonly type: "address";
1398
+ readonly internalType: "address";
1399
+ }];
1400
+ }, {
1401
+ readonly type: "error";
1402
+ readonly name: "StringTooLong";
1403
+ readonly inputs: readonly [{
1404
+ readonly name: "str";
1405
+ readonly type: "string";
1406
+ readonly internalType: "string";
1407
+ }];
1408
+ }];
138
1409
  };
139
1410
 
140
1411
  declare const MockZkVerifierArtifact: {
141
- contractName: string;
142
- isFixed: true;
143
- fixedAddress: string;
144
- abi: ({
145
- type: string;
146
- name: string;
147
- inputs: {
148
- name: string;
149
- type: string;
150
- internalType: string;
151
- }[];
152
- outputs: {
153
- name: string;
154
- type: string;
155
- internalType: string;
156
- components: {
157
- name: string;
158
- type: string;
159
- internalType: string;
160
- }[];
161
- }[];
162
- stateMutability: string;
163
- } | {
164
- type: string;
165
- name: string;
166
- inputs: {
167
- name: string;
168
- type: string;
169
- internalType: string;
170
- }[];
171
- outputs: {
172
- name: string;
173
- type: string;
174
- internalType: string;
175
- }[];
176
- stateMutability: string;
177
- } | {
178
- type: string;
179
- name: string;
180
- inputs: never[];
181
- outputs?: undefined;
182
- stateMutability?: undefined;
183
- })[];
184
- deployedBytecode: string;
1412
+ readonly contractName: "MockZkVerifier";
1413
+ readonly isFixed: true;
1414
+ readonly fixedAddress: "0x0000000000000000000000000000000000005001";
1415
+ readonly abi: readonly [{
1416
+ readonly type: "function";
1417
+ readonly name: "exists";
1418
+ readonly inputs: readonly [];
1419
+ readonly outputs: readonly [{
1420
+ readonly name: "";
1421
+ readonly type: "bool";
1422
+ readonly internalType: "bool";
1423
+ }];
1424
+ readonly stateMutability: "pure";
1425
+ }, {
1426
+ readonly type: "function";
1427
+ readonly name: "insertCtHash";
1428
+ readonly inputs: readonly [{
1429
+ readonly name: "ctHash";
1430
+ readonly type: "uint256";
1431
+ readonly internalType: "uint256";
1432
+ }, {
1433
+ readonly name: "value";
1434
+ readonly type: "uint256";
1435
+ readonly internalType: "uint256";
1436
+ }];
1437
+ readonly outputs: readonly [];
1438
+ readonly stateMutability: "nonpayable";
1439
+ }, {
1440
+ readonly type: "function";
1441
+ readonly name: "insertPackedCtHashes";
1442
+ readonly inputs: readonly [{
1443
+ readonly name: "ctHashes";
1444
+ readonly type: "uint256[]";
1445
+ readonly internalType: "uint256[]";
1446
+ }, {
1447
+ readonly name: "values";
1448
+ readonly type: "uint256[]";
1449
+ readonly internalType: "uint256[]";
1450
+ }];
1451
+ readonly outputs: readonly [];
1452
+ readonly stateMutability: "nonpayable";
1453
+ }, {
1454
+ readonly type: "function";
1455
+ readonly name: "zkVerify";
1456
+ readonly inputs: readonly [{
1457
+ readonly name: "value";
1458
+ readonly type: "uint256";
1459
+ readonly internalType: "uint256";
1460
+ }, {
1461
+ readonly name: "utype";
1462
+ readonly type: "uint8";
1463
+ readonly internalType: "uint8";
1464
+ }, {
1465
+ readonly name: "user";
1466
+ readonly type: "address";
1467
+ readonly internalType: "address";
1468
+ }, {
1469
+ readonly name: "securityZone";
1470
+ readonly type: "uint8";
1471
+ readonly internalType: "uint8";
1472
+ }, {
1473
+ readonly name: "";
1474
+ readonly type: "uint256";
1475
+ readonly internalType: "uint256";
1476
+ }];
1477
+ readonly outputs: readonly [{
1478
+ readonly name: "";
1479
+ readonly type: "tuple";
1480
+ readonly internalType: "struct EncryptedInput";
1481
+ readonly components: readonly [{
1482
+ readonly name: "ctHash";
1483
+ readonly type: "uint256";
1484
+ readonly internalType: "uint256";
1485
+ }, {
1486
+ readonly name: "securityZone";
1487
+ readonly type: "uint8";
1488
+ readonly internalType: "uint8";
1489
+ }, {
1490
+ readonly name: "utype";
1491
+ readonly type: "uint8";
1492
+ readonly internalType: "uint8";
1493
+ }, {
1494
+ readonly name: "signature";
1495
+ readonly type: "bytes";
1496
+ readonly internalType: "bytes";
1497
+ }];
1498
+ }];
1499
+ readonly stateMutability: "nonpayable";
1500
+ }, {
1501
+ readonly type: "function";
1502
+ readonly name: "zkVerifyCalcCtHash";
1503
+ readonly inputs: readonly [{
1504
+ readonly name: "value";
1505
+ readonly type: "uint256";
1506
+ readonly internalType: "uint256";
1507
+ }, {
1508
+ readonly name: "utype";
1509
+ readonly type: "uint8";
1510
+ readonly internalType: "uint8";
1511
+ }, {
1512
+ readonly name: "user";
1513
+ readonly type: "address";
1514
+ readonly internalType: "address";
1515
+ }, {
1516
+ readonly name: "securityZone";
1517
+ readonly type: "uint8";
1518
+ readonly internalType: "uint8";
1519
+ }, {
1520
+ readonly name: "";
1521
+ readonly type: "uint256";
1522
+ readonly internalType: "uint256";
1523
+ }];
1524
+ readonly outputs: readonly [{
1525
+ readonly name: "ctHash";
1526
+ readonly type: "uint256";
1527
+ readonly internalType: "uint256";
1528
+ }];
1529
+ readonly stateMutability: "view";
1530
+ }, {
1531
+ readonly type: "function";
1532
+ readonly name: "zkVerifyCalcCtHashesPacked";
1533
+ readonly inputs: readonly [{
1534
+ readonly name: "values";
1535
+ readonly type: "uint256[]";
1536
+ readonly internalType: "uint256[]";
1537
+ }, {
1538
+ readonly name: "utypes";
1539
+ readonly type: "uint8[]";
1540
+ readonly internalType: "uint8[]";
1541
+ }, {
1542
+ readonly name: "user";
1543
+ readonly type: "address";
1544
+ readonly internalType: "address";
1545
+ }, {
1546
+ readonly name: "securityZone";
1547
+ readonly type: "uint8";
1548
+ readonly internalType: "uint8";
1549
+ }, {
1550
+ readonly name: "chainId";
1551
+ readonly type: "uint256";
1552
+ readonly internalType: "uint256";
1553
+ }];
1554
+ readonly outputs: readonly [{
1555
+ readonly name: "ctHashes";
1556
+ readonly type: "uint256[]";
1557
+ readonly internalType: "uint256[]";
1558
+ }];
1559
+ readonly stateMutability: "view";
1560
+ }, {
1561
+ readonly type: "function";
1562
+ readonly name: "zkVerifyPacked";
1563
+ readonly inputs: readonly [{
1564
+ readonly name: "values";
1565
+ readonly type: "uint256[]";
1566
+ readonly internalType: "uint256[]";
1567
+ }, {
1568
+ readonly name: "utypes";
1569
+ readonly type: "uint8[]";
1570
+ readonly internalType: "uint8[]";
1571
+ }, {
1572
+ readonly name: "user";
1573
+ readonly type: "address";
1574
+ readonly internalType: "address";
1575
+ }, {
1576
+ readonly name: "securityZone";
1577
+ readonly type: "uint8";
1578
+ readonly internalType: "uint8";
1579
+ }, {
1580
+ readonly name: "chainId";
1581
+ readonly type: "uint256";
1582
+ readonly internalType: "uint256";
1583
+ }];
1584
+ readonly outputs: readonly [{
1585
+ readonly name: "inputs";
1586
+ readonly type: "tuple[]";
1587
+ readonly internalType: "struct EncryptedInput[]";
1588
+ readonly components: readonly [{
1589
+ readonly name: "ctHash";
1590
+ readonly type: "uint256";
1591
+ readonly internalType: "uint256";
1592
+ }, {
1593
+ readonly name: "securityZone";
1594
+ readonly type: "uint8";
1595
+ readonly internalType: "uint8";
1596
+ }, {
1597
+ readonly name: "utype";
1598
+ readonly type: "uint8";
1599
+ readonly internalType: "uint8";
1600
+ }, {
1601
+ readonly name: "signature";
1602
+ readonly type: "bytes";
1603
+ readonly internalType: "bytes";
1604
+ }];
1605
+ }];
1606
+ readonly stateMutability: "nonpayable";
1607
+ }, {
1608
+ readonly type: "error";
1609
+ readonly name: "InvalidInputs";
1610
+ readonly inputs: readonly [];
1611
+ }];
185
1612
  };
186
1613
 
187
1614
  declare const MockThresholdNetworkArtifact: {
188
- contractName: string;
189
- isFixed: true;
190
- fixedAddress: string;
191
- abi: ({
192
- type: string;
193
- name: string;
194
- inputs: ({
195
- name: string;
196
- type: string;
197
- internalType: string;
198
- components?: undefined;
199
- } | {
200
- name: string;
201
- type: string;
202
- internalType: string;
203
- components: {
204
- name: string;
205
- type: string;
206
- internalType: string;
207
- }[];
208
- })[];
209
- outputs: {
210
- name: string;
211
- type: string;
212
- internalType: string;
213
- }[];
214
- stateMutability: string;
215
- } | {
216
- type: string;
217
- name: string;
218
- inputs: never[];
219
- outputs?: undefined;
220
- stateMutability?: undefined;
221
- })[];
222
- deployedBytecode: string;
1615
+ readonly contractName: "MockThresholdNetwork";
1616
+ readonly isFixed: true;
1617
+ readonly fixedAddress: "0x0000000000000000000000000000000000005002";
1618
+ readonly abi: readonly [{
1619
+ readonly type: "function";
1620
+ readonly name: "decodeLowLevelReversion";
1621
+ readonly inputs: readonly [{
1622
+ readonly name: "data";
1623
+ readonly type: "bytes";
1624
+ readonly internalType: "bytes";
1625
+ }];
1626
+ readonly outputs: readonly [{
1627
+ readonly name: "error";
1628
+ readonly type: "string";
1629
+ readonly internalType: "string";
1630
+ }];
1631
+ readonly stateMutability: "pure";
1632
+ }, {
1633
+ readonly type: "function";
1634
+ readonly name: "decryptForTxWithPermit";
1635
+ readonly inputs: readonly [{
1636
+ readonly name: "ctHash";
1637
+ readonly type: "uint256";
1638
+ readonly internalType: "uint256";
1639
+ }, {
1640
+ readonly name: "permission";
1641
+ readonly type: "tuple";
1642
+ readonly internalType: "struct Permission";
1643
+ readonly components: readonly [{
1644
+ readonly name: "issuer";
1645
+ readonly type: "address";
1646
+ readonly internalType: "address";
1647
+ }, {
1648
+ readonly name: "expiration";
1649
+ readonly type: "uint64";
1650
+ readonly internalType: "uint64";
1651
+ }, {
1652
+ readonly name: "recipient";
1653
+ readonly type: "address";
1654
+ readonly internalType: "address";
1655
+ }, {
1656
+ readonly name: "validatorId";
1657
+ readonly type: "uint256";
1658
+ readonly internalType: "uint256";
1659
+ }, {
1660
+ readonly name: "validatorContract";
1661
+ readonly type: "address";
1662
+ readonly internalType: "address";
1663
+ }, {
1664
+ readonly name: "sealingKey";
1665
+ readonly type: "bytes32";
1666
+ readonly internalType: "bytes32";
1667
+ }, {
1668
+ readonly name: "issuerSignature";
1669
+ readonly type: "bytes";
1670
+ readonly internalType: "bytes";
1671
+ }, {
1672
+ readonly name: "recipientSignature";
1673
+ readonly type: "bytes";
1674
+ readonly internalType: "bytes";
1675
+ }];
1676
+ }];
1677
+ readonly outputs: readonly [{
1678
+ readonly name: "allowed";
1679
+ readonly type: "bool";
1680
+ readonly internalType: "bool";
1681
+ }, {
1682
+ readonly name: "error";
1683
+ readonly type: "string";
1684
+ readonly internalType: "string";
1685
+ }, {
1686
+ readonly name: "decryptedValue";
1687
+ readonly type: "uint256";
1688
+ readonly internalType: "uint256";
1689
+ }];
1690
+ readonly stateMutability: "view";
1691
+ }, {
1692
+ readonly type: "function";
1693
+ readonly name: "decryptForTxWithoutPermit";
1694
+ readonly inputs: readonly [{
1695
+ readonly name: "ctHash";
1696
+ readonly type: "uint256";
1697
+ readonly internalType: "uint256";
1698
+ }];
1699
+ readonly outputs: readonly [{
1700
+ readonly name: "allowed";
1701
+ readonly type: "bool";
1702
+ readonly internalType: "bool";
1703
+ }, {
1704
+ readonly name: "error";
1705
+ readonly type: "string";
1706
+ readonly internalType: "string";
1707
+ }, {
1708
+ readonly name: "decryptedValue";
1709
+ readonly type: "uint256";
1710
+ readonly internalType: "uint256";
1711
+ }];
1712
+ readonly stateMutability: "view";
1713
+ }, {
1714
+ readonly type: "function";
1715
+ readonly name: "exists";
1716
+ readonly inputs: readonly [];
1717
+ readonly outputs: readonly [{
1718
+ readonly name: "";
1719
+ readonly type: "bool";
1720
+ readonly internalType: "bool";
1721
+ }];
1722
+ readonly stateMutability: "pure";
1723
+ }, {
1724
+ readonly type: "function";
1725
+ readonly name: "initialize";
1726
+ readonly inputs: readonly [{
1727
+ readonly name: "_taskManager";
1728
+ readonly type: "address";
1729
+ readonly internalType: "address";
1730
+ }, {
1731
+ readonly name: "_acl";
1732
+ readonly type: "address";
1733
+ readonly internalType: "address";
1734
+ }];
1735
+ readonly outputs: readonly [];
1736
+ readonly stateMutability: "nonpayable";
1737
+ }, {
1738
+ readonly type: "function";
1739
+ readonly name: "mockAcl";
1740
+ readonly inputs: readonly [];
1741
+ readonly outputs: readonly [{
1742
+ readonly name: "";
1743
+ readonly type: "address";
1744
+ readonly internalType: "contract MockACL";
1745
+ }];
1746
+ readonly stateMutability: "view";
1747
+ }, {
1748
+ readonly type: "function";
1749
+ readonly name: "mockQueryDecrypt";
1750
+ readonly inputs: readonly [{
1751
+ readonly name: "ctHash";
1752
+ readonly type: "uint256";
1753
+ readonly internalType: "uint256";
1754
+ }, {
1755
+ readonly name: "";
1756
+ readonly type: "uint256";
1757
+ readonly internalType: "uint256";
1758
+ }, {
1759
+ readonly name: "issuer";
1760
+ readonly type: "address";
1761
+ readonly internalType: "address";
1762
+ }];
1763
+ readonly outputs: readonly [{
1764
+ readonly name: "allowed";
1765
+ readonly type: "bool";
1766
+ readonly internalType: "bool";
1767
+ }, {
1768
+ readonly name: "error";
1769
+ readonly type: "string";
1770
+ readonly internalType: "string";
1771
+ }, {
1772
+ readonly name: "";
1773
+ readonly type: "uint256";
1774
+ readonly internalType: "uint256";
1775
+ }];
1776
+ readonly stateMutability: "view";
1777
+ }, {
1778
+ readonly type: "function";
1779
+ readonly name: "mockTaskManager";
1780
+ readonly inputs: readonly [];
1781
+ readonly outputs: readonly [{
1782
+ readonly name: "";
1783
+ readonly type: "address";
1784
+ readonly internalType: "contract MockTaskManager";
1785
+ }];
1786
+ readonly stateMutability: "view";
1787
+ }, {
1788
+ readonly type: "function";
1789
+ readonly name: "queryDecrypt";
1790
+ readonly inputs: readonly [{
1791
+ readonly name: "ctHash";
1792
+ readonly type: "uint256";
1793
+ readonly internalType: "uint256";
1794
+ }, {
1795
+ readonly name: "";
1796
+ readonly type: "uint256";
1797
+ readonly internalType: "uint256";
1798
+ }, {
1799
+ readonly name: "permission";
1800
+ readonly type: "tuple";
1801
+ readonly internalType: "struct Permission";
1802
+ readonly components: readonly [{
1803
+ readonly name: "issuer";
1804
+ readonly type: "address";
1805
+ readonly internalType: "address";
1806
+ }, {
1807
+ readonly name: "expiration";
1808
+ readonly type: "uint64";
1809
+ readonly internalType: "uint64";
1810
+ }, {
1811
+ readonly name: "recipient";
1812
+ readonly type: "address";
1813
+ readonly internalType: "address";
1814
+ }, {
1815
+ readonly name: "validatorId";
1816
+ readonly type: "uint256";
1817
+ readonly internalType: "uint256";
1818
+ }, {
1819
+ readonly name: "validatorContract";
1820
+ readonly type: "address";
1821
+ readonly internalType: "address";
1822
+ }, {
1823
+ readonly name: "sealingKey";
1824
+ readonly type: "bytes32";
1825
+ readonly internalType: "bytes32";
1826
+ }, {
1827
+ readonly name: "issuerSignature";
1828
+ readonly type: "bytes";
1829
+ readonly internalType: "bytes";
1830
+ }, {
1831
+ readonly name: "recipientSignature";
1832
+ readonly type: "bytes";
1833
+ readonly internalType: "bytes";
1834
+ }];
1835
+ }];
1836
+ readonly outputs: readonly [{
1837
+ readonly name: "allowed";
1838
+ readonly type: "bool";
1839
+ readonly internalType: "bool";
1840
+ }, {
1841
+ readonly name: "error";
1842
+ readonly type: "string";
1843
+ readonly internalType: "string";
1844
+ }, {
1845
+ readonly name: "";
1846
+ readonly type: "uint256";
1847
+ readonly internalType: "uint256";
1848
+ }];
1849
+ readonly stateMutability: "view";
1850
+ }, {
1851
+ readonly type: "function";
1852
+ readonly name: "querySealOutput";
1853
+ readonly inputs: readonly [{
1854
+ readonly name: "ctHash";
1855
+ readonly type: "uint256";
1856
+ readonly internalType: "uint256";
1857
+ }, {
1858
+ readonly name: "";
1859
+ readonly type: "uint256";
1860
+ readonly internalType: "uint256";
1861
+ }, {
1862
+ readonly name: "permission";
1863
+ readonly type: "tuple";
1864
+ readonly internalType: "struct Permission";
1865
+ readonly components: readonly [{
1866
+ readonly name: "issuer";
1867
+ readonly type: "address";
1868
+ readonly internalType: "address";
1869
+ }, {
1870
+ readonly name: "expiration";
1871
+ readonly type: "uint64";
1872
+ readonly internalType: "uint64";
1873
+ }, {
1874
+ readonly name: "recipient";
1875
+ readonly type: "address";
1876
+ readonly internalType: "address";
1877
+ }, {
1878
+ readonly name: "validatorId";
1879
+ readonly type: "uint256";
1880
+ readonly internalType: "uint256";
1881
+ }, {
1882
+ readonly name: "validatorContract";
1883
+ readonly type: "address";
1884
+ readonly internalType: "address";
1885
+ }, {
1886
+ readonly name: "sealingKey";
1887
+ readonly type: "bytes32";
1888
+ readonly internalType: "bytes32";
1889
+ }, {
1890
+ readonly name: "issuerSignature";
1891
+ readonly type: "bytes";
1892
+ readonly internalType: "bytes";
1893
+ }, {
1894
+ readonly name: "recipientSignature";
1895
+ readonly type: "bytes";
1896
+ readonly internalType: "bytes";
1897
+ }];
1898
+ }];
1899
+ readonly outputs: readonly [{
1900
+ readonly name: "allowed";
1901
+ readonly type: "bool";
1902
+ readonly internalType: "bool";
1903
+ }, {
1904
+ readonly name: "error";
1905
+ readonly type: "string";
1906
+ readonly internalType: "string";
1907
+ }, {
1908
+ readonly name: "";
1909
+ readonly type: "bytes32";
1910
+ readonly internalType: "bytes32";
1911
+ }];
1912
+ readonly stateMutability: "view";
1913
+ }, {
1914
+ readonly type: "function";
1915
+ readonly name: "seal";
1916
+ readonly inputs: readonly [{
1917
+ readonly name: "input";
1918
+ readonly type: "uint256";
1919
+ readonly internalType: "uint256";
1920
+ }, {
1921
+ readonly name: "key";
1922
+ readonly type: "bytes32";
1923
+ readonly internalType: "bytes32";
1924
+ }];
1925
+ readonly outputs: readonly [{
1926
+ readonly name: "";
1927
+ readonly type: "bytes32";
1928
+ readonly internalType: "bytes32";
1929
+ }];
1930
+ readonly stateMutability: "pure";
1931
+ }, {
1932
+ readonly type: "function";
1933
+ readonly name: "unseal";
1934
+ readonly inputs: readonly [{
1935
+ readonly name: "hashed";
1936
+ readonly type: "bytes32";
1937
+ readonly internalType: "bytes32";
1938
+ }, {
1939
+ readonly name: "key";
1940
+ readonly type: "bytes32";
1941
+ readonly internalType: "bytes32";
1942
+ }];
1943
+ readonly outputs: readonly [{
1944
+ readonly name: "";
1945
+ readonly type: "uint256";
1946
+ readonly internalType: "uint256";
1947
+ }];
1948
+ readonly stateMutability: "pure";
1949
+ }, {
1950
+ readonly type: "error";
1951
+ readonly name: "NotAllowed";
1952
+ readonly inputs: readonly [];
1953
+ }, {
1954
+ readonly type: "error";
1955
+ readonly name: "SealingKeyInvalid";
1956
+ readonly inputs: readonly [];
1957
+ }, {
1958
+ readonly type: "error";
1959
+ readonly name: "SealingKeyMissing";
1960
+ readonly inputs: readonly [];
1961
+ }];
223
1962
  };
224
1963
 
225
1964
  declare const TestBedArtifact: {
226
- contractName: string;
227
- isFixed: true;
228
- fixedAddress: string;
229
- abi: ({
230
- type: string;
231
- name: string;
232
- inputs: {
233
- name: string;
234
- type: string;
235
- internalType: string;
236
- components: {
237
- name: string;
238
- type: string;
239
- internalType: string;
240
- }[];
241
- }[];
242
- outputs: never[];
243
- stateMutability: string;
244
- } | {
245
- type: string;
246
- name: string;
247
- inputs: {
248
- name: string;
249
- type: string;
250
- internalType: string;
251
- }[];
252
- outputs: {
253
- name: string;
254
- type: string;
255
- internalType: string;
256
- }[];
257
- stateMutability: string;
258
- } | {
259
- type: string;
260
- name: string;
261
- inputs: {
262
- name: string;
263
- type: string;
264
- internalType: string;
265
- }[];
266
- outputs?: undefined;
267
- stateMutability?: undefined;
268
- })[];
269
- deployedBytecode: string;
1965
+ readonly contractName: "TestBed";
1966
+ readonly isFixed: true;
1967
+ readonly fixedAddress: "0x0000000000000000000000000000000000005003";
1968
+ readonly abi: readonly [{
1969
+ readonly type: "function";
1970
+ readonly name: "add";
1971
+ readonly inputs: readonly [{
1972
+ readonly name: "inNumber";
1973
+ readonly type: "tuple";
1974
+ readonly internalType: "struct InEuint32";
1975
+ readonly components: readonly [{
1976
+ readonly name: "ctHash";
1977
+ readonly type: "uint256";
1978
+ readonly internalType: "uint256";
1979
+ }, {
1980
+ readonly name: "securityZone";
1981
+ readonly type: "uint8";
1982
+ readonly internalType: "uint8";
1983
+ }, {
1984
+ readonly name: "utype";
1985
+ readonly type: "uint8";
1986
+ readonly internalType: "uint8";
1987
+ }, {
1988
+ readonly name: "signature";
1989
+ readonly type: "bytes";
1990
+ readonly internalType: "bytes";
1991
+ }];
1992
+ }];
1993
+ readonly outputs: readonly [];
1994
+ readonly stateMutability: "nonpayable";
1995
+ }, {
1996
+ readonly type: "function";
1997
+ readonly name: "decrypt";
1998
+ readonly inputs: readonly [];
1999
+ readonly outputs: readonly [];
2000
+ readonly stateMutability: "nonpayable";
2001
+ }, {
2002
+ readonly type: "function";
2003
+ readonly name: "eNumber";
2004
+ readonly inputs: readonly [];
2005
+ readonly outputs: readonly [{
2006
+ readonly name: "";
2007
+ readonly type: "bytes32";
2008
+ readonly internalType: "euint32";
2009
+ }];
2010
+ readonly stateMutability: "view";
2011
+ }, {
2012
+ readonly type: "function";
2013
+ readonly name: "exists";
2014
+ readonly inputs: readonly [];
2015
+ readonly outputs: readonly [{
2016
+ readonly name: "";
2017
+ readonly type: "bool";
2018
+ readonly internalType: "bool";
2019
+ }];
2020
+ readonly stateMutability: "pure";
2021
+ }, {
2022
+ readonly type: "function";
2023
+ readonly name: "getDecryptResult";
2024
+ readonly inputs: readonly [{
2025
+ readonly name: "input1";
2026
+ readonly type: "bytes32";
2027
+ readonly internalType: "euint32";
2028
+ }];
2029
+ readonly outputs: readonly [{
2030
+ readonly name: "";
2031
+ readonly type: "uint32";
2032
+ readonly internalType: "uint32";
2033
+ }];
2034
+ readonly stateMutability: "view";
2035
+ }, {
2036
+ readonly type: "function";
2037
+ readonly name: "getDecryptResultSafe";
2038
+ readonly inputs: readonly [{
2039
+ readonly name: "input1";
2040
+ readonly type: "bytes32";
2041
+ readonly internalType: "euint32";
2042
+ }];
2043
+ readonly outputs: readonly [{
2044
+ readonly name: "value";
2045
+ readonly type: "uint32";
2046
+ readonly internalType: "uint32";
2047
+ }, {
2048
+ readonly name: "decrypted";
2049
+ readonly type: "bool";
2050
+ readonly internalType: "bool";
2051
+ }];
2052
+ readonly stateMutability: "view";
2053
+ }, {
2054
+ readonly type: "function";
2055
+ readonly name: "increment";
2056
+ readonly inputs: readonly [];
2057
+ readonly outputs: readonly [];
2058
+ readonly stateMutability: "nonpayable";
2059
+ }, {
2060
+ readonly type: "function";
2061
+ readonly name: "mul";
2062
+ readonly inputs: readonly [{
2063
+ readonly name: "inNumber";
2064
+ readonly type: "tuple";
2065
+ readonly internalType: "struct InEuint32";
2066
+ readonly components: readonly [{
2067
+ readonly name: "ctHash";
2068
+ readonly type: "uint256";
2069
+ readonly internalType: "uint256";
2070
+ }, {
2071
+ readonly name: "securityZone";
2072
+ readonly type: "uint8";
2073
+ readonly internalType: "uint8";
2074
+ }, {
2075
+ readonly name: "utype";
2076
+ readonly type: "uint8";
2077
+ readonly internalType: "uint8";
2078
+ }, {
2079
+ readonly name: "signature";
2080
+ readonly type: "bytes";
2081
+ readonly internalType: "bytes";
2082
+ }];
2083
+ }];
2084
+ readonly outputs: readonly [];
2085
+ readonly stateMutability: "nonpayable";
2086
+ }, {
2087
+ readonly type: "function";
2088
+ readonly name: "numberHash";
2089
+ readonly inputs: readonly [];
2090
+ readonly outputs: readonly [{
2091
+ readonly name: "";
2092
+ readonly type: "bytes32";
2093
+ readonly internalType: "bytes32";
2094
+ }];
2095
+ readonly stateMutability: "view";
2096
+ }, {
2097
+ readonly type: "function";
2098
+ readonly name: "publishDecryptResult";
2099
+ readonly inputs: readonly [{
2100
+ readonly name: "input";
2101
+ readonly type: "bytes32";
2102
+ readonly internalType: "euint32";
2103
+ }, {
2104
+ readonly name: "result";
2105
+ readonly type: "uint32";
2106
+ readonly internalType: "uint32";
2107
+ }, {
2108
+ readonly name: "signature";
2109
+ readonly type: "bytes";
2110
+ readonly internalType: "bytes";
2111
+ }];
2112
+ readonly outputs: readonly [];
2113
+ readonly stateMutability: "nonpayable";
2114
+ }, {
2115
+ readonly type: "function";
2116
+ readonly name: "setNumber";
2117
+ readonly inputs: readonly [{
2118
+ readonly name: "inNumber";
2119
+ readonly type: "tuple";
2120
+ readonly internalType: "struct InEuint32";
2121
+ readonly components: readonly [{
2122
+ readonly name: "ctHash";
2123
+ readonly type: "uint256";
2124
+ readonly internalType: "uint256";
2125
+ }, {
2126
+ readonly name: "securityZone";
2127
+ readonly type: "uint8";
2128
+ readonly internalType: "uint8";
2129
+ }, {
2130
+ readonly name: "utype";
2131
+ readonly type: "uint8";
2132
+ readonly internalType: "uint8";
2133
+ }, {
2134
+ readonly name: "signature";
2135
+ readonly type: "bytes";
2136
+ readonly internalType: "bytes";
2137
+ }];
2138
+ }];
2139
+ readonly outputs: readonly [];
2140
+ readonly stateMutability: "nonpayable";
2141
+ }, {
2142
+ readonly type: "function";
2143
+ readonly name: "setNumberTrivial";
2144
+ readonly inputs: readonly [{
2145
+ readonly name: "inNumber";
2146
+ readonly type: "uint32";
2147
+ readonly internalType: "uint32";
2148
+ }];
2149
+ readonly outputs: readonly [];
2150
+ readonly stateMutability: "nonpayable";
2151
+ }, {
2152
+ readonly type: "function";
2153
+ readonly name: "sub";
2154
+ readonly inputs: readonly [{
2155
+ readonly name: "inNumber";
2156
+ readonly type: "tuple";
2157
+ readonly internalType: "struct InEuint32";
2158
+ readonly components: readonly [{
2159
+ readonly name: "ctHash";
2160
+ readonly type: "uint256";
2161
+ readonly internalType: "uint256";
2162
+ }, {
2163
+ readonly name: "securityZone";
2164
+ readonly type: "uint8";
2165
+ readonly internalType: "uint8";
2166
+ }, {
2167
+ readonly name: "utype";
2168
+ readonly type: "uint8";
2169
+ readonly internalType: "uint8";
2170
+ }, {
2171
+ readonly name: "signature";
2172
+ readonly type: "bytes";
2173
+ readonly internalType: "bytes";
2174
+ }];
2175
+ }];
2176
+ readonly outputs: readonly [];
2177
+ readonly stateMutability: "nonpayable";
2178
+ }, {
2179
+ readonly type: "error";
2180
+ readonly name: "InvalidEncryptedInput";
2181
+ readonly inputs: readonly [{
2182
+ readonly name: "got";
2183
+ readonly type: "uint8";
2184
+ readonly internalType: "uint8";
2185
+ }, {
2186
+ readonly name: "expected";
2187
+ readonly type: "uint8";
2188
+ readonly internalType: "uint8";
2189
+ }];
2190
+ }, {
2191
+ readonly type: "error";
2192
+ readonly name: "SecurityZoneOutOfBounds";
2193
+ readonly inputs: readonly [{
2194
+ readonly name: "value";
2195
+ readonly type: "int32";
2196
+ readonly internalType: "int32";
2197
+ }];
2198
+ }];
270
2199
  };
271
2200
 
272
2201
  interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {