BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Ghostnet
  • /
  • KT1Umi6...QKcJ
operations (674)Storage Code Interact Tokens Fork Statistics Details
Latest
​x
563
1245
 
1
parameter (or
2
            (or
3
              (or
4
                (or (list %addToWhitelist (pair address bool))
5
                    (pair %burnFromCrowdsale (nat %token_id) (address %from_)))
6
                (or (pair %mintFromCrowdsale (address %to_) (nat %token_count))
7
                    (list %removeFromWhitelist address)))
8
              (or (or (map %setDefaultMetadata string bytes) (address %setDogaAddress))
9
                  (or
10
                    (pair %setMintParams (bool %is_private_sale)
11
                                         (pair (nat %mint_price)
12
                                               (pair (string %currency)
13
                                                     (pair (nat %next_token_id)
14
                                                           (pair (nat %total_supply)
15
                                                                 (pair
16
                                                                   (nat %max_mint_per_address)
17
                                                                   (pair
18
                                                                     (nat %token_per_pack)
19
                                                                     (pair
20
                                                                       (timestamp %start_time)
21
                                                                       (timestamp %end_time)))))))))
22
                    (unit %setMintPerAddress))))
23
            (or
24
              (or (or (address %setMultisigContract) (map %setNameList nat bytes))
25
                  (or (address %setNftAddress) (bool %setPause)))
26
              (address %setReserveAddress)));
27
storage (pair (bool %paused)
28
              (pair (address %multisig)
29
                    (pair (address %nft_address)
30
                          (pair (address %doga_address)
31
                                (pair (address %reserve_address)
32
                                      (pair (bool %is_private_sale)
33
                                            (pair (nat %mint_price)
34
                                                  (pair (nat %total_supply)
35
                                                        (pair
36
                                                          (big_map %mint_per_address
37
                                                            address
38
                                                            nat)
39
                                                          (pair
40
                                                            (nat %max_mint_per_address)
41
                                                            (pair
42
                                                              (timestamp %start_time)
43
                                                              (pair
44
                                                                (timestamp %end_time)
45
                                                                (pair
46
                                                                  (nat %next_token_id)
47
                                                                  (pair
48
                                                                    (big_map %name_list
49
                                                                      nat
50
                                                                      bytes)
51
                                                                    (pair
52
                                                                      (big_map %whitelist
53
                                                                        address
54
                                                                        bool)
55
                                                                      (pair
56
                                                                        (nat %token_per_pack)
57
                                                                        (pair
58
                                                                          (map %default_metadata
59
                                                                            string
60
                                                                            bytes)
61
                                                                          (string %currency))))))))))))))))));
62
code { UNPAIR ;
63
       IF_LEFT
64
         { IF_LEFT
65
             { IF_LEFT
66
                 { IF_LEFT
67
                     { DUP 2 ;
68
                       GET 3 ;
69
                       SENDER ;
70
                       COMPARE ;
71
                       NEQ ;
72
                       IF
73
                         { SELF_ADDRESS ;
74
                           DUP 3 ;
75
                           DIG 3 ;
76
                           GET 3 ;
77
                           CONTRACT %callMultisig (pair
78
                                                    (pair %entrypoint_signature
79
                                                      (string %name)
80
                                                      (pair (bytes %params)
81
                                                            (address %source_contract)))
82
                                                    (lambda %callback unit
83
                                                                      (list operation))) ;
84
                           IF_NONE
85
                             { SWAP ;
86
                               DIG 2 ;
87
                               DROP 2 ;
88
                               PUSH string "no call entrypoint" ;
89
                               FAILWITH }
90
                             { DUP 4 ;
91
                               PACK ;
92
                               SHA256 ;
93
                               SELF_ADDRESS ;
94
                               SWAP ;
95
                               PUSH string "addToWhitelist" ;
96
                               PAIR 3 ;
97
                               SWAP ;
98
                               PUSH mutez 0 ;
99
                               LAMBDA
100
                                 (pair (pair address (list (pair address bool))) unit)
101
                                 (list operation)
102
                                 { UNPAIR ;
103
                                   UNPAIR ;
104
                                   DIG 2 ;
105
                                   DROP ;
106
                                   CONTRACT %addToWhitelist (list (pair address bool)) ;
107
                                   IF_NONE
108
                                     { DROP ;
109
                                       PUSH string "no addToWhitelist entrypoint" ;
110
                                       FAILWITH }
111
                                     { NIL operation ;
112
                                       SWAP ;
113
                                       PUSH mutez 0 ;
114
                                       DIG 3 ;
115
                                       TRANSFER_TOKENS ;
116
                                       CONS } } ;
117
                               DUP 7 ;
118
                               DUP 7 ;
119
                               PAIR ;
120
                               APPLY ;
121
                               DIG 5 ;
122
                               DIG 6 ;
123
                               DROP 2 ;
124
                               DIG 3 ;
125
                               PAIR ;
126
                               TRANSFER_TOKENS ;
127
                               NIL operation ;
128
                               SWAP ;
129
                               CONS } }
130
                         { DUP 2 ;
131
                           GET 29 ;
132
                           SWAP ;
133
                           ITER { SWAP ; DUP 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
134
                           UPDATE 29 ;
135
                           NIL operation } ;
136
                       PAIR }
137
                     { DUP 2 ;
138
                       GET 3 ;
139
                       SENDER ;
140
                       COMPARE ;
141
                       NEQ ;
142
                       IF
143
                         { SELF_ADDRESS ;
144
                           DUP 3 ;
145
                           DIG 3 ;
146
                           GET 3 ;
147
                           CONTRACT %callMultisig (pair
148
                                                    (pair %entrypoint_signature
149
                                                      (string %name)
150
                                                      (pair (bytes %params)
151
                                                            (address %source_contract)))
152
                                                    (lambda %callback unit
153
                                                                      (list operation))) ;
154
                           IF_NONE
155
                             { SWAP ;
156
                               DIG 2 ;
157
                               DROP 2 ;
158
                               PUSH string "no call entrypoint" ;
159
                               FAILWITH }
160
                             { DUP 4 ;
161
                               PACK ;
162
                               SHA256 ;
163
                               SELF_ADDRESS ;
164
                               SWAP ;
165
                               PUSH string "burnFromCrowdsale" ;
166
                               PAIR 3 ;
167
                               SWAP ;
168
                               PUSH mutez 0 ;
169
                               LAMBDA
170
                                 (pair (pair address (pair nat address)) unit)
171
                                 (list operation)
172
                                 { UNPAIR ;
173
                                   UNPAIR ;
174
                                   DIG 2 ;
175
                                   DROP ;
176
                                   CONTRACT %burnFromCrowdsale (pair (nat %token_id)
177
                                                                     (address %from_)) ;
178
                                   IF_NONE
179
                                     { DROP ;
180
                                       PUSH string "no burnFromCrowdsale entrypoint" ;
181
                                       FAILWITH }
182
                                     { NIL operation ;
183
                                       SWAP ;
184
                                       PUSH mutez 0 ;
185
                                       DIG 3 ;
186
                                       TRANSFER_TOKENS ;
187
                                       CONS } } ;
188
                               DUP 7 ;
189
                               DUP 7 ;
190
                               PAIR ;
191
                               APPLY ;
192
                               DIG 5 ;
193
                               DIG 6 ;
194
                               DROP 2 ;
195
                               DIG 3 ;
196
                               PAIR ;
197
                               TRANSFER_TOKENS ;
198
                               NIL operation ;
199
                               SWAP ;
200
                               CONS } ;
201
                           PAIR }
202
                         { PUSH bool True ;
203
                           DUP 3 ;
204
                           CAR ;
205
                           COMPARE ;
206
                           EQ ;
207
                           IF
208
                             { DROP 2 ; PUSH string "Contract in pause" ; FAILWITH }
209
                             { DUP 2 ;
210
                               GET 5 ;
211
                               CONTRACT %burn (pair (nat %token_id) (address %from_)) ;
212
                               IF_NONE
213
                                 { DROP ;
214
                                   PUSH string "NFT contract must have a burn entrypoint" ;
215
                                   FAILWITH }
216
                                 { PUSH mutez 0 ; DIG 2 ; TRANSFER_TOKENS } ;
217
                               SWAP ;
218
                               NIL operation ;
219
                               DIG 2 ;
220
                               CONS ;
221
                               PAIR } } } }
222
                 { IF_LEFT
223
                     { PUSH nat 1 ;
224
                       DUP 2 ;
225
                       CDR ;
226
                       COMPARE ;
227
                       LT ;
228
                       IF
229
                         { DROP 2 ;
230
                           PUSH string "Value should be higher than zero" ;
231
                           FAILWITH }
232
                         { PUSH bool True ;
233
                           DUP 3 ;
234
                           CAR ;
235
                           COMPARE ;
236
                           EQ ;
237
                           IF
238
                             { DROP 2 ; PUSH string "Contract in pause" ; FAILWITH }
239
                             { DUP 2 ;
240
                               GET 23 ;
241
                               NOW ;
242
                               COMPARE ;
243
                               GE ;
244
                               DUP 3 ;
245
                               GET 21 ;
246
                               NOW ;
247
                               COMPARE ;
248
                               LT ;
249
                               OR ;
250
                               IF
251
                                 { DROP 2 ;
252
                                   PUSH string "Mint period is not open" ;
253
                                   FAILWITH }
254
                                 { DUP 2 ;
255
                                   GET 11 ;
256
                                   IF
257
                                     { DUP 2 ;
258
                                       GET 29 ;
259
                                       DUP 2 ;
260
                                       CAR ;
261
                                       GET ;
262
                                       IF_NONE
263
                                         { PUSH string "Address is not whitelisted" ;
264
                                           FAILWITH }
265
                                         { DROP } }
266
                                     {} ;
267
                                   DUP ;
268
                                   CDR ;
269
                                   PUSH nat 0 ;
270
                                   DUP 4 ;
271
                                   GET 31 ;
272
                                   COMPARE ;
273
                                   NEQ ;
274
                                   IF
275
                                     { PUSH nat 0 ;
276
                                       DUP 4 ;
277
                                       GET 31 ;
278
                                       DUP 3 ;
279
                                       EDIV ;
280
                                       IF_NONE
281
                                         { PUSH string "MOD by 0" ; FAILWITH }
282
                                         {} ;
283
                                       CDR ;
284
                                       COMPARE ;
285
                                       NEQ ;
286
                                       IF
287
                                         { DROP ;
288
                                           PUSH string "Invalid number of tokens" ;
289
                                           FAILWITH }
290
                                         { DUP 3 ;
291
                                           GET 31 ;
292
                                           DUP 4 ;
293
                                           GET 13 ;
294
                                           DIG 2 ;
295
                                           MUL ;
296
                                           EDIV ;
297
                                           IF_NONE
298
                                             { PUSH string "DIV by 0" ; FAILWITH }
299
                                             {} ;
300
                                           CAR } }
301
                                     { DUP 3 ; GET 13 ; SWAP ; MUL } ;
302
                                   PUSH string "XTZ" ;
303
                                   DUP 4 ;
304
                                   GET 34 ;
305
                                   COMPARE ;
306
                                   EQ ;
307
                                   IF
308
                                     { PUSH mutez 1 ;
309
                                       DUP 2 ;
310
                                       MUL ;
311
                                       AMOUNT ;
312
                                       COMPARE ;
313
                                       NEQ ;
314
                                       IF
315
                                         { DROP ; PUSH string "Invalid amount" ; FAILWITH }
316
                                         { NIL operation ;
317
                                           PUSH mutez 1 ;
318
                                           DIG 2 ;
319
                                           MUL ;
320
                                           DUP 4 ;
321
                                           GET 9 ;
322
                                           CONTRACT unit ;
323
                                           IF_NONE
324
                                             { DROP ;
325
                                               PUSH string "Invalid to address" ;
326
                                               FAILWITH }
327
                                             { SWAP ; UNIT ; TRANSFER_TOKENS } ;
328
                                           CONS } }
329
                                     { NIL operation ;
330
                                       SWAP ;
331
                                       DUP 4 ;
332
                                       GET 9 ;
333
                                       SENDER ;
334
                                       DUP 6 ;
335
                                       GET 7 ;
336
                                       PAIR 4 ;
337
                                       UNPAIR 4 ;
338
                                       CONTRACT %transfer (pair (address %from)
339
                                                                (pair (address %to)
340
                                                                      (nat %value))) ;
341
                                       IF_NONE
342
                                         { PUSH string "FA1.2 contract must have a transfer entrypoint" ;
343
                                           FAILWITH }
344
                                         {} ;
345
                                       PUSH mutez 0 ;
346
                                       DIG 4 ;
347
                                       DIG 4 ;
348
                                       DIG 4 ;
349
                                       PAIR 3 ;
350
                                       TRANSFER_TOKENS ;
351
                                       CONS } ;
352
                                   DUP 3 ;
353
                                   SWAP ;
354
                                   PAIR ;
355
                                   DUP 2 ;
356
                                   CDR ;
357
                                   PAIR ;
358
                                   LEFT (pair (list operation)
359
                                              (pair bool
360
                                                    (pair address
361
                                                          (pair address
362
                                                                (pair address
363
                                                                      (pair address
364
                                                                            (pair bool
365
                                                                                  (pair
366
                                                                                    nat
367
                                                                                    (pair
368
                                                                                      nat
369
                                                                                      (pair
370
                                                                                        (big_map
371
                                                                                          address
372
                                                                                          nat)
373
                                                                                        (pair
374
                                                                                          nat
375
                                                                                          (pair
376
                                                                                            timestamp
377
                                                                                            (pair
378
                                                                                              timestamp
379
                                                                                              (pair
380
                                                                                                nat
381
                                                                                                (pair
382
                                                                                                  (big_map
383
                                                                                                    nat
384
                                                                                                    bytes)
385
                                                                                                  (pair
386
                                                                                                    (big_map
387
                                                                                                      address
388
                                                                                                      bool)
389
                                                                                                    (pair
390
                                                                                                      nat
391
                                                                                                      (pair
392
                                                                                                        (map
393
                                                                                                          string
394
                                                                                                          bytes)
395
                                                                                                        string)))))))))))))))))) ;
396
                                   LOOP_LEFT { UNPAIR ;
397
                                               PUSH nat 1 ;
398
                                               DUP 2 ;
399
                                               COMPARE ;
400
                                               LT ;
401
                                               IF
402
                                                 { DROP ;
403
                                                   RIGHT (pair nat
404
                                                               (pair (list operation)
405
                                                                     (pair bool
406
                                                                           (pair address
407
                                                                                 (pair
408
                                                                                   address
409
                                                                                   (pair
410
                                                                                     address
411
                                                                                     (pair
412
                                                                                       address
413
                                                                                       (pair
414
                                                                                         bool
415
                                                                                         (pair
416
                                                                                           nat
417
                                                                                           (pair
418
                                                                                             nat
419
                                                                                             (pair
420
                                                                                               (big_map
421
                                                                                                 address
422
                                                                                                 nat)
423
                                                                                               (pair
424
                                                                                                 nat
425
                                                                                                 (pair
426
                                                                                                   timestamp
427
                                                                                                   (pair
428
                                                                                                     timestamp
429
                                                                                                     (pair
430
                                                                                                       nat
431
                                                                                                       (pair
432
                                                                                                         (big_map
433
                                                                                                           nat
434
                                                                                                           bytes)
435
                                                                                                         (pair
436
                                                                                                           (big_map
437
                                                                                                             address
438
                                                                                                             bool)
439
                                                                                                           (pair
440
                                                                                                             nat
441
                                                                                                             (pair
442
                                                                                                               (map
443
                                                                                                                 string
444
                                                                                                                 bytes)
445
                                                                                                               string))))))))))))))))))) }
446
                                                 { DUP 4 ;
447
                                                   GET 15 ;
448
                                                   DUP 3 ;
449
                                                   CDR ;
450
                                                   GET 25 ;
451
                                                   COMPARE ;
452
                                                   GT ;
453
                                                   IF
454
                                                     { DROP 2 ;
455
                                                       PUSH string "Total supply reached" ;
456
                                                       FAILWITH }
457
                                                     { DUP 2 ;
458
                                                       CDR ;
459
                                                       GET 17 ;
460
                                                       DUP 4 ;
461
                                                       CAR ;
462
                                                       GET ;
463
                                                       IF_NONE
464
                                                         { PUSH nat 0 }
465
                                                         { DUP 5 ;
466
                                                           GET 19 ;
467
                                                           DUP 2 ;
468
                                                           COMPARE ;
469
                                                           GE ;
470
                                                           IF
471
                                                             { DROP ;
472
                                                               PUSH string "Max mint per address reached" ;
473
                                                               FAILWITH }
474
                                                             {} } ;
475
                                                       DUP 3 ;
476
                                                       CDR ;
477
                                                       GET 5 ;
478
                                                       CONTRACT %mint (pair
479
                                                                        (pair
480
                                                                          (address %to_)
481
                                                                          (nat %token_id))
482
                                                                        (map %token_info
483
                                                                          string
484
                                                                          bytes)) ;
485
                                                       IF_NONE
486
                                                         { PUSH string "NFT contract must have a mint entrypoint" ;
487
                                                           FAILWITH }
488
                                                         { PUSH mutez 0 ;
489
                                                           DUP 5 ;
490
                                                           CDR ;
491
                                                           DUP ;
492
                                                           GET 33 ;
493
                                                           DUP 2 ;
494
                                                           GET 27 ;
495
                                                           DIG 2 ;
496
                                                           GET 25 ;
497
                                                           GET ;
498
                                                           IF_NONE
499
                                                             { PUSH bytes 0x446f67616d69 }
500
                                                             {} ;
501
                                                           SOME ;
502
                                                           PUSH string "name" ;
503
                                                           UPDATE ;
504
                                                           DUP 6 ;
505
                                                           CDR ;
506
                                                           GET 25 ;
507
                                                           DUP 8 ;
508
                                                           CAR ;
509
                                                           PAIR ;
510
                                                           PAIR ;
511
                                                           TRANSFER_TOKENS } ;
512
                                                       DUP 4 ;
513
                                                       CDR ;
514
                                                       GET 17 ;
515
                                                       PUSH nat 1 ;
516
                                                       DIG 3 ;
517
                                                       ADD ;
518
                                                       SOME ;
519
                                                       DUP 6 ;
520
                                                       CAR ;
521
                                                       PAIR 3 ;
522
                                                       PUSH nat 1 ;
523
                                                       DUP 5 ;
524
                                                       CDR ;
525
                                                       GET 25 ;
526
                                                       ADD ;
527
                                                       PUSH nat 1 ;
528
                                                       DIG 4 ;
529
                                                       SUB ;
530
                                                       ISNAT ;
531
                                                       IF_NONE
532
                                                         { DROP 4 ;
533
                                                           PUSH string "Invalid nat value" ;
534
                                                           FAILWITH }
535
                                                         { DUP 5 ;
536
                                                           CDR ;
537
                                                           DUP 6 ;
538
                                                           CDR ;
539
                                                           GET 27 ;
540
                                                           NONE bytes ;
541
                                                           DUP 8 ;
542
                                                           CDR ;
543
                                                           GET 25 ;
544
                                                           UPDATE ;
545
                                                           UPDATE 27 ;
546
                                                           DIG 2 ;
547
                                                           UPDATE 25 ;
548
                                                           DIG 2 ;
549
                                                           UNPAIR 3 ;
550
                                                           UPDATE ;
551
                                                           UPDATE 17 ;
552
                                                           DIG 3 ;
553
                                                           CAR ;
554
                                                           DIG 3 ;
555
                                                           CONS ;
556
                                                           PAIR ;
557
                                                           SWAP ;
558
                                                           PAIR ;
559
                                                           LEFT (pair (list operation)
560
                                                                      (pair bool
561
                                                                            (pair
562
                                                                              address
563
                                                                              (pair
564
                                                                                address
565
                                                                                (pair
566
                                                                                  address
567
                                                                                  (pair
568
                                                                                    address
569
                                                                                    (pair
570
                                                                                      bool
571
                                                                                      (pair
572
                                                                                        nat
573
                                                                                        (pair
574
                                                                                          nat
575
                                                                                          (pair
576
                                                                                            (big_map
577
                                                                                              address
578
                                                                                              nat)
579
                                                                                            (pair
580
                                                                                              nat
581
                                                                                              (pair
582
                                                                                                timestamp
583
                                                                                                (pair
584
                                                                                                  timestamp
585
                                                                                                  (pair
586
                                                                                                    nat
587
                                                                                                    (pair
588
                                                                                                      (big_map
589
                                                                                                        nat
590
                                                                                                        bytes)
591
                                                                                                      (pair
592
                                                                                                        (big_map
593
                                                                                                          address
594
                                                                                                          bool)
595
                                                                                                        (pair
596
                                                                                                          nat
597
                                                                                                          (pair
598
                                                                                                            (map
599
                                                                                                              string
600
                                                                                                              bytes)
601
                                                                                                            string)))))))))))))))))) } } } } ;
602
                                   SWAP ;
603
                                   DIG 2 ;
604
                                   DROP 2 } } } }
605
                     { DUP 2 ;
606
                       GET 3 ;
607
                       SENDER ;
608
                       COMPARE ;
609
                       NEQ ;
610
                       IF
611
                         { SELF_ADDRESS ;
612
                           DUP 3 ;
613
                           DIG 3 ;
614
                           GET 3 ;
615
                           CONTRACT %callMultisig (pair
616
                                                    (pair %entrypoint_signature
617
                                                      (string %name)
618
                                                      (pair (bytes %params)
619
                                                            (address %source_contract)))
620
                                                    (lambda %callback unit
621
                                                                      (list operation))) ;
622
                           IF_NONE
623
                             { SWAP ;
624
                               DIG 2 ;
625
                               DROP 2 ;
626
                               PUSH string "no call entrypoint" ;
627
                               FAILWITH }
628
                             { DUP 4 ;
629
                               PACK ;
630
                               SHA256 ;
631
                               SELF_ADDRESS ;
632
                               SWAP ;
633
                               PUSH string "removeFromWhitelist" ;
634
                               PAIR 3 ;
635
                               SWAP ;
636
                               PUSH mutez 0 ;
637
                               LAMBDA
638
                                 (pair (pair address (list address)) unit)
639
                                 (list operation)
640
                                 { UNPAIR ;
641
                                   UNPAIR ;
642
                                   DIG 2 ;
643
                                   DROP ;
644
                                   CONTRACT %removeFromWhitelist (list address) ;
645
                                   IF_NONE
646
                                     { DROP ;
647
                                       PUSH string "no removeFromWhitelist entrypoint" ;
648
                                       FAILWITH }
649
                                     { NIL operation ;
650
                                       SWAP ;
651
                                       PUSH mutez 0 ;
652
                                       DIG 3 ;
653
                                       TRANSFER_TOKENS ;
654
                                       CONS } } ;
655
                               DUP 7 ;
656
                               DUP 7 ;
657
                               PAIR ;
658
                               APPLY ;
659
                               DIG 5 ;
660
                               DIG 6 ;
661
                               DROP 2 ;
662
                               DIG 3 ;
663
                               PAIR ;
664
                               TRANSFER_TOKENS ;
665
                               NIL operation ;
666
                               SWAP ;
667
                               CONS } }
668
                         { DUP 2 ;
669
                           GET 29 ;
670
                           SWAP ;
671
                           ITER { SWAP ; NONE bool ; DIG 2 ; UPDATE } ;
672
                           UPDATE 29 ;
673
                           NIL operation } ;
674
                       PAIR } } }
675
             { IF_LEFT
676
                 { IF_LEFT
677
                     { DUP 2 ;
678
                       GET 3 ;
679
                       SENDER ;
680
                       COMPARE ;
681
                       NEQ ;
682
                       IF
683
                         { SELF_ADDRESS ;
684
                           DUP 3 ;
685
                           DIG 3 ;
686
                           GET 3 ;
687
                           CONTRACT %callMultisig (pair
688
                                                    (pair %entrypoint_signature
689
                                                      (string %name)
690
                                                      (pair (bytes %params)
691
                                                            (address %source_contract)))
692
                                                    (lambda %callback unit
693
                                                                      (list operation))) ;
694
                           IF_NONE
695
                             { SWAP ;
696
                               DIG 2 ;
697
                               DROP 2 ;
698
                               PUSH string "no call entrypoint" ;
699
                               FAILWITH }
700
                             { DUP 4 ;
701
                               PACK ;
702
                               SHA256 ;
703
                               SELF_ADDRESS ;
704
                               SWAP ;
705
                               PUSH string "setDefaultMetadata" ;
706
                               PAIR 3 ;
707
                               SWAP ;
708
                               PUSH mutez 0 ;
709
                               LAMBDA
710
                                 (pair (pair address (map string bytes)) unit)
711
                                 (list operation)
712
                                 { UNPAIR ;
713
                                   UNPAIR ;
714
                                   DIG 2 ;
715
                                   DROP ;
716
                                   CONTRACT %setDefaultMetadata (map string bytes) ;
717
                                   IF_NONE
718
                                     { DROP ;
719
                                       PUSH string "no setDefaultMetadata entrypoint" ;
720
                                       FAILWITH }
721
                                     { NIL operation ;
722
                                       SWAP ;
723
                                       PUSH mutez 0 ;
724
                                       DIG 3 ;
725
                                       TRANSFER_TOKENS ;
726
                                       CONS } } ;
727
                               DUP 7 ;
728
                               DUP 7 ;
729
                               PAIR ;
730
                               APPLY ;
731
                               DIG 5 ;
732
                               DIG 6 ;
733
                               DROP 2 ;
734
                               DIG 3 ;
735
                               PAIR ;
736
                               TRANSFER_TOKENS ;
737
                               NIL operation ;
738
                               SWAP ;
739
                               CONS } }
740
                         { DUP 2 ;
741
                           GET 33 ;
742
                           SWAP ;
743
                           ITER { SWAP ; DUP 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
744
                           UPDATE 33 ;
745
                           NIL operation } }
746
                     { DUP 2 ;
747
                       GET 3 ;
748
                       SENDER ;
749
                       COMPARE ;
750
                       NEQ ;
751
                       IF
752
                         { SELF_ADDRESS ;
753
                           DUP 3 ;
754
                           DIG 3 ;
755
                           GET 3 ;
756
                           CONTRACT %callMultisig (pair
757
                                                    (pair %entrypoint_signature
758
                                                      (string %name)
759
                                                      (pair (bytes %params)
760
                                                            (address %source_contract)))
761
                                                    (lambda %callback unit
762
                                                                      (list operation))) ;
763
                           IF_NONE
764
                             { SWAP ;
765
                               DIG 2 ;
766
                               DROP 2 ;
767
                               PUSH string "no call entrypoint" ;
768
                               FAILWITH }
769
                             { DUP 4 ;
770
                               PACK ;
771
                               SHA256 ;
772
                               SELF_ADDRESS ;
773
                               SWAP ;
774
                               PUSH string "setDogaAddress" ;
775
                               PAIR 3 ;
776
                               SWAP ;
777
                               PUSH mutez 0 ;
778
                               LAMBDA
779
                                 (pair (pair address address) unit)
780
                                 (list operation)
781
                                 { UNPAIR ;
782
                                   UNPAIR ;
783
                                   DIG 2 ;
784
                                   DROP ;
785
                                   CONTRACT %setDogaAddress address ;
786
                                   IF_NONE
787
                                     { DROP ;
788
                                       PUSH string "no setDogaAddress entrypoint" ;
789
                                       FAILWITH }
790
                                     { NIL operation ;
791
                                       SWAP ;
792
                                       PUSH mutez 0 ;
793
                                       DIG 3 ;
794
                                       TRANSFER_TOKENS ;
795
                                       CONS } } ;
796
                               DUP 7 ;
797
                               DUP 7 ;
798
                               PAIR ;
799
                               APPLY ;
800
                               DIG 5 ;
801
                               DIG 6 ;
802
                               DROP 2 ;
803
                               DIG 3 ;
804
                               PAIR ;
805
                               TRANSFER_TOKENS ;
806
                               NIL operation ;
807
                               SWAP ;
808
                               CONS } }
809
                         { UPDATE 7 ; NIL operation } } ;
810
                   PAIR }
811
                 { IF_LEFT
812
                     { DUP 2 ;
813
                       GET 3 ;
814
                       SENDER ;
815
                       COMPARE ;
816
                       NEQ ;
817
                       IF
818
                         { SELF_ADDRESS ;
819
                           DUP 3 ;
820
                           DIG 3 ;
821
                           GET 3 ;
822
                           CONTRACT %callMultisig (pair
823
                                                    (pair %entrypoint_signature
824
                                                      (string %name)
825
                                                      (pair (bytes %params)
826
                                                            (address %source_contract)))
827
                                                    (lambda %callback unit
828
                                                                      (list operation))) ;
829
                           IF_NONE
830
                             { SWAP ;
831
                               DIG 2 ;
832
                               DROP 2 ;
833
                               PUSH string "no call entrypoint" ;
834
                               FAILWITH }
835
                             { DUP 4 ;
836
                               PACK ;
837
                               SHA256 ;
838
                               SELF_ADDRESS ;
839
                               SWAP ;
840
                               PUSH string "setMintParams" ;
841
                               PAIR 3 ;
842
                               SWAP ;
843
                               PUSH mutez 0 ;
844
                               LAMBDA
845
                                 (pair
846
                                   (pair address
847
                                         (pair bool
848
                                               (pair nat
849
                                                     (pair string
850
                                                           (pair nat
851
                                                                 (pair nat
852
                                                                       (pair nat
853
                                                                             (pair nat
854
                                                                                   (pair
855
                                                                                     timestamp
856
                                                                                     timestamp)))))))))
857
                                   unit)
858
                                 (list operation)
859
                                 { UNPAIR ;
860
                                   UNPAIR ;
861
                                   DIG 2 ;
862
                                   DROP ;
863
                                   CONTRACT %setMintParams (pair (bool %is_private_sale)
864
                                                                 (pair (nat %mint_price)
865
                                                                       (pair
866
                                                                         (string %currency)
867
                                                                         (pair
868
                                                                           (nat %next_token_id)
869
                                                                           (pair
870
                                                                             (nat %total_supply)
871
                                                                             (pair
872
                                                                               (nat %max_mint_per_address)
873
                                                                               (pair
874
                                                                                 (nat %token_per_pack)
875
                                                                                 (pair
876
                                                                                   (timestamp %start_time)
877
                                                                                   (timestamp %end_time))))))))) ;
878
                                   IF_NONE
879
                                     { DROP ;
880
                                       PUSH string "no setMintParams entrypoint" ;
881
                                       FAILWITH }
882
                                     { NIL operation ;
883
                                       SWAP ;
884
                                       PUSH mutez 0 ;
885
                                       DIG 3 ;
886
                                       TRANSFER_TOKENS ;
887
                                       CONS } } ;
888
                               DUP 7 ;
889
                               DUP 7 ;
890
                               PAIR ;
891
                               APPLY ;
892
                               DIG 5 ;
893
                               DIG 6 ;
894
                               DROP 2 ;
895
                               DIG 3 ;
896
                               PAIR ;
897
                               TRANSFER_TOKENS ;
898
                               NIL operation ;
899
                               SWAP ;
900
                               CONS } ;
901
                           PAIR }
902
                         { PUSH nat 0 ;
903
                           DUP 2 ;
904
                           GET 11 ;
905
                           COMPARE ;
906
                           EQ ;
907
                           PUSH nat 0 ;
908
                           DUP 3 ;
909
                           GET 9 ;
910
                           COMPARE ;
911
                           EQ ;
912
                           PUSH nat 0 ;
913
                           DUP 4 ;
914
                           GET 3 ;
915
                           COMPARE ;
916
                           LE ;
917
                           OR ;
918
                           OR ;
919
                           IF
920
                             { DROP 2 ;
921
                               PUSH string "Value should be higher than zero" ;
922
                               FAILWITH }
923
                             { DUP ;
924
                               GET 16 ;
925
                               DUP 2 ;
926
                               GET 15 ;
927
                               COMPARE ;
928
                               GE ;
929
                               IF
930
                                 { DROP 2 ; PUSH string "Invalid date format" ; FAILWITH }
931
                                 { PUSH string "FA12" ;
932
                                   DUP 2 ;
933
                                   GET 5 ;
934
                                   COMPARE ;
935
                                   NEQ ;
936
                                   PUSH string "XTZ" ;
937
                                   DUP 3 ;
938
                                   GET 5 ;
939
                                   COMPARE ;
940
                                   NEQ ;
941
                                   AND ;
942
                                   IF
943
                                     { DROP 2 ; PUSH string "Invalid currency" ; FAILWITH }
944
                                     { SWAP ;
945
                                       DUP 2 ;
946
                                       CAR ;
947
                                       UPDATE 11 ;
948
                                       DUP 2 ;
949
                                       GET 3 ;
950
                                       UPDATE 13 ;
951
                                       DUP 2 ;
952
                                       GET 5 ;
953
                                       UPDATE 34 ;
954
                                       DUP 2 ;
955
                                       GET 7 ;
956
                                       UPDATE 25 ;
957
                                       DUP 2 ;
958
                                       GET 9 ;
959
                                       UPDATE 15 ;
960
                                       DUP 2 ;
961
                                       GET 11 ;
962
                                       UPDATE 19 ;
963
                                       DUP 2 ;
964
                                       GET 13 ;
965
                                       UPDATE 31 ;
966
                                       DUP 2 ;
967
                                       GET 15 ;
968
                                       UPDATE 21 ;
969
                                       SWAP ;
970
                                       GET 16 ;
971
                                       UPDATE 23 ;
972
                                       NIL operation ;
973
                                       PAIR } } } } }
974
                     { DROP ;
975
                       DUP ;
976
                       GET 3 ;
977
                       SENDER ;
978
                       COMPARE ;
979
                       NEQ ;
980
                       IF
981
                         { SELF_ADDRESS ;
982
                           DUP 2 ;
983
                           DIG 2 ;
984
                           GET 3 ;
985
                           CONTRACT %callMultisig (pair
986
                                                    (pair %entrypoint_signature
987
                                                      (string %name)
988
                                                      (pair (bytes %params)
989
                                                            (address %source_contract)))
990
                                                    (lambda %callback unit
991
                                                                      (list operation))) ;
992
                           IF_NONE
993
                             { SWAP ; DROP ; PUSH string "no call entrypoint" ; FAILWITH }
994
                             { UNIT ;
995
                               PACK ;
996
                               SHA256 ;
997
                               SELF_ADDRESS ;
998
                               SWAP ;
999
                               PUSH string "setMintPerAddress" ;
1000
                               PAIR 3 ;
1001
                               SWAP ;
1002
                               PUSH mutez 0 ;
1003
                               LAMBDA
1004
                                 (pair address unit)
1005
                                 (list operation)
1006
                                 { CAR ;
1007
                                   CONTRACT %setMintPerAddress unit ;
1008
                                   IF_NONE
1009
                                     { PUSH string "no setMintPerAddress entrypoint" ;
1010
                                       FAILWITH }
1011
                                     { NIL operation ;
1012
                                       SWAP ;
1013
                                       PUSH mutez 0 ;
1014
                                       UNIT ;
1015
                                       TRANSFER_TOKENS ;
1016
                                       CONS } } ;
1017
                               DUP 6 ;
1018
                               APPLY ;
1019
                               DIG 5 ;
1020
                               DROP ;
1021
                               DIG 3 ;
1022
                               PAIR ;
1023
                               TRANSFER_TOKENS ;
1024
                               NIL operation ;
1025
                               SWAP ;
1026
                               CONS } }
1027
                         { EMPTY_BIG_MAP address nat ; UPDATE 17 ; NIL operation } ;
1028
                       PAIR } } } }
1029
         { IF_LEFT
1030
             { IF_LEFT
1031
                 { IF_LEFT
1032
                     { DUP 2 ;
1033
                       GET 3 ;
1034
                       SENDER ;
1035
                       COMPARE ;
1036
                       NEQ ;
1037
                       IF
1038
                         { SELF_ADDRESS ;
1039
                           DUP 3 ;
1040
                           DIG 3 ;
1041
                           GET 3 ;
1042
                           CONTRACT %callMultisig (pair
1043
                                                    (pair %entrypoint_signature
1044
                                                      (string %name)
1045
                                                      (pair (bytes %params)
1046
                                                            (address %source_contract)))
1047
                                                    (lambda %callback unit
1048
                                                                      (list operation))) ;
1049
                           IF_NONE
1050
                             { SWAP ;
1051
                               DIG 2 ;
1052
                               DROP 2 ;
1053
                               PUSH string "no call entrypoint" ;
1054
                               FAILWITH }
1055
                             { DUP 4 ;
1056
                               PACK ;
1057
                               SHA256 ;
1058
                               SELF_ADDRESS ;
1059
                               SWAP ;
1060
                               PUSH string "setMultisigContract" ;
1061
                               PAIR 3 ;
1062
                               SWAP ;
1063
                               PUSH mutez 0 ;
1064
                               LAMBDA
1065
                                 (pair (pair address address) unit)
1066
                                 (list operation)
1067
                                 { UNPAIR ;
1068
                                   UNPAIR ;
1069
                                   DIG 2 ;
1070
                                   DROP ;
1071
                                   CONTRACT %setMultisigContract address ;
1072
                                   IF_NONE
1073
                                     { DROP ;
1074
                                       PUSH string "no setMultisigContract entrypoint" ;
1075
                                       FAILWITH }
1076
                                     { NIL operation ;
1077
                                       SWAP ;
1078
                                       PUSH mutez 0 ;
1079
                                       DIG 3 ;
1080
                                       TRANSFER_TOKENS ;
1081
                                       CONS } } ;
1082
                               DUP 7 ;
1083
                               DUP 7 ;
1084
                               PAIR ;
1085
                               APPLY ;
1086
                               DIG 5 ;
1087
                               DIG 6 ;
1088
                               DROP 2 ;
1089
                               DIG 3 ;
1090
                               PAIR ;
1091
                               TRANSFER_TOKENS ;
1092
                               NIL operation ;
1093
                               SWAP ;
1094
                               CONS } }
1095
                         { UPDATE 3 ; NIL operation } }
1096
                     { DUP 2 ;
1097
                       GET 3 ;
1098
                       SENDER ;
1099
                       COMPARE ;
1100
                       NEQ ;
1101
                       IF
1102
                         { SELF_ADDRESS ;
1103
                           DUP 3 ;
1104
                           DIG 3 ;
1105
                           GET 3 ;
1106
                           CONTRACT %callMultisig (pair
1107
                                                    (pair %entrypoint_signature
1108
                                                      (string %name)
1109
                                                      (pair (bytes %params)
1110
                                                            (address %source_contract)))
1111
                                                    (lambda %callback unit
1112
                                                                      (list operation))) ;
1113
                           IF_NONE
1114
                             { SWAP ;
1115
                               DIG 2 ;
1116
                               DROP 2 ;
1117
                               PUSH string "no call entrypoint" ;
1118
                               FAILWITH }
1119
                             { DUP 4 ;
1120
                               PACK ;
1121
                               SHA256 ;
1122
                               SELF_ADDRESS ;
1123
                               SWAP ;
1124
                               PUSH string "setNameList" ;
1125
                               PAIR 3 ;
1126
                               SWAP ;
1127
                               PUSH mutez 0 ;
1128
                               LAMBDA
1129
                                 (pair (pair address (map nat bytes)) unit)
1130
                                 (list operation)
1131
                                 { UNPAIR ;
1132
                                   UNPAIR ;
1133
                                   DIG 2 ;
1134
                                   DROP ;
1135
                                   CONTRACT %setNameList (map nat bytes) ;
1136
                                   IF_NONE
1137
                                     { DROP ;
1138
                                       PUSH string "no setNameList entrypoint" ;
1139
                                       FAILWITH }
1140
                                     { NIL operation ;
1141
                                       SWAP ;
1142
                                       PUSH mutez 0 ;
1143
                                       DIG 3 ;
1144
                                       TRANSFER_TOKENS ;
1145
                                       CONS } } ;
1146
                               DUP 7 ;
1147
                               DUP 7 ;
1148
                               PAIR ;
1149
                               APPLY ;
1150
                               DIG 5 ;
1151
                               DIG 6 ;
1152
                               DROP 2 ;
1153
                               DIG 3 ;
1154
                               PAIR ;
1155
                               TRANSFER_TOKENS ;
1156
                               NIL operation ;
1157
                               SWAP ;
1158
                               CONS } }
1159
                         { DUP 2 ;
1160
                           GET 27 ;
1161
                           SWAP ;
1162
                           ITER { SWAP ; DUP 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
1163
                           UPDATE 27 ;
1164
                           NIL operation } } }
1165
                 { IF_LEFT
1166
                     { DUP 2 ;
1167
                       GET 3 ;
1168
                       SENDER ;
1169
                       COMPARE ;
1170
                       NEQ ;
1171
                       IF
1172
                         { SELF_ADDRESS ;
1173
                           DUP 3 ;
1174
                           DIG 3 ;
1175
                           GET 3 ;
1176
                           CONTRACT %callMultisig (pair
1177
                                                    (pair %entrypoint_signature
1178
                                                      (string %name)
1179
                                                      (pair (bytes %params)
1180
                                                            (address %source_contract)))
1181
                                                    (lambda %callback unit
1182
                                                                      (list operation))) ;
1183
                           IF_NONE
1184
                             { SWAP ;
1185
                               DIG 2 ;
1186
                               DROP 2 ;
1187
                               PUSH string "no call entrypoint" ;
1188
                               FAILWITH }
1189
                             { DUP 4 ;
1190
                               PACK ;
1191
                               SHA256 ;
1192
                               SELF_ADDRESS ;
1193
                               SWAP ;
1194
                               PUSH string "setNftAddress" ;
1195
                               PAIR 3 ;
1196
                               SWAP ;
1197
                               PUSH mutez 0 ;
1198
                               LAMBDA
1199
                                 (pair (pair address address) unit)
1200
                                 (list operation)
1201
                                 { UNPAIR ;
1202
                                   UNPAIR ;
1203
                                   DIG 2 ;
1204
                                   DROP ;
1205
                                   CONTRACT %setNftAddress address ;
1206
                                   IF_NONE
1207
                                     { DROP ;
1208
                                       PUSH string "no setNftAddress entrypoint" ;
1209
                                       FAILWITH }
1210
                                     { NIL operation ;
1211
                                       SWAP ;
1212
                                       PUSH mutez 0 ;
1213
                                       DIG 3 ;
1214
                                       TRANSFER_TOKENS ;
1215
                                       CONS } } ;
1216
                               DUP 7 ;
1217
                               DUP 7 ;
1218
                               PAIR ;
1219
                               APPLY ;
1220
                               DIG 5 ;
1221
                               DIG 6 ;
1222
                               DROP 2 ;
1223
                               DIG 3 ;
1224
                               PAIR ;
1225
                               TRANSFER_TOKENS ;
1226
                               NIL operation ;
1227
                               SWAP ;
1228
                               CONS } }
1229
                         { UPDATE 5 ; NIL operation } }
1230
                     { DUP 2 ;
1231
                       GET 3 ;
1232
                       SENDER ;
1233
                       COMPARE ;
1234
                       NEQ ;
1235
                       IF
1236
                         { SELF_ADDRESS ;
1237
                           DUP 3 ;
1238
                           DIG 3 ;
1239
                           GET 3 ;
1240
                           CONTRACT %callMultisig (pair
1241
                                                    (pair %entrypoint_signature
1242
                                                      (string %name)
1243
                                                      (pair (bytes %params)
1244
                                                            (address %source_contract)))
1245
                                                    (lambda %callback unit
1246
                                                                      (list operation))) ;
1247
                           IF_NONE
1248
                             { SWAP ;
1249
                               DIG 2 ;
1250
                               DROP 2 ;
1251
                               PUSH string "no call entrypoint" ;
1252
                               FAILWITH }
1253
                             { DUP 4 ;
1254
                               PACK ;
1255
                               SHA256 ;
1256
                               SELF_ADDRESS ;
1257
                               SWAP ;
1258
                               PUSH string "setPause" ;
1259
                               PAIR 3 ;
1260
                               SWAP ;
1261
                               PUSH mutez 0 ;
1262
                               LAMBDA
1263
                                 (pair (pair address bool) unit)
1264
                                 (list operation)
1265
                                 { UNPAIR ;
1266
                                   UNPAIR ;
1267
                                   DIG 2 ;
1268
                                   DROP ;
1269
                                   CONTRACT %setPause bool ;
1270
                                   IF_NONE
1271
                                     { DROP ;
1272
                                       PUSH string "no setPause entrypoint" ;
1273
                                       FAILWITH }
1274
                                     { NIL operation ;
1275
                                       SWAP ;
1276
                                       PUSH mutez 0 ;
1277
                                       DIG 3 ;
1278
                                       TRANSFER_TOKENS ;
1279
                                       CONS } } ;
1280
                               DUP 7 ;
1281
                               DUP 7 ;
1282
                               PAIR ;
1283
                               APPLY ;
1284
                               DIG 5 ;
1285
                               DIG 6 ;
1286
                               DROP 2 ;
1287
                               DIG 3 ;
1288
                               PAIR ;
1289
                               TRANSFER_TOKENS ;
1290
                               NIL operation ;
1291
                               SWAP ;
1292
                               CONS } }
1293
                         { UPDATE 1 ; NIL operation } } } }
1294
             { DUP 2 ;
1295
               GET 3 ;
1296
               SENDER ;
1297
               COMPARE ;
1298
               NEQ ;
1299
               IF
1300
                 { SELF_ADDRESS ;
1301
                   DUP 3 ;
1302
                   DIG 3 ;
1303
                   GET 3 ;
1304
                   CONTRACT %callMultisig (pair
1305
                                            (pair %entrypoint_signature (string %name)
1306
                                                                        (pair
1307
                                                                          (bytes %params)
1308
                                                                          (address %source_contract)))
1309
                                            (lambda %callback unit (list operation))) ;
1310
                   IF_NONE
1311
                     { SWAP ; DIG 2 ; DROP 2 ; PUSH string "no call entrypoint" ; FAILWITH }
1312
                     { DUP 4 ;
1313
                       PACK ;
1314
                       SHA256 ;
1315
                       SELF_ADDRESS ;
1316
                       SWAP ;
1317
                       PUSH string "setReserveAddress" ;
1318
                       PAIR 3 ;
1319
                       SWAP ;
1320
                       PUSH mutez 0 ;
1321
                       LAMBDA
1322
                         (pair (pair address address) unit)
1323
                         (list operation)
1324
                         { UNPAIR ;
1325
                           UNPAIR ;
1326
                           DIG 2 ;
1327
                           DROP ;
1328
                           CONTRACT %setReserveAddress address ;
1329
                           IF_NONE
1330
                             { DROP ;
1331
                               PUSH string "no setReserveAddress entrypoint" ;
1332
                               FAILWITH }
1333
                             { NIL operation ; SWAP ; PUSH mutez 0 ; DIG 3 ; TRANSFER_TOKENS ; CONS } } ;
1334
                       DUP 7 ;
1335
                       DUP 7 ;
1336
                       PAIR ;
1337
                       APPLY ;
1338
                       DIG 5 ;
1339
                       DIG 6 ;
1340
                       DROP 2 ;
1341
                       DIG 3 ;
1342
                       PAIR ;
1343
                       TRANSFER_TOKENS ;
1344
                       NIL operation ;
1345
                       SWAP ;
1346
                       CONS } }
1347
                 { UPDATE 9 ; NIL operation } } ;
1348
           PAIR } }