BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • DOGAMÍ Alpha Series 2 Minter
operations (24.3K)Storage Code Interact Tokens Fork Statistics Details
Latest
​x
709
1281
 
1
parameter (or
2
            (or
3
              (or
4
                (or
5
                  (or (address %addRevealAdmin)
6
                      (list %addToWhitelist (pair address nat)))
7
                  (or (nat %assignMetadata)
8
                      (pair %burnFromCrowdsale (nat %token_id) (address %from_))))
9
                (or
10
                  (or (pair %mintFromCrowdsale (address %to_) (nat %token_count))
11
                      (list %removeFromWhitelist address))
12
                  (or (address %removeRevealAdmin)
13
                      (pair %reveal
14
                        (pair %metadata
15
                          (pair
16
                            (pair (bytes %artifactUri)
17
                                  (pair %attributes
18
                                    (pair
19
                                      (pair
20
                                        (pair (pair (string %a) (string %b))
21
                                              (pair (string %c) (string %d)))
22
                                        (pair (pair (string %e) (string %f))
23
                                              (pair (string %g) (string %h))))
24
                                      (pair
25
                                        (pair (pair (string %i) (string %j))
26
                                              (pair (string %k) (string %l)))
27
                                        (pair (pair (string %m) (string %n))
28
                                              (pair (string %o) (string %p)))))
29
                                    (pair (pair (string %q) (string %r))
30
                                          (pair (string %s) (string %t)))))
31
                            (pair (bytes %displayUri) (bytes %formats)))
32
                          (pair (nat %metadata_id) (bytes %thumbnailUri)))
33
                        (nat %token_id)))))
34
              (or
35
                (or
36
                  (or
37
                    (list %revealBatch (pair
38
                                        (pair %metadata
39
                                          (pair
40
                                            (pair (bytes %artifactUri)
41
                                                  (pair %attributes
42
                                                    (pair
43
                                                      (pair
44
                                                        (pair
45
                                                          (pair (string %a) (string %b))
46
                                                          (pair (string %c) (string %d)))
47
                                                        (pair
48
                                                          (pair (string %e) (string %f))
49
                                                          (pair (string %g) (string %h))))
50
                                                      (pair
51
                                                        (pair
52
                                                          (pair (string %i) (string %j))
53
                                                          (pair (string %k) (string %l)))
54
                                                        (pair
55
                                                          (pair (string %m) (string %n))
56
                                                          (pair (string %o) (string %p)))))
57
                                                    (pair (pair (string %q) (string %r))
58
                                                          (pair (string %s) (string %t)))))
59
                                            (pair (bytes %displayUri) (bytes %formats)))
60
                                          (pair (nat %metadata_id) (bytes %thumbnailUri)))
61
                                        (nat %token_id)))
62
                    (address %setDogaAddress))
63
                  (or
64
                    (pair %setFreeMetadata
65
                      (pair (map %free_metadata nat nat) (nat %free_metadata_length))
66
                      (nat %version))
67
                    (string %setIpfsHashes)))
68
                (or
69
                  (or
70
                    (pair %setMintParams (bool %is_private_sale)
71
                                         (pair (nat %mint_price)
72
                                               (pair (nat %total_supply)
73
                                                     (pair (nat %max_mint_per_address)
74
                                                           (pair (timestamp %start_time)
75
                                                                 (pair
76
                                                                   (timestamp %end_time)
77
                                                                   (timestamp %reveal_time)))))))
78
                    (unit %setMintPerAddress))
79
                  (or (address %setMultisigContract) (map %setNameList nat bytes)))))
80
            (or
81
              (or (or (address %setNftAddress) (address %setOracleAddress))
82
                  (or (bool %setPause) (pair %setRandomOffset (nat %from_) (nat %to_))))
83
              (or (address %setReserveAddress) (map %setTokenIdToMetadataId nat nat))));
84
storage (pair (bool %paused)
85
              (pair (address %multisig)
86
                    (pair (address %nft_address)
87
                          (pair (address %doga_address)
88
                                (pair (address %reserve_address)
89
                                      (pair (bool %is_private_sale)
90
                                            (pair (nat %mint_price)
91
                                                  (pair (nat %total_supply)
92
                                                        (pair
93
                                                          (big_map %mint_per_address
94
                                                            address
95
                                                            nat)
96
                                                          (pair
97
                                                            (nat %max_mint_per_address)
98
                                                            (pair
99
                                                              (timestamp %start_time)
100
                                                              (pair
101
                                                                (timestamp %end_time)
102
                                                                (pair
103
                                                                  (timestamp %reveal_time)
104
                                                                  (pair
105
                                                                    (big_map %whitelist
106
                                                                      address
107
                                                                      nat)
108
                                                                    (pair
109
                                                                      (big_map %free_metadata_v1
110
                                                                        nat
111
                                                                        nat)
112
                                                                      (pair
113
                                                                        (nat %free_metadata_v1_length)
114
                                                                        (pair
115
                                                                          (big_map %free_metadata_v2
116
                                                                            nat
117
                                                                            nat)
118
                                                                          (pair
119
                                                                            (nat %free_metadata_v2_length)
120
                                                                            (pair
121
                                                                              (big_map %token_id_to_metadata_id
122
                                                                                nat
123
                                                                                nat)
124
                                                                              (pair
125
                                                                                (nat %random_offset)
126
                                                                                (pair
127
                                                                                  (nat %next_token_id)
128
                                                                                  (pair
129
                                                                                    (set %reveal_admins address)
130
                                                                                    (pair
131
                                                                                      (big_map %name_list
132
                                                                                        nat
133
                                                                                        bytes)
134
                                                                                      (pair
135
                                                                                        (address %oracle)
136
                                                                                        (string %ipfs_hashes)))))))))))))))))))))))));
137
code { LAMBDA
138
         (pair
139
           (pair
140
             (pair
141
               (pair
142
                 (pair bytes
143
                       (pair
144
                         (pair
145
                           (pair (pair (pair string string) (pair string string))
146
                                 (pair (pair string string) (pair string string)))
147
                           (pair (pair (pair string string) (pair string string))
148
                                 (pair (pair string string) (pair string string))))
149
                         (pair (pair string string) (pair string string))))
150
                 (pair bytes bytes))
151
               (pair nat bytes))
152
             nat)
153
           (pair
154
             (pair bool
155
                   (pair address
156
                         (pair address
157
                               (pair address
158
                                     (pair address
159
                                           (pair bool
160
                                                 (pair nat
161
                                                       (pair nat
162
                                                             (pair (big_map address nat)
163
                                                                   (pair nat
164
                                                                         (pair timestamp
165
                                                                               (pair
166
                                                                                 timestamp
167
                                                                                 (pair
168
                                                                                   timestamp
169
                                                                                   (pair
170
                                                                                     (big_map
171
                                                                                       address
172
                                                                                       nat)
173
                                                                                     (pair
174
                                                                                       (big_map
175
                                                                                         nat
176
                                                                                         nat)
177
                                                                                       (pair
178
                                                                                         nat
179
                                                                                         (pair
180
                                                                                           (big_map
181
                                                                                             nat
182
                                                                                             nat)
183
                                                                                           (pair
184
                                                                                             nat
185
                                                                                             (pair
186
                                                                                               (big_map
187
                                                                                                 nat
188
                                                                                                 nat)
189
                                                                                               (pair
190
                                                                                                 nat
191
                                                                                                 (pair
192
                                                                                                   nat
193
                                                                                                   (pair
194
                                                                                                     (set address)
195
                                                                                                     (pair
196
                                                                                                       (big_map
197
                                                                                                         nat
198
                                                                                                         bytes)
199
                                                                                                       (pair
200
                                                                                                         address
201
                                                                                                         string))))))))))))))))))))))))
202
             (list operation)))
203
         (pair (list operation)
204
               (pair bool
205
                     (pair address
206
                           (pair address
207
                                 (pair address
208
                                       (pair address
209
                                             (pair bool
210
                                                   (pair nat
211
                                                         (pair nat
212
                                                               (pair
213
                                                                 (big_map address nat)
214
                                                                 (pair nat
215
                                                                       (pair timestamp
216
                                                                             (pair
217
                                                                               timestamp
218
                                                                               (pair
219
                                                                                 timestamp
220
                                                                                 (pair
221
                                                                                   (big_map
222
                                                                                     address
223
                                                                                     nat)
224
                                                                                   (pair
225
                                                                                     (big_map
226
                                                                                       nat
227
                                                                                       nat)
228
                                                                                     (pair
229
                                                                                       nat
230
                                                                                       (pair
231
                                                                                         (big_map
232
                                                                                           nat
233
                                                                                           nat)
234
                                                                                         (pair
235
                                                                                           nat
236
                                                                                           (pair
237
                                                                                             (big_map
238
                                                                                               nat
239
                                                                                               nat)
240
                                                                                             (pair
241
                                                                                               nat
242
                                                                                               (pair
243
                                                                                                 nat
244
                                                                                                 (pair
245
                                                                                                   (set address)
246
                                                                                                   (pair
247
                                                                                                     (big_map
248
                                                                                                       nat
249
                                                                                                       bytes)
250
                                                                                                     (pair
251
                                                                                                       address
252
                                                                                                       string)))))))))))))))))))))))))
253
         { UNPAIR 3 ;
254
           SWAP ;
255
           DUP ;
256
           DUG 2 ;
257
           GET 43 ;
258
           SENDER ;
259
           MEM ;
260
           NOT ;
261
           IF
262
             { DROP 3 ; PUSH string "Unauthorized admin address" ; FAILWITH }
263
             { SWAP ;
264
               DUP ;
265
               DUG 2 ;
266
               GET 37 ;
267
               SWAP ;
268
               DUP ;
269
               DUG 2 ;
270
               CDR ;
271
               GET ;
272
               IF_NONE
273
                 { PUSH string "You have not assigned a metadata yet" ; FAILWITH }
274
                 { SWAP ;
275
                   DUP ;
276
                   DUG 2 ;
277
                   CAR ;
278
                   CDR ;
279
                   CAR ;
280
                   SWAP ;
281
                   DUP ;
282
                   DUG 2 ;
283
                   COMPARE ;
284
                   NEQ ;
285
                   IF
286
                     { DROP ; PUSH string "Token id not matching metadata id" ; FAILWITH }
287
                     { DROP } } ;
288
               SWAP ;
289
               DUP ;
290
               DUG 2 ;
291
               GET 5 ;
292
               CONTRACT %updateMetadataWithFunction (pair
293
                                                      (lambda %metadata_updater
294
                                                        (map string bytes)
295
                                                        (map string bytes))
296
                                                      (nat %token_id)) ;
297
               IF_NONE
298
                 { DROP ;
299
                   PUSH string "NFT contract must have an update metadata with function entrypoint" ;
300
                   FAILWITH }
301
                 { PUSH mutez 0 ;
302
                   DUP 3 ;
303
                   CDR ;
304
                   DIG 3 ;
305
                   LAMBDA
306
                     (pair
307
                       (pair
308
                         (pair
309
                           (pair
310
                             (pair bytes
311
                                   (pair
312
                                     (pair
313
                                       (pair
314
                                         (pair (pair string string) (pair string string))
315
                                         (pair (pair string string) (pair string string)))
316
                                       (pair
317
                                         (pair (pair string string) (pair string string))
318
                                         (pair (pair string string) (pair string string))))
319
                                     (pair (pair string string) (pair string string))))
320
                             (pair bytes bytes))
321
                           (pair nat bytes))
322
                         nat)
323
                       (map string bytes))
324
                     (map string bytes)
325
                     { UNPAIR ;
326
                       DUP ;
327
                       DUG 2 ;
328
                       CAR ;
329
                       CAR ;
330
                       CDR ;
331
                       CDR ;
332
                       SOME ;
333
                       PUSH string "formats" ;
334
                       UPDATE ;
335
                       SWAP ;
336
                       DUP ;
337
                       DUG 2 ;
338
                       CAR ;
339
                       CAR ;
340
                       CAR ;
341
                       CAR ;
342
                       SOME ;
343
                       PUSH string "artifactUri" ;
344
                       UPDATE ;
345
                       SWAP ;
346
                       DUP ;
347
                       DUG 2 ;
348
                       CAR ;
349
                       CAR ;
350
                       CDR ;
351
                       CAR ;
352
                       SOME ;
353
                       PUSH string "displayUri" ;
354
                       UPDATE ;
355
                       SWAP ;
356
                       DUP ;
357
                       DUG 2 ;
358
                       CAR ;
359
                       CDR ;
360
                       CDR ;
361
                       SOME ;
362
                       PUSH string "thumbnailUri" ;
363
                       UPDATE ;
364
                       SWAP ;
365
                       CAR ;
366
                       CAR ;
367
                       CAR ;
368
                       CDR ;
369
                       EMPTY_MAP string (pair (option string) string) ;
370
                       SWAP ;
371
                       DUP ;
372
                       DUG 2 ;
373
                       CDR ;
374
                       CDR ;
375
                       CDR ;
376
                       PUSH string "number" ;
377
                       SOME ;
378
                       PAIR ;
379
                       SOME ;
380
                       PUSH string "Vitality" ;
381
                       UPDATE ;
382
                       SWAP ;
383
                       DUP ;
384
                       DUG 2 ;
385
                       CDR ;
386
                       CDR ;
387
                       CAR ;
388
                       PUSH string "number" ;
389
                       SOME ;
390
                       PAIR ;
391
                       SOME ;
392
                       PUSH string "Strength" ;
393
                       UPDATE ;
394
                       SWAP ;
395
                       DUP ;
396
                       DUG 2 ;
397
                       CDR ;
398
                       CAR ;
399
                       CDR ;
400
                       NONE string ;
401
                       PAIR ;
402
                       SOME ;
403
                       PUSH string "Status" ;
404
                       UPDATE ;
405
                       SWAP ;
406
                       DUP ;
407
                       DUG 2 ;
408
                       CDR ;
409
                       CAR ;
410
                       CAR ;
411
                       NONE string ;
412
                       PAIR ;
413
                       SOME ;
414
                       PUSH string "Size" ;
415
                       UPDATE ;
416
                       SWAP ;
417
                       DUP ;
418
                       DUG 2 ;
419
                       CAR ;
420
                       CDR ;
421
                       CDR ;
422
                       CDR ;
423
                       CDR ;
424
                       NONE string ;
425
                       PAIR ;
426
                       SOME ;
427
                       PUSH string "Secondary personality" ;
428
                       UPDATE ;
429
                       SWAP ;
430
                       DUP ;
431
                       DUG 2 ;
432
                       CAR ;
433
                       CDR ;
434
                       CDR ;
435
                       CDR ;
436
                       CAR ;
437
                       NONE string ;
438
                       PAIR ;
439
                       SOME ;
440
                       PUSH string "Rarity tier" ;
441
                       UPDATE ;
442
                       SWAP ;
443
                       DUP ;
444
                       DUG 2 ;
445
                       CAR ;
446
                       CDR ;
447
                       CDR ;
448
                       CAR ;
449
                       CDR ;
450
                       PUSH string "number" ;
451
                       SOME ;
452
                       PAIR ;
453
                       SOME ;
454
                       PUSH string "Rarity score" ;
455
                       UPDATE ;
456
                       SWAP ;
457
                       DUP ;
458
                       DUG 2 ;
459
                       CAR ;
460
                       CDR ;
461
                       CDR ;
462
                       CAR ;
463
                       CAR ;
464
                       NONE string ;
465
                       PAIR ;
466
                       SOME ;
467
                       PUSH string "Primary personality" ;
468
                       UPDATE ;
469
                       SWAP ;
470
                       DUP ;
471
                       DUG 2 ;
472
                       CAR ;
473
                       CDR ;
474
                       CAR ;
475
                       CDR ;
476
                       CDR ;
477
                       PUSH string "number" ;
478
                       SOME ;
479
                       PAIR ;
480
                       SOME ;
481
                       PUSH string "Obedience" ;
482
                       UPDATE ;
483
                       SWAP ;
484
                       DUP ;
485
                       DUG 2 ;
486
                       CAR ;
487
                       CDR ;
488
                       CAR ;
489
                       CDR ;
490
                       CAR ;
491
                       PUSH string "number" ;
492
                       SOME ;
493
                       PAIR ;
494
                       SOME ;
495
                       PUSH string "Intelligence" ;
496
                       UPDATE ;
497
                       SWAP ;
498
                       DUP ;
499
                       DUG 2 ;
500
                       CAR ;
501
                       CDR ;
502
                       CAR ;
503
                       CAR ;
504
                       CDR ;
505
                       NONE string ;
506
                       PAIR ;
507
                       SOME ;
508
                       PUSH string "Group" ;
509
                       UPDATE ;
510
                       SWAP ;
511
                       DUP ;
512
                       DUG 2 ;
513
                       CAR ;
514
                       CDR ;
515
                       CAR ;
516
                       CAR ;
517
                       CAR ;
518
                       NONE string ;
519
                       PAIR ;
520
                       SOME ;
521
                       PUSH string "Generation" ;
522
                       UPDATE ;
523
                       SWAP ;
524
                       DUP ;
525
                       DUG 2 ;
526
                       CAR ;
527
                       CAR ;
528
                       CDR ;
529
                       CDR ;
530
                       CDR ;
531
                       NONE string ;
532
                       PAIR ;
533
                       SOME ;
534
                       PUSH string "Gender" ;
535
                       UPDATE ;
536
                       SWAP ;
537
                       DUP ;
538
                       DUG 2 ;
539
                       CAR ;
540
                       CAR ;
541
                       CDR ;
542
                       CDR ;
543
                       CAR ;
544
                       NONE string ;
545
                       PAIR ;
546
                       SOME ;
547
                       PUSH string "Fur color" ;
548
                       UPDATE ;
549
                       SWAP ;
550
                       DUP ;
551
                       DUG 2 ;
552
                       CAR ;
553
                       CAR ;
554
                       CDR ;
555
                       CAR ;
556
                       CDR ;
557
                       PUSH string "number" ;
558
                       SOME ;
559
                       PAIR ;
560
                       SOME ;
561
                       PUSH string "Friendliness" ;
562
                       UPDATE ;
563
                       SWAP ;
564
                       DUP ;
565
                       DUG 2 ;
566
                       CAR ;
567
                       CAR ;
568
                       CDR ;
569
                       CAR ;
570
                       CAR ;
571
                       NONE string ;
572
                       PAIR ;
573
                       SOME ;
574
                       PUSH string "Eyes color" ;
575
                       UPDATE ;
576
                       SWAP ;
577
                       DUP ;
578
                       DUG 2 ;
579
                       CAR ;
580
                       CAR ;
581
                       CAR ;
582
                       CDR ;
583
                       CDR ;
584
                       PUSH string "number" ;
585
                       SOME ;
586
                       PAIR ;
587
                       SOME ;
588
                       PUSH string "Breeding count" ;
589
                       UPDATE ;
590
                       SWAP ;
591
                       DUP ;
592
                       DUG 2 ;
593
                       CAR ;
594
                       CAR ;
595
                       CAR ;
596
                       CDR ;
597
                       CAR ;
598
                       NONE string ;
599
                       PAIR ;
600
                       SOME ;
601
                       PUSH string "Breed" ;
602
                       UPDATE ;
603
                       SWAP ;
604
                       DUP ;
605
                       DUG 2 ;
606
                       CAR ;
607
                       CAR ;
608
                       CAR ;
609
                       CAR ;
610
                       CDR ;
611
                       PUSH string "number" ;
612
                       SOME ;
613
                       PAIR ;
614
                       SOME ;
615
                       PUSH string "Bonding level" ;
616
                       UPDATE ;
617
                       SWAP ;
618
                       CAR ;
619
                       CAR ;
620
                       CAR ;
621
                       CAR ;
622
                       CAR ;
623
                       PUSH string "date" ;
624
                       SOME ;
625
                       PAIR ;
626
                       SOME ;
627
                       PUSH string "Birthday" ;
628
                       UPDATE ;
629
                       PACK ;
630
                       SOME ;
631
                       PUSH string "attributes" ;
632
                       UPDATE } ;
633
                   SWAP ;
634
                   APPLY ;
635
                   PAIR ;
636
                   TRANSFER_TOKENS } ;
637
               SWAP ;
638
               DUG 2 ;
639
               CONS ;
640
               PAIR } } ;
641
       SWAP ;
642
       UNPAIR ;
643
       IF_LEFT
644
         { IF_LEFT
645
             { IF_LEFT
646
                 { DIG 2 ;
647
                   DROP ;
648
                   IF_LEFT
649
                     { IF_LEFT
650
                         { SWAP ;
651
                           DUP ;
652
                           DUG 2 ;
653
                           GET 3 ;
654
                           SENDER ;
655
                           COMPARE ;
656
                           NEQ ;
657
                           IF
658
                             { SELF_ADDRESS ;
659
                               DIG 2 ;
660
                               DUP ;
661
                               GET 3 ;
662
                               CONTRACT %callMultisig (pair
663
                                                        (pair %entrypoint_signature
664
                                                          (string %name)
665
                                                          (pair (bytes %params)
666
                                                                (address %source_contract)))
667
                                                        (lambda %callback unit
668
                                                                          (list operation))) ;
669
                               IF_NONE
670
                                 { SWAP ;
671
                                   DIG 2 ;
672
                                   DROP 2 ;
673
                                   PUSH string "no call entrypoint" ;
674
                                   FAILWITH }
675
                                 { SELF_ADDRESS ;
676
                                   DUP 5 ;
677
                                   PACK ;
678
                                   SHA256 ;
679
                                   PUSH string "addRevealAdmin" ;
680
                                   PAIR 3 ;
681
                                   SWAP ;
682
                                   PUSH mutez 0 ;
683
                                   DIG 5 ;
684
                                   DIG 5 ;
685
                                   PAIR ;
686
                                   LAMBDA
687
                                     (pair (pair address address) unit)
688
                                     (list operation)
689
                                     { CAR ;
690
                                       UNPAIR ;
691
                                       CONTRACT %addRevealAdmin address ;
692
                                       IF_NONE
693
                                         { DROP ;
694
                                           PUSH string "no addRevealAdmin entrypoint" ;
695
                                           FAILWITH }
696
                                         { NIL operation ;
697
                                           SWAP ;
698
                                           PUSH mutez 0 ;
699
                                           DIG 3 ;
700
                                           TRANSFER_TOKENS ;
701
                                           CONS } } ;
702
                                   SWAP ;
703
                                   APPLY ;
704
                                   DIG 3 ;
705
                                   PAIR ;
706
                                   TRANSFER_TOKENS ;
707
                                   NIL operation ;
708
                                   SWAP ;
709
                                   CONS } ;
710
                               PAIR }
711
                             { SWAP ;
712
                               DUP ;
713
                               GET 43 ;
714
                               DIG 2 ;
715
                               PUSH bool True ;
716
                               SWAP ;
717
                               UPDATE ;
718
                               UPDATE 43 ;
719
                               NIL operation ;
720
                               PAIR } }
721
                         { SWAP ;
722
                           DUP ;
723
                           DUG 2 ;
724
                           GET 3 ;
725
                           SENDER ;
726
                           COMPARE ;
727
                           NEQ ;
728
                           IF
729
                             { SELF_ADDRESS ;
730
                               DIG 2 ;
731
                               DUP ;
732
                               GET 3 ;
733
                               CONTRACT %callMultisig (pair
734
                                                        (pair %entrypoint_signature
735
                                                          (string %name)
736
                                                          (pair (bytes %params)
737
                                                                (address %source_contract)))
738
                                                        (lambda %callback unit
739
                                                                          (list operation))) ;
740
                               IF_NONE
741
                                 { SWAP ;
742
                                   DIG 2 ;
743
                                   DROP 2 ;
744
                                   PUSH string "no call entrypoint" ;
745
                                   FAILWITH }
746
                                 { SELF_ADDRESS ;
747
                                   DUP 5 ;
748
                                   PACK ;
749
                                   SHA256 ;
750
                                   PUSH string "addToWhitelist" ;
751
                                   PAIR 3 ;
752
                                   SWAP ;
753
                                   PUSH mutez 0 ;
754
                                   DIG 5 ;
755
                                   DIG 5 ;
756
                                   PAIR ;
757
                                   LAMBDA
758
                                     (pair (pair address (list (pair address nat))) unit)
759
                                     (list operation)
760
                                     { CAR ;
761
                                       UNPAIR ;
762
                                       CONTRACT %addToWhitelist (list (pair address nat)) ;
763
                                       IF_NONE
764
                                         { DROP ;
765
                                           PUSH string "no addToWhitelist entrypoint" ;
766
                                           FAILWITH }
767
                                         { NIL operation ;
768
                                           SWAP ;
769
                                           PUSH mutez 0 ;
770
                                           DIG 3 ;
771
                                           TRANSFER_TOKENS ;
772
                                           CONS } } ;
773
                                   SWAP ;
774
                                   APPLY ;
775
                                   DIG 3 ;
776
                                   PAIR ;
777
                                   TRANSFER_TOKENS ;
778
                                   NIL operation ;
779
                                   SWAP ;
780
                                   CONS } ;
781
                               PAIR }
782
                             { SWAP ;
783
                               DUP ;
784
                               DUG 2 ;
785
                               GET 27 ;
786
                               SWAP ;
787
                               ITER { DUP ; DUG 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
788
                               UPDATE 27 ;
789
                               NIL operation ;
790
                               PAIR } } }
791
                     { IF_LEFT
792
                         { PUSH bool True ;
793
                           DUP 3 ;
794
                           CAR ;
795
                           COMPARE ;
796
                           EQ ;
797
                           IF
798
                             { DROP 2 ; PUSH string "Contract in pause" ; FAILWITH }
799
                             { DUP ;
800
                               SENDER ;
801
                               PAIR ;
802
                               DUP 3 ;
803
                               GET 37 ;
804
                               DUP 3 ;
805
                               GET ;
806
                               IF_NONE
807
                                 {}
808
                                 { DROP ;
809
                                   PUSH string "Token already has an assigned metadata" ;
810
                                   FAILWITH } ;
811
                               DUP 3 ;
812
                               GET 5 ;
813
                               SWAP ;
814
                               VIEW "balance_of_view" nat ;
815
                               IF_NONE
816
                                 { DROP 2 ; PUSH string "View returned an error" ; FAILWITH }
817
                                 { PUSH nat 1 ;
818
                                   SWAP ;
819
                                   COMPARE ;
820
                                   NEQ ;
821
                                   IF
822
                                     { DROP 2 ;
823
                                       PUSH string "You do not own this token" ;
824
                                       FAILWITH }
825
                                     { PUSH nat 8000 ;
826
                                       SWAP ;
827
                                       DUP ;
828
                                       DUG 2 ;
829
                                       COMPARE ;
830
                                       LE ;
831
                                       IF
832
                                         { PUSH nat 1 ;
833
                                           DUP 3 ;
834
                                           GET 31 ;
835
                                           COMPARE ;
836
                                           LT ;
837
                                           IF
838
                                             { DROP 2 ;
839
                                               PUSH string "No free metadata available" ;
840
                                               FAILWITH }
841
                                             { LEVEL ;
842
                                               DUP 3 ;
843
                                               GET 39 ;
844
                                               ADD ;
845
                                               PUSH nat 1 ;
846
                                               DUP 4 ;
847
                                               GET 31 ;
848
                                               DIG 2 ;
849
                                               EDIV ;
850
                                               IF_NONE
851
                                                 { PUSH string "MOD by 0" ; FAILWITH }
852
                                                 {} ;
853
                                               CDR ;
854
                                               ADD ;
855
                                               DUP 3 ;
856
                                               GET 29 ;
857
                                               SWAP ;
858
                                               DUP ;
859
                                               DUG 2 ;
860
                                               GET ;
861
                                               IF_NONE
862
                                                 { PUSH string "Index does not exist" ;
863
                                                   FAILWITH }
864
                                                 {} ;
865
                                               DUP 4 ;
866
                                               GET 29 ;
867
                                               DUP 5 ;
868
                                               GET 31 ;
869
                                               GET ;
870
                                               IF_NONE
871
                                                 { PUSH string "Did not find tail metadata id" ;
872
                                                   FAILWITH }
873
                                                 {} ;
874
                                               PUSH int 1 ;
875
                                               DUP 6 ;
876
                                               GET 31 ;
877
                                               SUB ;
878
                                               ISNAT ;
879
                                               IF_NONE { PUSH nat 0 } {} ;
880
                                               DUP 6 ;
881
                                               DUP 4 ;
882
                                               UPDATE 39 ;
883
                                               DUP 7 ;
884
                                               GET 37 ;
885
                                               DIG 4 ;
886
                                               SOME ;
887
                                               DIG 6 ;
888
                                               UPDATE ;
889
                                               UPDATE 37 ;
890
                                               DUP 5 ;
891
                                               GET 29 ;
892
                                               DIG 3 ;
893
                                               SOME ;
894
                                               DIG 4 ;
895
                                               UPDATE ;
896
                                               NONE nat ;
897
                                               DIG 4 ;
898
                                               GET 31 ;
899
                                               UPDATE ;
900
                                               UPDATE 29 ;
901
                                               SWAP ;
902
                                               UPDATE 31 ;
903
                                               NIL operation ;
904
                                               PAIR } }
905
                                         { PUSH nat 12000 ;
906
                                           SWAP ;
907
                                           DUP ;
908
                                           DUG 2 ;
909
                                           COMPARE ;
910
                                           LE ;
911
                                           IF
912
                                             { NOW ;
913
                                               DUP 3 ;
914
                                               GET 25 ;
915
                                               COMPARE ;
916
                                               GT ;
917
                                               IF
918
                                                 { DROP 2 ;
919
                                                   PUSH string "Reveal period is not open" ;
920
                                                   FAILWITH }
921
                                                 { PUSH nat 1 ;
922
                                                   DUP 3 ;
923
                                                   GET 35 ;
924
                                                   COMPARE ;
925
                                                   LT ;
926
                                                   IF
927
                                                     { DROP 2 ;
928
                                                       PUSH string "No free metadata available" ;
929
                                                       FAILWITH }
930
                                                     { LEVEL ;
931
                                                       DUP 3 ;
932
                                                       GET 39 ;
933
                                                       ADD ;
934
                                                       PUSH nat 1 ;
935
                                                       DUP 4 ;
936
                                                       GET 35 ;
937
                                                       DIG 2 ;
938
                                                       EDIV ;
939
                                                       IF_NONE
940
                                                         { PUSH string "MOD by 0" ;
941
                                                           FAILWITH }
942
                                                         {} ;
943
                                                       CDR ;
944
                                                       ADD ;
945
                                                       DUP 3 ;
946
                                                       GET 33 ;
947
                                                       SWAP ;
948
                                                       DUP ;
949
                                                       DUG 2 ;
950
                                                       GET ;
951
                                                       IF_NONE
952
                                                         { PUSH string "Index does not exist" ;
953
                                                           FAILWITH }
954
                                                         {} ;
955
                                                       DUP 4 ;
956
                                                       GET 33 ;
957
                                                       DUP 5 ;
958
                                                       GET 35 ;
959
                                                       GET ;
960
                                                       IF_NONE
961
                                                         { PUSH string "Did not find tail metadata id" ;
962
                                                           FAILWITH }
963
                                                         {} ;
964
                                                       PUSH int 1 ;
965
                                                       DUP 6 ;
966
                                                       GET 35 ;
967
                                                       SUB ;
968
                                                       ISNAT ;
969
                                                       IF_NONE { PUSH nat 0 } {} ;
970
                                                       DUP 6 ;
971
                                                       DUP 4 ;
972
                                                       UPDATE 39 ;
973
                                                       DUP 7 ;
974
                                                       GET 37 ;
975
                                                       DIG 4 ;
976
                                                       SOME ;
977
                                                       DIG 6 ;
978
                                                       UPDATE ;
979
                                                       UPDATE 37 ;
980
                                                       DUP 5 ;
981
                                                       GET 33 ;
982
                                                       DIG 3 ;
983
                                                       SOME ;
984
                                                       DIG 4 ;
985
                                                       UPDATE ;
986
                                                       NONE nat ;
987
                                                       DIG 4 ;
988
                                                       GET 35 ;
989
                                                       UPDATE ;
990
                                                       UPDATE 33 ;
991
                                                       SWAP ;
992
                                                       UPDATE 35 ;
993
                                                       NIL operation ;
994
                                                       PAIR } } }
995
                                             { DROP 2 ;
996
                                               PUSH string "token_id out of range" ;
997
                                               FAILWITH } } } } } }
998
                         { SWAP ;
999
                           DUP ;
1000
                           DUG 2 ;
1001
                           GET 3 ;
1002
                           SENDER ;
1003
                           COMPARE ;
1004
                           NEQ ;
1005
                           IF
1006
                             { SELF_ADDRESS ;
1007
                               DIG 2 ;
1008
                               DUP ;
1009
                               GET 3 ;
1010
                               CONTRACT %callMultisig (pair
1011
                                                        (pair %entrypoint_signature
1012
                                                          (string %name)
1013
                                                          (pair (bytes %params)
1014
                                                                (address %source_contract)))
1015
                                                        (lambda %callback unit
1016
                                                                          (list operation))) ;
1017
                               IF_NONE
1018
                                 { SWAP ;
1019
                                   DIG 2 ;
1020
                                   DROP 2 ;
1021
                                   PUSH string "no call entrypoint" ;
1022
                                   FAILWITH }
1023
                                 { SELF_ADDRESS ;
1024
                                   DUP 5 ;
1025
                                   PACK ;
1026
                                   SHA256 ;
1027
                                   PUSH string "burnFromCrowdsale" ;
1028
                                   PAIR 3 ;
1029
                                   SWAP ;
1030
                                   PUSH mutez 0 ;
1031
                                   DIG 5 ;
1032
                                   DIG 5 ;
1033
                                   PAIR ;
1034
                                   LAMBDA
1035
                                     (pair (pair address (pair nat address)) unit)
1036
                                     (list operation)
1037
                                     { CAR ;
1038
                                       UNPAIR ;
1039
                                       CONTRACT %burnFromCrowdsale (pair (nat %token_id)
1040
                                                                         (address %from_)) ;
1041
                                       IF_NONE
1042
                                         { DROP ;
1043
                                           PUSH string "no burnFromCrowdsale entrypoint" ;
1044
                                           FAILWITH }
1045
                                         { NIL operation ;
1046
                                           SWAP ;
1047
                                           PUSH mutez 0 ;
1048
                                           DIG 3 ;
1049
                                           TRANSFER_TOKENS ;
1050
                                           CONS } } ;
1051
                                   SWAP ;
1052
                                   APPLY ;
1053
                                   DIG 3 ;
1054
                                   PAIR ;
1055
                                   TRANSFER_TOKENS ;
1056
                                   NIL operation ;
1057
                                   SWAP ;
1058
                                   CONS } ;
1059
                               PAIR }
1060
                             { PUSH bool True ;
1061
                               DUP 3 ;
1062
                               CAR ;
1063
                               COMPARE ;
1064
                               EQ ;
1065
                               IF
1066
                                 { DROP 2 ; PUSH string "Contract in pause" ; FAILWITH }
1067
                                 { SWAP ;
1068
                                   DUP ;
1069
                                   DUG 2 ;
1070
                                   GET 5 ;
1071
                                   CONTRACT %burn (pair (nat %token_id) (address %from_)) ;
1072
                                   IF_NONE
1073
                                     { DROP ;
1074
                                       PUSH string "NFT contract must have a burn entrypoint" ;
1075
                                       FAILWITH }
1076
                                     { PUSH mutez 0 ; DIG 2 ; TRANSFER_TOKENS } ;
1077
                                   SWAP ;
1078
                                   NIL operation ;
1079
                                   DIG 2 ;
1080
                                   CONS ;
1081
                                   PAIR } } } } }
1082
                 { IF_LEFT
1083
                     { DIG 2 ;
1084
                       DROP ;
1085
                       IF_LEFT
1086
                         { PUSH nat 1 ;
1087
                           SWAP ;
1088
                           DUP ;
1089
                           DUG 2 ;
1090
                           CDR ;
1091
                           COMPARE ;
1092
                           LT ;
1093
                           IF
1094
                             { DROP 2 ;
1095
                               PUSH string "Value should be higher than zero" ;
1096
                               FAILWITH }
1097
                             { PUSH bool True ;
1098
                               DUP 3 ;
1099
                               CAR ;
1100
                               COMPARE ;
1101
                               EQ ;
1102
                               IF
1103
                                 { DROP 2 ; PUSH string "Contract in pause" ; FAILWITH }
1104
                                 { SWAP ;
1105
                                   DUP ;
1106
                                   DUG 2 ;
1107
                                   GET 23 ;
1108
                                   NOW ;
1109
                                   COMPARE ;
1110
                                   GE ;
1111
                                   DUP 3 ;
1112
                                   GET 21 ;
1113
                                   NOW ;
1114
                                   COMPARE ;
1115
                                   LT ;
1116
                                   OR ;
1117
                                   IF
1118
                                     { DROP 2 ;
1119
                                       PUSH string "Mint period is not open" ;
1120
                                       FAILWITH }
1121
                                     { SWAP ;
1122
                                       DUP ;
1123
                                       DUG 2 ;
1124
                                       GET 11 ;
1125
                                       IF
1126
                                         { SWAP ;
1127
                                           DUP ;
1128
                                           DUG 2 ;
1129
                                           GET 27 ;
1130
                                           SWAP ;
1131
                                           DUP ;
1132
                                           DUG 2 ;
1133
                                           CAR ;
1134
                                           GET ;
1135
                                           IF_NONE
1136
                                             { PUSH string "Address is not whitelisted" ;
1137
                                               FAILWITH }
1138
                                             {} }
1139
                                         { PUSH nat 0 } ;
1140
                                       DROP ;
1141
                                       SWAP ;
1142
                                       DUP ;
1143
                                       DUG 2 ;
1144
                                       GET 13 ;
1145
                                       SWAP ;
1146
                                       DUP ;
1147
                                       DUG 2 ;
1148
                                       CDR ;
1149
                                       MUL ;
1150
                                       NIL operation ;
1151
                                       SWAP ;
1152
                                       DUP 4 ;
1153
                                       GET 9 ;
1154
                                       SENDER ;
1155
                                       DUP 6 ;
1156
                                       GET 7 ;
1157
                                       PAIR 4 ;
1158
                                       UNPAIR 4 ;
1159
                                       CONTRACT %transfer (pair (address %from)
1160
                                                                (pair (address %to)
1161
                                                                      (nat %value))) ;
1162
                                       IF_NONE
1163
                                         { PUSH string "FA1.2 contract must have a transfer entrypoint" ;
1164
                                           FAILWITH }
1165
                                         {} ;
1166
                                       PUSH mutez 0 ;
1167
                                       DIG 4 ;
1168
                                       DIG 4 ;
1169
                                       DIG 4 ;
1170
                                       PAIR 3 ;
1171
                                       TRANSFER_TOKENS ;
1172
                                       CONS ;
1173
                                       DUP 3 ;
1174
                                       SWAP ;
1175
                                       PAIR ;
1176
                                       SWAP ;
1177
                                       DUP ;
1178
                                       DUG 2 ;
1179
                                       CDR ;
1180
                                       PAIR ;
1181
                                       LEFT (pair (list operation)
1182
                                                  (pair bool
1183
                                                        (pair address
1184
                                                              (pair address
1185
                                                                    (pair address
1186
                                                                          (pair address
1187
                                                                                (pair
1188
                                                                                  bool
1189
                                                                                  (pair
1190
                                                                                    nat
1191
                                                                                    (pair
1192
                                                                                      nat
1193
                                                                                      (pair
1194
                                                                                        (big_map
1195
                                                                                          address
1196
                                                                                          nat)
1197
                                                                                        (pair
1198
                                                                                          nat
1199
                                                                                          (pair
1200
                                                                                            timestamp
1201
                                                                                            (pair
1202
                                                                                              timestamp
1203
                                                                                              (pair
1204
                                                                                                timestamp
1205
                                                                                                (pair
1206
                                                                                                  (big_map
1207
                                                                                                    address
1208
                                                                                                    nat)
1209
                                                                                                  (pair
1210
                                                                                                    (big_map
1211
                                                                                                      nat
1212
                                                                                                      nat)
1213
                                                                                                    (pair
1214
                                                                                                      nat
1215
                                                                                                      (pair
1216
                                                                                                        (big_map
1217
                                                                                                          nat
1218
                                                                                                          nat)
1219
                                                                                                        (pair
1220
                                                                                                          nat
1221
                                                                                                          (pair
1222
                                                                                                            (big_map
1223
                                                                                                              nat
1224
                                                                                                              nat)
1225
                                                                                                            (pair
1226
                                                                                                              nat
1227
                                                                                                              (pair
1228
                                                                                                                nat
1229
                                                                                                                (pair
1230
                                                                                                                  (set address)
1231
                                                                                                                  (pair
1232
                                                                                                                    (big_map
1233
                                                                                                                      nat
1234
                                                                                                                      bytes)
1235
                                                                                                                    (pair
1236
                                                                                                                      address
1237
                                                                                                                      string))))))))))))))))))))))))) ;
1238
                                       LOOP_LEFT { UNPAIR ;
1239
                                                   PUSH nat 1 ;
1240
                                                   SWAP ;
1241
                                                   DUP ;
1242
                                                   DUG 2 ;
1243
                                                   COMPARE ;
1244
                                                   LT ;
1245
                                                   IF
1246
                                                     { DROP ;
1247
                                                       RIGHT (pair nat
1248
                                                                   (pair
1249
                                                                     (list operation)
1250
                                                                     (pair bool
1251
                                                                           (pair address
1252
                                                                                 (pair
1253
                                                                                   address
1254
                                                                                   (pair
1255
                                                                                     address
1256
                                                                                     (pair
1257
                                                                                       address
1258
                                                                                       (pair
1259
                                                                                         bool
1260
                                                                                         (pair
1261
                                                                                           nat
1262
                                                                                           (pair
1263
                                                                                             nat
1264
                                                                                             (pair
1265
                                                                                               (big_map
1266
                                                                                                 address
1267
                                                                                                 nat)
1268
                                                                                               (pair
1269
                                                                                                 nat
1270
                                                                                                 (pair
1271
                                                                                                   timestamp
1272
                                                                                                   (pair
1273
                                                                                                     timestamp
1274
                                                                                                     (pair
1275
                                                                                                       timestamp
1276
                                                                                                       (pair
1277
                                                                                                         (big_map
1278
                                                                                                           address
1279
                                                                                                           nat)
1280
                                                                                                         (pair
1281
                                                                                                           (big_map
1282
                                                                                                             nat
1283
                                                                                                             nat)
1284
                                                                                                           (pair
1285
                                                                                                             nat
1286
                                                                                                             (pair
1287
                                                                                                               (big_map
1288
                                                                                                                 nat
1289
                                                                                                                 nat)
1290
                                                                                                               (pair
1291
                                                                                                                 nat
1292
                                                                                                                 (pair
1293
                                                                                                                   (big_map
1294
                                                                                                                     nat
1295
                                                                                                                     nat)
1296
                                                                                                                   (pair
1297
                                                                                                                     nat
1298
                                                                                                                     (pair
1299
                                                                                                                       nat
1300
                                                                                                                       (pair
1301
                                                                                                                         (set address)
1302
                                                                                                                         (pair
1303
                                                                                                                           (big_map
1304
                                                                                                                             nat
1305
                                                                                                                             bytes)
1306
                                                                                                                           (pair
1307
                                                                                                                             address
1308
                                                                                                                             string)))))))))))))))))))))))))) }
1309
                                                     { DUP 4 ;
1310
                                                       GET 15 ;
1311
                                                       DUP 3 ;
1312
                                                       CDR ;
1313
                                                       GET 41 ;
1314
                                                       COMPARE ;
1315
                                                       GT ;
1316
                                                       IF
1317
                                                         { DROP 2 ;
1318
                                                           PUSH string "Total supply reached" ;
1319
                                                           FAILWITH }
1320
                                                         { SWAP ;
1321
                                                           DUP ;
1322
                                                           DUG 2 ;
1323
                                                           CDR ;
1324
                                                           GET 17 ;
1325
                                                           DUP 4 ;
1326
                                                           CAR ;
1327
                                                           GET ;
1328
                                                           IF_NONE
1329
                                                             { PUSH nat 0 }
1330
                                                             { DUP 5 ;
1331
                                                               GET 19 ;
1332
                                                               SWAP ;
1333
                                                               DUP ;
1334
                                                               DUG 2 ;
1335
                                                               COMPARE ;
1336
                                                               GE ;
1337
                                                               IF
1338
                                                                 { DROP ;
1339
                                                                   PUSH string "Max mint per address reached" ;
1340
                                                                   FAILWITH }
1341
                                                                 {} } ;
1342
                                                           DUP 3 ;
1343
                                                           CDR ;
1344
                                                           GET 5 ;
1345
                                                           CONTRACT %mint (pair
1346
                                                                            (pair
1347
                                                                              (address %to_)
1348
                                                                              (nat %token_id))
1349
                                                                            (map %token_info
1350
                                                                              string
1351
                                                                              bytes)) ;
1352
                                                           IF_NONE
1353
                                                             { PUSH string "NFT contract must have a mint entrypoint" ;
1354
                                                               FAILWITH }
1355
                                                             { PUSH mutez 0 ;
1356
                                                               EMPTY_MAP string bytes ;
1357
                                                               PUSH bytes 0x697066733a2f2f516d5151687a766556587376566d46397a76673457344239415a47454d77473639615833655244474a704e4d4874 ;
1358
                                                               SOME ;
1359
                                                               PUSH string "thumbnailUri" ;
1360
                                                               UPDATE ;
1361
                                                               PUSH bytes 0x7b22646563696d616c73223a20322c2022736861726573223a207b22747a31626a394e784b59757073375743466d79746b594a547736727874697a4a5237394b223a20377d7d ;
1362
                                                               SOME ;
1363
                                                               PUSH string "royalties" ;
1364
                                                               UPDATE ;
1365
                                                               PUSH bytes 0x28632920444f47414d492e20416c6c205269676874732052657365727665642e ;
1366
                                                               SOME ;
1367
                                                               PUSH string "rights" ;
1368
                                                               UPDATE ;
1369
                                                               DUP 6 ;
1370
                                                               CDR ;
1371
                                                               GET 45 ;
1372
                                                               DUP 7 ;
1373
                                                               CDR ;
1374
                                                               GET 41 ;
1375
                                                               GET ;
1376
                                                               IF_NONE
1377
                                                                 { PUSH bytes 0x446f67616d69 }
1378
                                                                 {} ;
1379
                                                               SOME ;
1380
                                                               PUSH string "name" ;
1381
                                                               UPDATE ;
1382
                                                               PUSH bytes 0x74727565 ;
1383
                                                               SOME ;
1384
                                                               PUSH string "isBooleanAmount" ;
1385
                                                               UPDATE ;
1386
                                                               PUSH bytes 0x5b7b226d696d6554797065223a2022766964656f2f6d7034222c2022757269223a2022697066733a2f2f516d53514b474439574e685352525147667a446269486a6f46474b64647752427a73733753535265695678536654227d2c207b226d696d6554797065223a2022696d6167652f676966222c2022757269223a2022697066733a2f2f516d516677385a6855354448623759344e364878325a7867366854446138773179705931764857434b684e4b776f227d2c207b226d696d6554797065223a2022696d6167652f676966222c2022757269223a2022697066733a2f2f516d5151687a766556587376566d46397a76673457344239415a47454d77473639615833655244474a704e4d4874227d5d ;
1387
                                                               SOME ;
1388
                                                               PUSH string "formats" ;
1389
                                                               UPDATE ;
1390
                                                               PUSH bytes 0x697066733a2f2f516d516677385a6855354448623759344e364878325a7867366854446138773179705931764857434b684e4b776f ;
1391
                                                               SOME ;
1392
                                                               PUSH string "displayUri" ;
1393
                                                               UPDATE ;
1394
                                                               PUSH bytes 0x596f75722074727565207669727475616c20636f6d70616e696f6e21 ;
1395
                                                               SOME ;
1396
                                                               PUSH string "description" ;
1397
                                                               UPDATE ;
1398
                                                               PUSH bytes 0x30 ;
1399
                                                               SOME ;
1400
                                                               PUSH string "decimals" ;
1401
                                                               UPDATE ;
1402
                                                               PUSH bytes 0x5b22444f47414d49225d ;
1403
                                                               SOME ;
1404
                                                               PUSH string "creators" ;
1405
                                                               UPDATE ;
1406
                                                               EMPTY_MAP string
1407
                                                                          (pair
1408
                                                                            (option string)
1409
                                                                            string) ;
1410
                                                               PUSH string "Box" ;
1411
                                                               NONE string ;
1412
                                                               PAIR ;
1413
                                                               SOME ;
1414
                                                               PUSH string "Status" ;
1415
                                                               UPDATE ;
1416
                                                               PUSH string "Alpha 2" ;
1417
                                                               NONE string ;
1418
                                                               PAIR ;
1419
                                                               SOME ;
1420
                                                               PUSH string "Generation" ;
1421
                                                               UPDATE ;
1422
                                                               PACK ;
1423
                                                               SOME ;
1424
                                                               PUSH string "attributes" ;
1425
                                                               UPDATE ;
1426
                                                               PUSH bytes 0x697066733a2f2f516d53514b474439574e685352525147667a446269486a6f46474b64647752427a73733753535265695678536654 ;
1427
                                                               SOME ;
1428
                                                               PUSH string "artifactUri" ;
1429
                                                               UPDATE ;
1430
                                                               DUP 6 ;
1431
                                                               CDR ;
1432
                                                               GET 41 ;
1433
                                                               DUP 8 ;
1434
                                                               CAR ;
1435
                                                               PAIR ;
1436
                                                               PAIR ;
1437
                                                               TRANSFER_TOKENS } ;
1438
                                                           DUP 4 ;
1439
                                                           CDR ;
1440
                                                           GET 17 ;
1441
                                                           PUSH nat 1 ;
1442
                                                           DIG 3 ;
1443
                                                           ADD ;
1444
                                                           SOME ;
1445
                                                           DUP 6 ;
1446
                                                           CAR ;
1447
                                                           UPDATE ;
1448
                                                           PUSH nat 1 ;
1449
                                                           DUP 5 ;
1450
                                                           CDR ;
1451
                                                           GET 41 ;
1452
                                                           ADD ;
1453
                                                           PUSH nat 1 ;
1454
                                                           DIG 4 ;
1455
                                                           SUB ;
1456
                                                           ISNAT ;
1457
                                                           IF_NONE
1458
                                                             { DROP 4 ;
1459
                                                               PUSH string "Invalid nat value" ;
1460
                                                               FAILWITH }
1461
                                                             { DUP 5 ;
1462
                                                               CDR ;
1463
                                                               DUP 6 ;
1464
                                                               CDR ;
1465
                                                               GET 45 ;
1466
                                                               NONE bytes ;
1467
                                                               DUP 8 ;
1468
                                                               CDR ;
1469
                                                               GET 41 ;
1470
                                                               UPDATE ;
1471
                                                               UPDATE 45 ;
1472
                                                               DIG 2 ;
1473
                                                               UPDATE 41 ;
1474
                                                               DIG 2 ;
1475
                                                               UPDATE 17 ;
1476
                                                               DIG 3 ;
1477
                                                               CAR ;
1478
                                                               DIG 3 ;
1479
                                                               CONS ;
1480
                                                               PAIR ;
1481
                                                               SWAP ;
1482
                                                               PAIR ;
1483
                                                               LEFT (pair
1484
                                                                      (list operation)
1485
                                                                      (pair bool
1486
                                                                            (pair
1487
                                                                              address
1488
                                                                              (pair
1489
                                                                                address
1490
                                                                                (pair
1491
                                                                                  address
1492
                                                                                  (pair
1493
                                                                                    address
1494
                                                                                    (pair
1495
                                                                                      bool
1496
                                                                                      (pair
1497
                                                                                        nat
1498
                                                                                        (pair
1499
                                                                                          nat
1500
                                                                                          (pair
1501
                                                                                            (big_map
1502
                                                                                              address
1503
                                                                                              nat)
1504
                                                                                            (pair
1505
                                                                                              nat
1506
                                                                                              (pair
1507
                                                                                                timestamp
1508
                                                                                                (pair
1509
                                                                                                  timestamp
1510
                                                                                                  (pair
1511
                                                                                                    timestamp
1512
                                                                                                    (pair
1513
                                                                                                      (big_map
1514
                                                                                                        address
1515
                                                                                                        nat)
1516
                                                                                                      (pair
1517
                                                                                                        (big_map
1518
                                                                                                          nat
1519
                                                                                                          nat)
1520
                                                                                                        (pair
1521
                                                                                                          nat
1522
                                                                                                          (pair
1523
                                                                                                            (big_map
1524
                                                                                                              nat
1525
                                                                                                              nat)
1526
                                                                                                            (pair
1527
                                                                                                              nat
1528
                                                                                                              (pair
1529
                                                                                                                (big_map
1530
                                                                                                                  nat
1531
                                                                                                                  nat)
1532
                                                                                                                (pair
1533
                                                                                                                  nat
1534
                                                                                                                  (pair
1535
                                                                                                                    nat
1536
                                                                                                                    (pair
1537
                                                                                                                      (set address)
1538
                                                                                                                      (pair
1539
                                                                                                                        (big_map
1540
                                                                                                                          nat
1541
                                                                                                                          bytes)
1542
                                                                                                                        (pair
1543
                                                                                                                          address
1544
                                                                                                                          string))))))))))))))))))))))))) } } } } ;
1545
                                       SWAP ;
1546
                                       DIG 2 ;
1547
                                       DROP 2 } } } }
1548
                         { SWAP ;
1549
                           DUP ;
1550
                           DUG 2 ;
1551
                           GET 3 ;
1552
                           SENDER ;
1553
                           COMPARE ;
1554
                           NEQ ;
1555
                           IF
1556
                             { SELF_ADDRESS ;
1557
                               DIG 2 ;
1558
                               DUP ;
1559
                               GET 3 ;
1560
                               CONTRACT %callMultisig (pair
1561
                                                        (pair %entrypoint_signature
1562
                                                          (string %name)
1563
                                                          (pair (bytes %params)
1564
                                                                (address %source_contract)))
1565
                                                        (lambda %callback unit
1566
                                                                          (list operation))) ;
1567
                               IF_NONE
1568
                                 { SWAP ;
1569
                                   DIG 2 ;
1570
                                   DROP 2 ;
1571
                                   PUSH string "no call entrypoint" ;
1572
                                   FAILWITH }
1573
                                 { SELF_ADDRESS ;
1574
                                   DUP 5 ;
1575
                                   PACK ;
1576
                                   SHA256 ;
1577
                                   PUSH string "removeToWhitelist" ;
1578
                                   PAIR 3 ;
1579
                                   SWAP ;
1580
                                   PUSH mutez 0 ;
1581
                                   DIG 5 ;
1582
                                   DIG 5 ;
1583
                                   PAIR ;
1584
                                   LAMBDA
1585
                                     (pair (pair address (list address)) unit)
1586
                                     (list operation)
1587
                                     { CAR ;
1588
                                       UNPAIR ;
1589
                                       CONTRACT %removeToWhitelist (list address) ;
1590
                                       IF_NONE
1591
                                         { DROP ;
1592
                                           PUSH string "no removeToWhitelist entrypoint" ;
1593
                                           FAILWITH }
1594
                                         { NIL operation ;
1595
                                           SWAP ;
1596
                                           PUSH mutez 0 ;
1597
                                           DIG 3 ;
1598
                                           TRANSFER_TOKENS ;
1599
                                           CONS } } ;
1600
                                   SWAP ;
1601
                                   APPLY ;
1602
                                   DIG 3 ;
1603
                                   PAIR ;
1604
                                   TRANSFER_TOKENS ;
1605
                                   NIL operation ;
1606
                                   SWAP ;
1607
                                   CONS } ;
1608
                               PAIR }
1609
                             { SWAP ;
1610
                               DUP ;
1611
                               DUG 2 ;
1612
                               GET 27 ;
1613
                               SWAP ;
1614
                               ITER { SWAP ; NONE nat ; DIG 2 ; UPDATE } ;
1615
                               UPDATE 27 ;
1616
                               NIL operation ;
1617
                               PAIR } } }
1618
                     { IF_LEFT
1619
                         { DIG 2 ;
1620
                           DROP ;
1621
                           SWAP ;
1622
                           DUP ;
1623
                           DUG 2 ;
1624
                           GET 3 ;
1625
                           SENDER ;
1626
                           COMPARE ;
1627
                           NEQ ;
1628
                           IF
1629
                             { SELF_ADDRESS ;
1630
                               DIG 2 ;
1631
                               DUP ;
1632
                               GET 3 ;
1633
                               CONTRACT %callMultisig (pair
1634
                                                        (pair %entrypoint_signature
1635
                                                          (string %name)
1636
                                                          (pair (bytes %params)
1637
                                                                (address %source_contract)))
1638
                                                        (lambda %callback unit
1639
                                                                          (list operation))) ;
1640
                               IF_NONE
1641
                                 { SWAP ;
1642
                                   DIG 2 ;
1643
                                   DROP 2 ;
1644
                                   PUSH string "no call entrypoint" ;
1645
                                   FAILWITH }
1646
                                 { SELF_ADDRESS ;
1647
                                   DUP 5 ;
1648
                                   PACK ;
1649
                                   SHA256 ;
1650
                                   PUSH string "removeRevealAdmin" ;
1651
                                   PAIR 3 ;
1652
                                   SWAP ;
1653
                                   PUSH mutez 0 ;
1654
                                   DIG 5 ;
1655
                                   DIG 5 ;
1656
                                   PAIR ;
1657
                                   LAMBDA
1658
                                     (pair (pair address address) unit)
1659
                                     (list operation)
1660
                                     { CAR ;
1661
                                       UNPAIR ;
1662
                                       CONTRACT %removeRevealAdmin address ;
1663
                                       IF_NONE
1664
                                         { DROP ;
1665
                                           PUSH string "no removeRevealAdmin entrypoint" ;
1666
                                           FAILWITH }
1667
                                         { NIL operation ;
1668
                                           SWAP ;
1669
                                           PUSH mutez 0 ;
1670
                                           DIG 3 ;
1671
                                           TRANSFER_TOKENS ;
1672
                                           CONS } } ;
1673
                                   SWAP ;
1674
                                   APPLY ;
1675
                                   DIG 3 ;
1676
                                   PAIR ;
1677
                                   TRANSFER_TOKENS ;
1678
                                   NIL operation ;
1679
                                   SWAP ;
1680
                                   CONS } ;
1681
                               PAIR }
1682
                             { SWAP ;
1683
                               DUP ;
1684
                               GET 43 ;
1685
                               DIG 2 ;
1686
                               PUSH bool False ;
1687
                               SWAP ;
1688
                               UPDATE ;
1689
                               UPDATE 43 ;
1690
                               NIL operation ;
1691
                               PAIR } }
1692
                         { NIL operation ; DUG 2 ; PAIR 3 ; EXEC } } } }
1693
             { IF_LEFT
1694
                 { IF_LEFT
1695
                     { IF_LEFT
1696
                         { SWAP ;
1697
                           NIL operation ;
1698
                           PAIR ;
1699
                           SWAP ;
1700
                           ITER { SWAP ; DUP ; CAR ; SWAP ; CDR ; DIG 2 ; PAIR 3 ; SWAP ; DUP ; DUG 2 ; SWAP ; EXEC } ;
1701
                           SWAP ;
1702
                           DROP }
1703
                         { DIG 2 ;
1704
                           DROP ;
1705
                           SWAP ;
1706
                           DUP ;
1707
                           DUG 2 ;
1708
                           GET 3 ;
1709
                           SENDER ;
1710
                           COMPARE ;
1711
                           NEQ ;
1712
                           IF
1713
                             { SELF_ADDRESS ;
1714
                               DIG 2 ;
1715
                               DUP ;
1716
                               GET 3 ;
1717
                               CONTRACT %callMultisig (pair
1718
                                                        (pair %entrypoint_signature
1719
                                                          (string %name)
1720
                                                          (pair (bytes %params)
1721
                                                                (address %source_contract)))
1722
                                                        (lambda %callback unit
1723
                                                                          (list operation))) ;
1724
                               IF_NONE
1725
                                 { SWAP ;
1726
                                   DIG 2 ;
1727
                                   DROP 2 ;
1728
                                   PUSH string "no call entrypoint" ;
1729
                                   FAILWITH }
1730
                                 { SELF_ADDRESS ;
1731
                                   DUP 5 ;
1732
                                   PACK ;
1733
                                   SHA256 ;
1734
                                   PUSH string "setDogaAddress" ;
1735
                                   PAIR 3 ;
1736
                                   SWAP ;
1737
                                   PUSH mutez 0 ;
1738
                                   DIG 5 ;
1739
                                   DIG 5 ;
1740
                                   PAIR ;
1741
                                   LAMBDA
1742
                                     (pair (pair address address) unit)
1743
                                     (list operation)
1744
                                     { CAR ;
1745
                                       UNPAIR ;
1746
                                       CONTRACT %setDogaAddress address ;
1747
                                       IF_NONE
1748
                                         { DROP ;
1749
                                           PUSH string "no setDogaAddress entrypoint" ;
1750
                                           FAILWITH }
1751
                                         { NIL operation ;
1752
                                           SWAP ;
1753
                                           PUSH mutez 0 ;
1754
                                           DIG 3 ;
1755
                                           TRANSFER_TOKENS ;
1756
                                           CONS } } ;
1757
                                   SWAP ;
1758
                                   APPLY ;
1759
                                   DIG 3 ;
1760
                                   PAIR ;
1761
                                   TRANSFER_TOKENS ;
1762
                                   NIL operation ;
1763
                                   SWAP ;
1764
                                   CONS } ;
1765
                               PAIR }
1766
                             { UPDATE 7 ; NIL operation ; PAIR } } }
1767
                     { DIG 2 ;
1768
                       DROP ;
1769
                       IF_LEFT
1770
                         { SWAP ;
1771
                           DUP ;
1772
                           DUG 2 ;
1773
                           GET 3 ;
1774
                           SENDER ;
1775
                           COMPARE ;
1776
                           NEQ ;
1777
                           IF
1778
                             { SELF_ADDRESS ;
1779
                               DIG 2 ;
1780
                               DUP ;
1781
                               GET 3 ;
1782
                               CONTRACT %callMultisig (pair
1783
                                                        (pair %entrypoint_signature
1784
                                                          (string %name)
1785
                                                          (pair (bytes %params)
1786
                                                                (address %source_contract)))
1787
                                                        (lambda %callback unit
1788
                                                                          (list operation))) ;
1789
                               IF_NONE
1790
                                 { SWAP ;
1791
                                   DIG 2 ;
1792
                                   DROP 2 ;
1793
                                   PUSH string "no call entrypoint" ;
1794
                                   FAILWITH }
1795
                                 { SELF_ADDRESS ;
1796
                                   DUP 5 ;
1797
                                   PACK ;
1798
                                   SHA256 ;
1799
                                   PUSH string "setFreeMetadata" ;
1800
                                   PAIR 3 ;
1801
                                   SWAP ;
1802
                                   PUSH mutez 0 ;
1803
                                   DIG 5 ;
1804
                                   DIG 5 ;
1805
                                   PAIR ;
1806
                                   LAMBDA
1807
                                     (pair
1808
                                       (pair address (pair (pair (map nat nat) nat) nat))
1809
                                       unit)
1810
                                     (list operation)
1811
                                     { CAR ;
1812
                                       UNPAIR ;
1813
                                       CONTRACT %setFreeMetadata (pair
1814
                                                                   (pair
1815
                                                                     (map %free_metadata
1816
                                                                       nat
1817
                                                                       nat)
1818
                                                                     (nat %free_metadata_length))
1819
                                                                   (nat %version)) ;
1820
                                       IF_NONE
1821
                                         { DROP ;
1822
                                           PUSH string "no setFreeMetadata entrypoint" ;
1823
                                           FAILWITH }
1824
                                         { NIL operation ;
1825
                                           SWAP ;
1826
                                           PUSH mutez 0 ;
1827
                                           DIG 3 ;
1828
                                           TRANSFER_TOKENS ;
1829
                                           CONS } } ;
1830
                                   SWAP ;
1831
                                   APPLY ;
1832
                                   DIG 3 ;
1833
                                   PAIR ;
1834
                                   TRANSFER_TOKENS ;
1835
                                   NIL operation ;
1836
                                   SWAP ;
1837
                                   CONS } ;
1838
                               PAIR }
1839
                             { LAMBDA
1840
                                 (pair (big_map nat nat) (pair nat nat))
1841
                                 (big_map nat nat)
1842
                                 { UNPAIR ; SWAP ; DUP ; DUG 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
1843
                               PUSH nat 1 ;
1844
                               DUP 3 ;
1845
                               CDR ;
1846
                               COMPARE ;
1847
                               EQ ;
1848
                               IF
1849
                                 { DUP 3 ;
1850
                                   GET 29 ;
1851
                                   DUP 3 ;
1852
                                   CAR ;
1853
                                   CAR ;
1854
                                   ITER { SWAP ; PAIR ; SWAP ; DUP ; DUG 2 ; SWAP ; EXEC } ;
1855
                                   SWAP ;
1856
                                   DROP ;
1857
                                   DIG 2 ;
1858
                                   SWAP ;
1859
                                   UPDATE 29 ;
1860
                                   SWAP ;
1861
                                   CAR ;
1862
                                   CDR ;
1863
                                   UPDATE 31 }
1864
                                 { PUSH nat 2 ;
1865
                                   DUP 3 ;
1866
                                   CDR ;
1867
                                   COMPARE ;
1868
                                   EQ ;
1869
                                   IF
1870
                                     { DUP 3 ;
1871
                                       GET 33 ;
1872
                                       DUP 3 ;
1873
                                       CAR ;
1874
                                       CAR ;
1875
                                       ITER { SWAP ; PAIR ; SWAP ; DUP ; DUG 2 ; SWAP ; EXEC } ;
1876
                                       SWAP ;
1877
                                       DROP ;
1878
                                       DIG 2 ;
1879
                                       SWAP ;
1880
                                       UPDATE 33 ;
1881
                                       SWAP ;
1882
                                       CAR ;
1883
                                       CDR ;
1884
                                       UPDATE 35 }
1885
                                     { DROP 3 ; PUSH string "version not found" ; FAILWITH } } ;
1886
                               NIL operation ;
1887
                               PAIR } }
1888
                         { SWAP ;
1889
                           DUP ;
1890
                           DUG 2 ;
1891
                           GET 3 ;
1892
                           SENDER ;
1893
                           COMPARE ;
1894
                           NEQ ;
1895
                           IF
1896
                             { SELF_ADDRESS ;
1897
                               DIG 2 ;
1898
                               DUP ;
1899
                               GET 3 ;
1900
                               CONTRACT %callMultisig (pair
1901
                                                        (pair %entrypoint_signature
1902
                                                          (string %name)
1903
                                                          (pair (bytes %params)
1904
                                                                (address %source_contract)))
1905
                                                        (lambda %callback unit
1906
                                                                          (list operation))) ;
1907
                               IF_NONE
1908
                                 { SWAP ;
1909
                                   DIG 2 ;
1910
                                   DROP 2 ;
1911
                                   PUSH string "no call entrypoint" ;
1912
                                   FAILWITH }
1913
                                 { SELF_ADDRESS ;
1914
                                   DUP 5 ;
1915
                                   PACK ;
1916
                                   SHA256 ;
1917
                                   PUSH string "setIpfsHashes" ;
1918
                                   PAIR 3 ;
1919
                                   SWAP ;
1920
                                   PUSH mutez 0 ;
1921
                                   DIG 5 ;
1922
                                   DIG 5 ;
1923
                                   PAIR ;
1924
                                   LAMBDA
1925
                                     (pair (pair address string) unit)
1926
                                     (list operation)
1927
                                     { CAR ;
1928
                                       UNPAIR ;
1929
                                       CONTRACT %setIpfsHashes string ;
1930
                                       IF_NONE
1931
                                         { DROP ;
1932
                                           PUSH string "no setIpfsHashes entrypoint" ;
1933
                                           FAILWITH }
1934
                                         { NIL operation ;
1935
                                           SWAP ;
1936
                                           PUSH mutez 0 ;
1937
                                           DIG 3 ;
1938
                                           TRANSFER_TOKENS ;
1939
                                           CONS } } ;
1940
                                   SWAP ;
1941
                                   APPLY ;
1942
                                   DIG 3 ;
1943
                                   PAIR ;
1944
                                   TRANSFER_TOKENS ;
1945
                                   NIL operation ;
1946
                                   SWAP ;
1947
                                   CONS } ;
1948
                               PAIR }
1949
                             { UPDATE 48 ; NIL operation ; PAIR } } } }
1950
                 { DIG 2 ;
1951
                   DROP ;
1952
                   IF_LEFT
1953
                     { IF_LEFT
1954
                         { SWAP ;
1955
                           DUP ;
1956
                           DUG 2 ;
1957
                           GET 3 ;
1958
                           SENDER ;
1959
                           COMPARE ;
1960
                           NEQ ;
1961
                           IF
1962
                             { SELF_ADDRESS ;
1963
                               DIG 2 ;
1964
                               DUP ;
1965
                               GET 3 ;
1966
                               CONTRACT %callMultisig (pair
1967
                                                        (pair %entrypoint_signature
1968
                                                          (string %name)
1969
                                                          (pair (bytes %params)
1970
                                                                (address %source_contract)))
1971
                                                        (lambda %callback unit
1972
                                                                          (list operation))) ;
1973
                               IF_NONE
1974
                                 { SWAP ;
1975
                                   DIG 2 ;
1976
                                   DROP 2 ;
1977
                                   PUSH string "no call entrypoint" ;
1978
                                   FAILWITH }
1979
                                 { SELF_ADDRESS ;
1980
                                   DUP 5 ;
1981
                                   PACK ;
1982
                                   SHA256 ;
1983
                                   PUSH string "setMintParams" ;
1984
                                   PAIR 3 ;
1985
                                   SWAP ;
1986
                                   PUSH mutez 0 ;
1987
                                   DIG 5 ;
1988
                                   DIG 5 ;
1989
                                   PAIR ;
1990
                                   LAMBDA
1991
                                     (pair
1992
                                       (pair address
1993
                                             (pair bool
1994
                                                   (pair nat
1995
                                                         (pair nat
1996
                                                               (pair nat
1997
                                                                     (pair timestamp
1998
                                                                           (pair
1999
                                                                             timestamp
2000
                                                                             timestamp)))))))
2001
                                       unit)
2002
                                     (list operation)
2003
                                     { CAR ;
2004
                                       UNPAIR ;
2005
                                       CONTRACT %setMintParams (pair
2006
                                                                 (bool %is_private_sale)
2007
                                                                 (pair (nat %mint_price)
2008
                                                                       (pair
2009
                                                                         (nat %total_supply)
2010
                                                                         (pair
2011
                                                                           (nat %max_mint_per_address)
2012
                                                                           (pair
2013
                                                                             (timestamp %start_time)
2014
                                                                             (pair
2015
                                                                               (timestamp %end_time)
2016
                                                                               (timestamp %reveal_time))))))) ;
2017
                                       IF_NONE
2018
                                         { DROP ;
2019
                                           PUSH string "no setMintParams entrypoint" ;
2020
                                           FAILWITH }
2021
                                         { NIL operation ;
2022
                                           SWAP ;
2023
                                           PUSH mutez 0 ;
2024
                                           DIG 3 ;
2025
                                           TRANSFER_TOKENS ;
2026
                                           CONS } } ;
2027
                                   SWAP ;
2028
                                   APPLY ;
2029
                                   DIG 3 ;
2030
                                   PAIR ;
2031
                                   TRANSFER_TOKENS ;
2032
                                   NIL operation ;
2033
                                   SWAP ;
2034
                                   CONS } ;
2035
                               PAIR }
2036
                             { PUSH nat 0 ;
2037
                               SWAP ;
2038
                               DUP ;
2039
                               DUG 2 ;
2040
                               GET 7 ;
2041
                               COMPARE ;
2042
                               EQ ;
2043
                               PUSH nat 0 ;
2044
                               DUP 3 ;
2045
                               GET 5 ;
2046
                               COMPARE ;
2047
                               EQ ;
2048
                               PUSH nat 0 ;
2049
                               DUP 4 ;
2050
                               GET 3 ;
2051
                               COMPARE ;
2052
                               LE ;
2053
                               OR ;
2054
                               OR ;
2055
                               IF
2056
                                 { DROP 2 ;
2057
                                   PUSH string "Value should be higher than zero" ;
2058
                                   FAILWITH }
2059
                                 { DUP ;
2060
                                   GET 11 ;
2061
                                   SWAP ;
2062
                                   DUP ;
2063
                                   DUG 2 ;
2064
                                   GET 9 ;
2065
                                   COMPARE ;
2066
                                   GE ;
2067
                                   IF
2068
                                     { DROP 2 ;
2069
                                       PUSH string "Invalid date format" ;
2070
                                       FAILWITH }
2071
                                     { DUP ;
2072
                                       DUG 2 ;
2073
                                       CAR ;
2074
                                       UPDATE 11 ;
2075
                                       SWAP ;
2076
                                       DUP ;
2077
                                       DUG 2 ;
2078
                                       GET 3 ;
2079
                                       UPDATE 13 ;
2080
                                       SWAP ;
2081
                                       DUP ;
2082
                                       DUG 2 ;
2083
                                       GET 5 ;
2084
                                       UPDATE 15 ;
2085
                                       SWAP ;
2086
                                       DUP ;
2087
                                       DUG 2 ;
2088
                                       GET 7 ;
2089
                                       UPDATE 19 ;
2090
                                       SWAP ;
2091
                                       DUP ;
2092
                                       DUG 2 ;
2093
                                       GET 9 ;
2094
                                       UPDATE 21 ;
2095
                                       SWAP ;
2096
                                       DUP ;
2097
                                       DUG 2 ;
2098
                                       GET 11 ;
2099
                                       UPDATE 23 ;
2100
                                       SWAP ;
2101
                                       GET 12 ;
2102
                                       UPDATE 25 ;
2103
                                       NIL operation ;
2104
                                       PAIR } } } }
2105
                         { DROP ;
2106
                           DUP ;
2107
                           GET 3 ;
2108
                           SENDER ;
2109
                           COMPARE ;
2110
                           NEQ ;
2111
                           IF
2112
                             { SELF_ADDRESS ;
2113
                               SWAP ;
2114
                               DUP ;
2115
                               GET 3 ;
2116
                               CONTRACT %callMultisig (pair
2117
                                                        (pair %entrypoint_signature
2118
                                                          (string %name)
2119
                                                          (pair (bytes %params)
2120
                                                                (address %source_contract)))
2121
                                                        (lambda %callback unit
2122
                                                                          (list operation))) ;
2123
                               IF_NONE
2124
                                 { SWAP ; DROP ; PUSH string "no call entrypoint" ; FAILWITH }
2125
                                 { SELF_ADDRESS ;
2126
                                   UNIT ;
2127
                                   PACK ;
2128
                                   SHA256 ;
2129
                                   PUSH string "setMintPerAddress" ;
2130
                                   PAIR 3 ;
2131
                                   SWAP ;
2132
                                   PUSH mutez 0 ;
2133
                                   DIG 4 ;
2134
                                   LAMBDA
2135
                                     (pair address unit)
2136
                                     (list operation)
2137
                                     { CAR ;
2138
                                       CONTRACT %setMintPerAddress unit ;
2139
                                       IF_NONE
2140
                                         { PUSH string "no setMintPerAddress entrypoint" ;
2141
                                           FAILWITH }
2142
                                         { NIL operation ;
2143
                                           SWAP ;
2144
                                           PUSH mutez 0 ;
2145
                                           UNIT ;
2146
                                           TRANSFER_TOKENS ;
2147
                                           CONS } } ;
2148
                                   SWAP ;
2149
                                   APPLY ;
2150
                                   DIG 3 ;
2151
                                   PAIR ;
2152
                                   TRANSFER_TOKENS ;
2153
                                   NIL operation ;
2154
                                   SWAP ;
2155
                                   CONS } ;
2156
                               PAIR }
2157
                             { EMPTY_BIG_MAP address nat ; UPDATE 17 ; NIL operation ; PAIR } } }
2158
                     { IF_LEFT
2159
                         { SWAP ;
2160
                           DUP ;
2161
                           DUG 2 ;
2162
                           GET 3 ;
2163
                           SENDER ;
2164
                           COMPARE ;
2165
                           NEQ ;
2166
                           IF
2167
                             { SELF_ADDRESS ;
2168
                               DIG 2 ;
2169
                               DUP ;
2170
                               GET 3 ;
2171
                               CONTRACT %callMultisig (pair
2172
                                                        (pair %entrypoint_signature
2173
                                                          (string %name)
2174
                                                          (pair (bytes %params)
2175
                                                                (address %source_contract)))
2176
                                                        (lambda %callback unit
2177
                                                                          (list operation))) ;
2178
                               IF_NONE
2179
                                 { SWAP ;
2180
                                   DIG 2 ;
2181
                                   DROP 2 ;
2182
                                   PUSH string "no call entrypoint" ;
2183
                                   FAILWITH }
2184
                                 { SELF_ADDRESS ;
2185
                                   DUP 5 ;
2186
                                   PACK ;
2187
                                   SHA256 ;
2188
                                   PUSH string "updateMultisig" ;
2189
                                   PAIR 3 ;
2190
                                   SWAP ;
2191
                                   PUSH mutez 0 ;
2192
                                   DIG 5 ;
2193
                                   DIG 5 ;
2194
                                   PAIR ;
2195
                                   LAMBDA
2196
                                     (pair (pair address address) unit)
2197
                                     (list operation)
2198
                                     { CAR ;
2199
                                       UNPAIR ;
2200
                                       CONTRACT %updateMultisig address ;
2201
                                       IF_NONE
2202
                                         { DROP ;
2203
                                           PUSH string "no updateMultisig entrypoint" ;
2204
                                           FAILWITH }
2205
                                         { NIL operation ;
2206
                                           SWAP ;
2207
                                           PUSH mutez 0 ;
2208
                                           DIG 3 ;
2209
                                           TRANSFER_TOKENS ;
2210
                                           CONS } } ;
2211
                                   SWAP ;
2212
                                   APPLY ;
2213
                                   DIG 3 ;
2214
                                   PAIR ;
2215
                                   TRANSFER_TOKENS ;
2216
                                   NIL operation ;
2217
                                   SWAP ;
2218
                                   CONS } ;
2219
                               PAIR }
2220
                             { UPDATE 3 ; NIL operation ; PAIR } }
2221
                         { SWAP ;
2222
                           DUP ;
2223
                           DUG 2 ;
2224
                           GET 3 ;
2225
                           SENDER ;
2226
                           COMPARE ;
2227
                           NEQ ;
2228
                           IF
2229
                             { SELF_ADDRESS ;
2230
                               DIG 2 ;
2231
                               DUP ;
2232
                               GET 3 ;
2233
                               CONTRACT %callMultisig (pair
2234
                                                        (pair %entrypoint_signature
2235
                                                          (string %name)
2236
                                                          (pair (bytes %params)
2237
                                                                (address %source_contract)))
2238
                                                        (lambda %callback unit
2239
                                                                          (list operation))) ;
2240
                               IF_NONE
2241
                                 { SWAP ;
2242
                                   DIG 2 ;
2243
                                   DROP 2 ;
2244
                                   PUSH string "no call entrypoint" ;
2245
                                   FAILWITH }
2246
                                 { SELF_ADDRESS ;
2247
                                   DUP 5 ;
2248
                                   PACK ;
2249
                                   SHA256 ;
2250
                                   PUSH string "setNameList" ;
2251
                                   PAIR 3 ;
2252
                                   SWAP ;
2253
                                   PUSH mutez 0 ;
2254
                                   DIG 5 ;
2255
                                   DIG 5 ;
2256
                                   PAIR ;
2257
                                   LAMBDA
2258
                                     (pair (pair address (map nat bytes)) unit)
2259
                                     (list operation)
2260
                                     { CAR ;
2261
                                       UNPAIR ;
2262
                                       CONTRACT %setNameList (map nat bytes) ;
2263
                                       IF_NONE
2264
                                         { DROP ;
2265
                                           PUSH string "no setNameList entrypoint" ;
2266
                                           FAILWITH }
2267
                                         { NIL operation ;
2268
                                           SWAP ;
2269
                                           PUSH mutez 0 ;
2270
                                           DIG 3 ;
2271
                                           TRANSFER_TOKENS ;
2272
                                           CONS } } ;
2273
                                   SWAP ;
2274
                                   APPLY ;
2275
                                   DIG 3 ;
2276
                                   PAIR ;
2277
                                   TRANSFER_TOKENS ;
2278
                                   NIL operation ;
2279
                                   SWAP ;
2280
                                   CONS } ;
2281
                               PAIR }
2282
                             { SWAP ;
2283
                               DUP ;
2284
                               DUG 2 ;
2285
                               GET 45 ;
2286
                               SWAP ;
2287
                               ITER { DUP ; DUG 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
2288
                               UPDATE 45 ;
2289
                               NIL operation ;
2290
                               PAIR } } } } } }
2291
         { DIG 2 ;
2292
           DROP ;
2293
           IF_LEFT
2294
             { IF_LEFT
2295
                 { IF_LEFT
2296
                     { SWAP ;
2297
                       DUP ;
2298
                       DUG 2 ;
2299
                       GET 3 ;
2300
                       SENDER ;
2301
                       COMPARE ;
2302
                       NEQ ;
2303
                       IF
2304
                         { SELF_ADDRESS ;
2305
                           DIG 2 ;
2306
                           DUP ;
2307
                           GET 3 ;
2308
                           CONTRACT %callMultisig (pair
2309
                                                    (pair %entrypoint_signature
2310
                                                      (string %name)
2311
                                                      (pair (bytes %params)
2312
                                                            (address %source_contract)))
2313
                                                    (lambda %callback unit
2314
                                                                      (list operation))) ;
2315
                           IF_NONE
2316
                             { SWAP ;
2317
                               DIG 2 ;
2318
                               DROP 2 ;
2319
                               PUSH string "no call entrypoint" ;
2320
                               FAILWITH }
2321
                             { SELF_ADDRESS ;
2322
                               DUP 5 ;
2323
                               PACK ;
2324
                               SHA256 ;
2325
                               PUSH string "setNftAddress" ;
2326
                               PAIR 3 ;
2327
                               SWAP ;
2328
                               PUSH mutez 0 ;
2329
                               DIG 5 ;
2330
                               DIG 5 ;
2331
                               PAIR ;
2332
                               LAMBDA
2333
                                 (pair (pair address address) unit)
2334
                                 (list operation)
2335
                                 { CAR ;
2336
                                   UNPAIR ;
2337
                                   CONTRACT %setNftAddress address ;
2338
                                   IF_NONE
2339
                                     { DROP ;
2340
                                       PUSH string "no setNftAddress entrypoint" ;
2341
                                       FAILWITH }
2342
                                     { NIL operation ;
2343
                                       SWAP ;
2344
                                       PUSH mutez 0 ;
2345
                                       DIG 3 ;
2346
                                       TRANSFER_TOKENS ;
2347
                                       CONS } } ;
2348
                               SWAP ;
2349
                               APPLY ;
2350
                               DIG 3 ;
2351
                               PAIR ;
2352
                               TRANSFER_TOKENS ;
2353
                               NIL operation ;
2354
                               SWAP ;
2355
                               CONS } ;
2356
                           PAIR }
2357
                         { UPDATE 5 ; NIL operation ; PAIR } }
2358
                     { SWAP ;
2359
                       DUP ;
2360
                       DUG 2 ;
2361
                       GET 3 ;
2362
                       SENDER ;
2363
                       COMPARE ;
2364
                       NEQ ;
2365
                       IF
2366
                         { SELF_ADDRESS ;
2367
                           DIG 2 ;
2368
                           DUP ;
2369
                           GET 3 ;
2370
                           CONTRACT %callMultisig (pair
2371
                                                    (pair %entrypoint_signature
2372
                                                      (string %name)
2373
                                                      (pair (bytes %params)
2374
                                                            (address %source_contract)))
2375
                                                    (lambda %callback unit
2376
                                                                      (list operation))) ;
2377
                           IF_NONE
2378
                             { SWAP ;
2379
                               DIG 2 ;
2380
                               DROP 2 ;
2381
                               PUSH string "no call entrypoint" ;
2382
                               FAILWITH }
2383
                             { SELF_ADDRESS ;
2384
                               DUP 5 ;
2385
                               PACK ;
2386
                               SHA256 ;
2387
                               PUSH string "setOracleAddress" ;
2388
                               PAIR 3 ;
2389
                               SWAP ;
2390
                               PUSH mutez 0 ;
2391
                               DIG 5 ;
2392
                               DIG 5 ;
2393
                               PAIR ;
2394
                               LAMBDA
2395
                                 (pair (pair address address) unit)
2396
                                 (list operation)
2397
                                 { CAR ;
2398
                                   UNPAIR ;
2399
                                   CONTRACT %setOracleAddress address ;
2400
                                   IF_NONE
2401
                                     { DROP ;
2402
                                       PUSH string "no setOracleAddress entrypoint" ;
2403
                                       FAILWITH }
2404
                                     { NIL operation ;
2405
                                       SWAP ;
2406
                                       PUSH mutez 0 ;
2407
                                       DIG 3 ;
2408
                                       TRANSFER_TOKENS ;
2409
                                       CONS } } ;
2410
                               SWAP ;
2411
                               APPLY ;
2412
                               DIG 3 ;
2413
                               PAIR ;
2414
                               TRANSFER_TOKENS ;
2415
                               NIL operation ;
2416
                               SWAP ;
2417
                               CONS } ;
2418
                           PAIR }
2419
                         { UPDATE 47 ; NIL operation ; PAIR } } }
2420
                 { IF_LEFT
2421
                     { SWAP ;
2422
                       DUP ;
2423
                       DUG 2 ;
2424
                       GET 3 ;
2425
                       SENDER ;
2426
                       COMPARE ;
2427
                       NEQ ;
2428
                       IF
2429
                         { SELF_ADDRESS ;
2430
                           DIG 2 ;
2431
                           DUP ;
2432
                           GET 3 ;
2433
                           CONTRACT %callMultisig (pair
2434
                                                    (pair %entrypoint_signature
2435
                                                      (string %name)
2436
                                                      (pair (bytes %params)
2437
                                                            (address %source_contract)))
2438
                                                    (lambda %callback unit
2439
                                                                      (list operation))) ;
2440
                           IF_NONE
2441
                             { SWAP ;
2442
                               DIG 2 ;
2443
                               DROP 2 ;
2444
                               PUSH string "no call entrypoint" ;
2445
                               FAILWITH }
2446
                             { SELF_ADDRESS ;
2447
                               DUP 5 ;
2448
                               PACK ;
2449
                               SHA256 ;
2450
                               PUSH string "setPause" ;
2451
                               PAIR 3 ;
2452
                               SWAP ;
2453
                               PUSH mutez 0 ;
2454
                               DIG 5 ;
2455
                               DIG 5 ;
2456
                               PAIR ;
2457
                               LAMBDA
2458
                                 (pair (pair address bool) unit)
2459
                                 (list operation)
2460
                                 { CAR ;
2461
                                   UNPAIR ;
2462
                                   CONTRACT %setPause bool ;
2463
                                   IF_NONE
2464
                                     { DROP ;
2465
                                       PUSH string "no setPause entrypoint" ;
2466
                                       FAILWITH }
2467
                                     { NIL operation ;
2468
                                       SWAP ;
2469
                                       PUSH mutez 0 ;
2470
                                       DIG 3 ;
2471
                                       TRANSFER_TOKENS ;
2472
                                       CONS } } ;
2473
                               SWAP ;
2474
                               APPLY ;
2475
                               DIG 3 ;
2476
                               PAIR ;
2477
                               TRANSFER_TOKENS ;
2478
                               NIL operation ;
2479
                               SWAP ;
2480
                               CONS } ;
2481
                           PAIR }
2482
                         { UPDATE 1 ; NIL operation ; PAIR } }
2483
                     { SWAP ;
2484
                       DUP ;
2485
                       DUG 2 ;
2486
                       GET 3 ;
2487
                       SENDER ;
2488
                       COMPARE ;
2489
                       NEQ ;
2490
                       IF
2491
                         { SELF_ADDRESS ;
2492
                           DIG 2 ;
2493
                           DUP ;
2494
                           GET 3 ;
2495
                           CONTRACT %callMultisig (pair
2496
                                                    (pair %entrypoint_signature
2497
                                                      (string %name)
2498
                                                      (pair (bytes %params)
2499
                                                            (address %source_contract)))
2500
                                                    (lambda %callback unit
2501
                                                                      (list operation))) ;
2502
                           IF_NONE
2503
                             { SWAP ;
2504
                               DIG 2 ;
2505
                               DROP 2 ;
2506
                               PUSH string "no call entrypoint" ;
2507
                               FAILWITH }
2508
                             { SELF_ADDRESS ;
2509
                               DUP 5 ;
2510
                               PACK ;
2511
                               SHA256 ;
2512
                               PUSH string "setRandomOffset" ;
2513
                               PAIR 3 ;
2514
                               SWAP ;
2515
                               PUSH mutez 0 ;
2516
                               DIG 5 ;
2517
                               DIG 5 ;
2518
                               PAIR ;
2519
                               LAMBDA
2520
                                 (pair (pair address (pair nat nat)) unit)
2521
                                 (list operation)
2522
                                 { CAR ;
2523
                                   UNPAIR ;
2524
                                   CONTRACT %setRandomOffset (pair (nat %from_)
2525
                                                                   (nat %to_)) ;
2526
                                   IF_NONE
2527
                                     { DROP ;
2528
                                       PUSH string "no setRandomOffset entrypoint" ;
2529
                                       FAILWITH }
2530
                                     { NIL operation ;
2531
                                       SWAP ;
2532
                                       PUSH mutez 0 ;
2533
                                       DIG 3 ;
2534
                                       TRANSFER_TOKENS ;
2535
                                       CONS } } ;
2536
                               SWAP ;
2537
                               APPLY ;
2538
                               DIG 3 ;
2539
                               PAIR ;
2540
                               TRANSFER_TOKENS ;
2541
                               NIL operation ;
2542
                               SWAP ;
2543
                               CONS } ;
2544
                           PAIR }
2545
                         { SWAP ;
2546
                           DUP ;
2547
                           DUG 2 ;
2548
                           GET 47 ;
2549
                           SWAP ;
2550
                           VIEW "getRandomBetween" nat ;
2551
                           IF_NONE
2552
                             { PUSH string "Oracle failed to supply random number" ;
2553
                               FAILWITH }
2554
                             {} ;
2555
                           UPDATE 39 ;
2556
                           NIL operation ;
2557
                           PAIR } } } }
2558
             { IF_LEFT
2559
                 { SWAP ;
2560
                   DUP ;
2561
                   DUG 2 ;
2562
                   GET 3 ;
2563
                   SENDER ;
2564
                   COMPARE ;
2565
                   NEQ ;
2566
                   IF
2567
                     { SELF_ADDRESS ;
2568
                       DIG 2 ;
2569
                       DUP ;
2570
                       GET 3 ;
2571
                       CONTRACT %callMultisig (pair
2572
                                                (pair %entrypoint_signature
2573
                                                  (string %name)
2574
                                                  (pair (bytes %params)
2575
                                                        (address %source_contract)))
2576
                                                (lambda %callback unit (list operation))) ;
2577
                       IF_NONE
2578
                         { SWAP ; DIG 2 ; DROP 2 ; PUSH string "no call entrypoint" ; FAILWITH }
2579
                         { SELF_ADDRESS ;
2580
                           DUP 5 ;
2581
                           PACK ;
2582
                           SHA256 ;
2583
                           PUSH string "setReserveAddress" ;
2584
                           PAIR 3 ;
2585
                           SWAP ;
2586
                           PUSH mutez 0 ;
2587
                           DIG 5 ;
2588
                           DIG 5 ;
2589
                           PAIR ;
2590
                           LAMBDA
2591
                             (pair (pair address address) unit)
2592
                             (list operation)
2593
                             { CAR ;
2594
                               UNPAIR ;
2595
                               CONTRACT %setReserveAddress address ;
2596
                               IF_NONE
2597
                                 { DROP ;
2598
                                   PUSH string "no setReserveAddress entrypoint" ;
2599
                                   FAILWITH }
2600
                                 { NIL operation ;
2601
                                   SWAP ;
2602
                                   PUSH mutez 0 ;
2603
                                   DIG 3 ;
2604
                                   TRANSFER_TOKENS ;
2605
                                   CONS } } ;
2606
                           SWAP ;
2607
                           APPLY ;
2608
                           DIG 3 ;
2609
                           PAIR ;
2610
                           TRANSFER_TOKENS ;
2611
                           NIL operation ;
2612
                           SWAP ;
2613
                           CONS } ;
2614
                       PAIR }
2615
                     { UPDATE 9 ; NIL operation ; PAIR } }
2616
                 { SWAP ;
2617
                   DUP ;
2618
                   DUG 2 ;
2619
                   GET 3 ;
2620
                   SENDER ;
2621
                   COMPARE ;
2622
                   NEQ ;
2623
                   IF
2624
                     { SELF_ADDRESS ;
2625
                       DIG 2 ;
2626
                       DUP ;
2627
                       GET 3 ;
2628
                       CONTRACT %callMultisig (pair
2629
                                                (pair %entrypoint_signature
2630
                                                  (string %name)
2631
                                                  (pair (bytes %params)
2632
                                                        (address %source_contract)))
2633
                                                (lambda %callback unit (list operation))) ;
2634
                       IF_NONE
2635
                         { SWAP ; DIG 2 ; DROP 2 ; PUSH string "no call entrypoint" ; FAILWITH }
2636
                         { SELF_ADDRESS ;
2637
                           DUP 5 ;
2638
                           PACK ;
2639
                           SHA256 ;
2640
                           PUSH string "setTokenIdToMetadataId" ;
2641
                           PAIR 3 ;
2642
                           SWAP ;
2643
                           PUSH mutez 0 ;
2644
                           DIG 5 ;
2645
                           DIG 5 ;
2646
                           PAIR ;
2647
                           LAMBDA
2648
                             (pair (pair address (map nat nat)) unit)
2649
                             (list operation)
2650
                             { CAR ;
2651
                               UNPAIR ;
2652
                               CONTRACT %setTokenIdToMetadataId (map nat nat) ;
2653
                               IF_NONE
2654
                                 { DROP ;
2655
                                   PUSH string "no setTokenIdToMetadataId entrypoint" ;
2656
                                   FAILWITH }
2657
                                 { NIL operation ;
2658
                                   SWAP ;
2659
                                   PUSH mutez 0 ;
2660
                                   DIG 3 ;
2661
                                   TRANSFER_TOKENS ;
2662
                                   CONS } } ;
2663
                           SWAP ;
2664
                           APPLY ;
2665
                           DIG 3 ;
2666
                           PAIR ;
2667
                           TRANSFER_TOKENS ;
2668
                           NIL operation ;
2669
                           SWAP ;
2670
                           CONS } ;
2671
                       PAIR }
2672
                     { SWAP ;
2673
                       DUP ;
2674
                       DUG 2 ;
2675
                       GET 37 ;
2676
                       SWAP ;
2677
                       ITER { DUP ; DUG 2 ; CDR ; SOME ; DIG 2 ; CAR ; UPDATE } ;
2678
                       UPDATE 37 ;
2679
                       NIL operation ;
2680
                       PAIR } } } } }