BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • Parrotz Crowdsale
operations (2.62K)Storage Code Interact Tokens Metadata Fork Statistics Details
Latest
​x
669
1047
 
1
parameter (or
2
            (or
3
              (or (list %add_presale1_addresses address)
4
                  (or (list %add_presale2_addresses address) (bool %end_sale)))
5
              (or
6
                (or (nat %mint)
7
                    (pair %oracle_callback (string %currency_pair)
8
                                           (pair (timestamp %last_update) (nat %rate))))
9
                (or (address %register_fa2)
10
                    (pair %reserve_giveaways (address %address) (nat %amount)))))
11
            (or
12
              (or
13
                (or (list %reveal_metadata (pair (bytes %metadata) (nat %token_id)))
14
                    (address %set_admin))
15
                (or (nat %set_giveaway_amount)
16
                    (pair %set_presale_limits (nat %presale1_limit)
17
                                              (nat %presale2_limit))))
18
              (or
19
                (or
20
                  (pair %set_price (mutez %presale1_price)
21
                                   (pair (mutez %presale2_price)
22
                                         (mutez %public_sale_price)))
23
                  (pair %set_time (timestamp %presale1_start_time)
24
                                  (pair (timestamp %presale2_start_time)
25
                                        (timestamp %public_sale_start_time))))
26
                (or (unit %start_sale)
27
                    (pair %update_mint_limit (nat %max_mint) (nat %mint_limit))))));
28
storage (pair (address %admin)
29
              (pair (address %artist)
30
                    (pair (address %dev)
31
                          (pair (address %fa2)
32
                                (pair (nat %giveaway_amount)
33
                                      (pair (nat %giveaway_index)
34
                                            (pair (nat %max_mint)
35
                                                  (pair (big_map %metadata string bytes)
36
                                                        (pair (nat %mint_index)
37
                                                              (pair (nat %mint_limit)
38
                                                                    (pair
39
                                                                      (big_map %mints
40
                                                                        address
41
                                                                        (pair
42
                                                                          (nat %last_mint_level)
43
                                                                          (nat %minted)))
44
                                                                      (pair
45
                                                                        (address %oracle)
46
                                                                        (pair
47
                                                                          (bool %oracle_callback_expected)
48
                                                                          (pair
49
                                                                            (bytes %placeholder_ipfs)
50
                                                                            (pair
51
                                                                              (nat %presale1_count)
52
                                                                              (pair
53
                                                                                (nat %presale1_limit)
54
                                                                                (pair
55
                                                                                  (mutez %presale1_price)
56
                                                                                  (pair
57
                                                                                    (timestamp %presale1_start_time)
58
                                                                                    (pair
59
                                                                                      (big_map %presale1_whitelist
60
                                                                                        address
61
                                                                                        nat)
62
                                                                                      (pair
63
                                                                                        (nat %presale2_count)
64
                                                                                        (pair
65
                                                                                          (nat %presale2_limit)
66
                                                                                          (pair
67
                                                                                            (mutez %presale2_price)
68
                                                                                            (pair
69
                                                                                              (timestamp %presale2_start_time)
70
                                                                                              (pair
71
                                                                                                (big_map %presale2_whitelist
72
                                                                                                  address
73
                                                                                                  nat)
74
                                                                                                (pair
75
                                                                                                  (string %provenance_hash)
76
                                                                                                  (pair
77
                                                                                                    (mutez %public_sale_price)
78
                                                                                                    (pair
79
                                                                                                      (timestamp %public_sale_start_time)
80
                                                                                                      (pair
81
                                                                                                        (bool %sale_ended)
82
                                                                                                        (pair
83
                                                                                                          (nat %total_mints)
84
                                                                                                          (nat %total_supply))))))))))))))))))))))))))))));
85
code { LAMBDA
86
         (pair nat
87
               (pair address
88
                     (pair address
89
                           (pair address
90
                                 (pair address
91
                                       (pair nat
92
                                             (pair nat
93
                                                   (pair nat
94
                                                         (pair (big_map string bytes)
95
                                                               (pair nat
96
                                                                     (pair nat
97
                                                                           (pair
98
                                                                             (big_map
99
                                                                               address
100
                                                                               (pair nat
101
                                                                                     nat))
102
                                                                             (pair
103
                                                                               address
104
                                                                               (pair
105
                                                                                 bool
106
                                                                                 (pair
107
                                                                                   bytes
108
                                                                                   (pair
109
                                                                                     nat
110
                                                                                     (pair
111
                                                                                       nat
112
                                                                                       (pair
113
                                                                                         mutez
114
                                                                                         (pair
115
                                                                                           timestamp
116
                                                                                           (pair
117
                                                                                             (big_map
118
                                                                                               address
119
                                                                                               nat)
120
                                                                                             (pair
121
                                                                                               nat
122
                                                                                               (pair
123
                                                                                                 nat
124
                                                                                                 (pair
125
                                                                                                   mutez
126
                                                                                                   (pair
127
                                                                                                     timestamp
128
                                                                                                     (pair
129
                                                                                                       (big_map
130
                                                                                                         address
131
                                                                                                         nat)
132
                                                                                                       (pair
133
                                                                                                         string
134
                                                                                                         (pair
135
                                                                                                           mutez
136
                                                                                                           (pair
137
                                                                                                             timestamp
138
                                                                                                             (pair
139
                                                                                                               bool
140
                                                                                                               (pair
141
                                                                                                                 nat
142
                                                                                                                 nat))))))))))))))))))))))))))))))
143
         (pair bytes
144
               (pair address
145
                     (pair address
146
                           (pair address
147
                                 (pair address
148
                                       (pair nat
149
                                             (pair nat
150
                                                   (pair nat
151
                                                         (pair (big_map string bytes)
152
                                                               (pair nat
153
                                                                     (pair nat
154
                                                                           (pair
155
                                                                             (big_map
156
                                                                               address
157
                                                                               (pair nat
158
                                                                                     nat))
159
                                                                             (pair
160
                                                                               address
161
                                                                               (pair
162
                                                                                 bool
163
                                                                                 (pair
164
                                                                                   bytes
165
                                                                                   (pair
166
                                                                                     nat
167
                                                                                     (pair
168
                                                                                       nat
169
                                                                                       (pair
170
                                                                                         mutez
171
                                                                                         (pair
172
                                                                                           timestamp
173
                                                                                           (pair
174
                                                                                             (big_map
175
                                                                                               address
176
                                                                                               nat)
177
                                                                                             (pair
178
                                                                                               nat
179
                                                                                               (pair
180
                                                                                                 nat
181
                                                                                                 (pair
182
                                                                                                   mutez
183
                                                                                                   (pair
184
                                                                                                     timestamp
185
                                                                                                     (pair
186
                                                                                                       (big_map
187
                                                                                                         address
188
                                                                                                         nat)
189
                                                                                                       (pair
190
                                                                                                         string
191
                                                                                                         (pair
192
                                                                                                           mutez
193
                                                                                                           (pair
194
                                                                                                             timestamp
195
                                                                                                             (pair
196
                                                                                                               bool
197
                                                                                                               (pair
198
                                                                                                                 nat
199
                                                                                                                 nat))))))))))))))))))))))))))))))
200
         { UNPAIR ;
201
           NIL bytes ;
202
           SWAP ;
203
           DUP ;
204
           DUG 2 ;
205
           PUSH nat 0 ;
206
           PUSH nat 0 ;
207
           DUP 5 ;
208
           COMPARE ;
209
           EQ ;
210
           IF
211
             { DROP 2 ;
212
               SWAP ;
213
               DROP ;
214
               PUSH (map int bytes) { Elt 0 0x30 ;
215
                       Elt 1 0x31 ;
216
                       Elt 2 0x32 ;
217
                       Elt 3 0x33 ;
218
                       Elt 4 0x34 ;
219
                       Elt 5 0x35 ;
220
                       Elt 6 0x36 ;
221
                       Elt 7 0x37 ;
222
                       Elt 8 0x38 ;
223
                       Elt 9 0x39 } ;
224
               PUSH int 0 ;
225
               GET ;
226
               IF_NONE { PUSH int 205 ; FAILWITH } {} ;
227
               CONS }
228
             { PUSH nat 0 ;
229
               DUP 3 ;
230
               COMPARE ;
231
               GT ;
232
               LOOP { DROP ;
233
                      DUP ;
234
                      PUSH nat 10 ;
235
                      SWAP ;
236
                      EDIV ;
237
                      IF_NONE { PUSH int 208 ; FAILWITH } { CDR } ;
238
                      PUSH nat 10 ;
239
                      DIG 2 ;
240
                      EDIV ;
241
                      IF_NONE { PUSH int 209 ; FAILWITH } { CAR } ;
242
                      SWAP ;
243
                      DIG 2 ;
244
                      PUSH (map nat bytes) { Elt 0 0x30 ;
245
                              Elt 1 0x31 ;
246
                              Elt 2 0x32 ;
247
                              Elt 3 0x33 ;
248
                              Elt 4 0x34 ;
249
                              Elt 5 0x35 ;
250
                              Elt 6 0x36 ;
251
                              Elt 7 0x37 ;
252
                              Elt 8 0x38 ;
253
                              Elt 9 0x39 } ;
254
                      DUP 3 ;
255
                      GET ;
256
                      IF_NONE { PUSH int 210 ; FAILWITH } {} ;
257
                      CONS ;
258
                      DUG 2 ;
259
                      PUSH nat 0 ;
260
                      DUP 3 ;
261
                      COMPARE ;
262
                      GT } ;
263
               DROP 2 ;
264
               SWAP ;
265
               DROP } ;
266
           CONCAT ;
267
           SWAP ;
268
           DUP ;
269
           DUG 2 ;
270
           GET 27 ;
271
           CONCAT ;
272
           PAIR } ;
273
       SWAP ;
274
       UNPAIR ;
275
       IF_LEFT
276
         { IF_LEFT
277
             { DIG 2 ;
278
               DROP ;
279
               IF_LEFT
280
                 { SWAP ;
281
                   DUP ;
282
                   DUG 2 ;
283
                   CAR ;
284
                   SENDER ;
285
                   COMPARE ;
286
                   EQ ;
287
                   IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
288
                   DUP ;
289
                   ITER { DIG 2 ;
290
                          DUP ;
291
                          GET 37 ;
292
                          PUSH (option nat) (Some 0) ;
293
                          DIG 3 ;
294
                          UPDATE ;
295
                          UPDATE 37 ;
296
                          SWAP } ;
297
                   DROP }
298
                 { IF_LEFT
299
                     { SWAP ;
300
                       DUP ;
301
                       DUG 2 ;
302
                       CAR ;
303
                       SENDER ;
304
                       COMPARE ;
305
                       EQ ;
306
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
307
                       DUP ;
308
                       ITER { DIG 2 ;
309
                              DUP ;
310
                              GET 47 ;
311
                              PUSH (option nat) (Some 0) ;
312
                              DIG 3 ;
313
                              UPDATE ;
314
                              UPDATE 47 ;
315
                              SWAP } ;
316
                       DROP }
317
                     { SWAP ;
318
                       DUP ;
319
                       DUG 2 ;
320
                       CAR ;
321
                       SENDER ;
322
                       COMPARE ;
323
                       EQ ;
324
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
325
                       UPDATE 55 } } ;
326
               NIL operation }
327
             { IF_LEFT
328
                 { IF_LEFT
329
                     { SWAP ;
330
                       DUP ;
331
                       DUG 2 ;
332
                       GET 35 ;
333
                       NOW ;
334
                       COMPARE ;
335
                       GE ;
336
                       IF {} { PUSH string "PRESALE_NOT_STARTED" ; FAILWITH } ;
337
                       SWAP ;
338
                       DUP ;
339
                       DUG 2 ;
340
                       GET 55 ;
341
                       IF { PUSH string "SALE_ENDED" ; FAILWITH } {} ;
342
                       SWAP ;
343
                       DUP ;
344
                       GET 58 ;
345
                       SWAP ;
346
                       DUP ;
347
                       DUG 3 ;
348
                       GET 57 ;
349
                       COMPARE ;
350
                       LT ;
351
                       IF {} { PUSH string "SOLD_OUT" ; FAILWITH } ;
352
                       SWAP ;
353
                       DUP ;
354
                       DUG 2 ;
355
                       GET 19 ;
356
                       SWAP ;
357
                       DUP ;
358
                       DUG 2 ;
359
                       COMPARE ;
360
                       LE ;
361
                       IF {} { PUSH string "ONE_TIME_MINT_LIMIT_EXCEEDED" ; FAILWITH } ;
362
                       SWAP ;
363
                       DUP ;
364
                       DUG 2 ;
365
                       GET 58 ;
366
                       SWAP ;
367
                       DUP ;
368
                       DUG 2 ;
369
                       DUP 4 ;
370
                       GET 57 ;
371
                       ADD ;
372
                       COMPARE ;
373
                       LE ;
374
                       IF {} { PUSH string "NOT_ENOUGH_NFTS_AVAILABLE" ; FAILWITH } ;
375
                       PUSH mutez 0 ;
376
                       DUP 3 ;
377
                       GET 45 ;
378
                       NOW ;
379
                       COMPARE ;
380
                       LE ;
381
                       IF
382
                         { DROP ;
383
                           SWAP ;
384
                           DUP ;
385
                           DUG 2 ;
386
                           GET 31 ;
387
                           SWAP ;
388
                           DUP ;
389
                           DUG 2 ;
390
                           DUP 4 ;
391
                           GET 29 ;
392
                           ADD ;
393
                           COMPARE ;
394
                           LE ;
395
                           IF {} { PUSH string "PRESALE_LIMIT_EXCEEDED" ; FAILWITH } ;
396
                           SWAP ;
397
                           DUP ;
398
                           DUG 2 ;
399
                           GET 37 ;
400
                           SENDER ;
401
                           MEM ;
402
                           IF {} { PUSH string "NOT_WHITELISTED" ; FAILWITH } ;
403
                           SWAP ;
404
                           DUP ;
405
                           GET 37 ;
406
                           DUP ;
407
                           SENDER ;
408
                           DUP ;
409
                           DUG 2 ;
410
                           GET ;
411
                           IF_NONE { PUSH int 277 ; FAILWITH } {} ;
412
                           DUP 5 ;
413
                           ADD ;
414
                           SOME ;
415
                           SWAP ;
416
                           UPDATE ;
417
                           UPDATE 37 ;
418
                           DUP ;
419
                           DUG 2 ;
420
                           GET 33 ;
421
                           SWAP ;
422
                           DUP ;
423
                           DUG 2 ;
424
                           MUL ;
425
                           DIG 2 ;
426
                           DUP ;
427
                           GET 29 ;
428
                           DUP 4 ;
429
                           ADD ;
430
                           UPDATE 29 ;
431
                           DUG 2 }
432
                         { DUP 3 ;
433
                           GET 53 ;
434
                           NOW ;
435
                           COMPARE ;
436
                           LE ;
437
                           IF
438
                             { DROP ;
439
                               SWAP ;
440
                               DUP ;
441
                               DUG 2 ;
442
                               GET 41 ;
443
                               SWAP ;
444
                               DUP ;
445
                               DUG 2 ;
446
                               DUP 4 ;
447
                               GET 39 ;
448
                               ADD ;
449
                               COMPARE ;
450
                               LE ;
451
                               IF
452
                                 {}
453
                                 { PUSH string "PRESALE_LIMIT_EXCEEDED" ; FAILWITH } ;
454
                               SWAP ;
455
                               DUP ;
456
                               DUG 2 ;
457
                               GET 37 ;
458
                               SENDER ;
459
                               MEM ;
460
                               IF
461
                                 { PUSH bool True }
462
                                 { SWAP ; DUP ; DUG 2 ; GET 47 ; SENDER ; MEM } ;
463
                               IF {} { PUSH string "NOT_WHITELISTED" ; FAILWITH } ;
464
                               SWAP ;
465
                               DUP ;
466
                               DUG 2 ;
467
                               GET 43 ;
468
                               SWAP ;
469
                               DUP ;
470
                               DUG 2 ;
471
                               MUL ;
472
                               DUP 3 ;
473
                               GET 37 ;
474
                               SENDER ;
475
                               MEM ;
476
                               IF
477
                                 { DIG 2 ;
478
                                   DUP ;
479
                                   GET 37 ;
480
                                   DUP ;
481
                                   SENDER ;
482
                                   DUP ;
483
                                   DUG 2 ;
484
                                   GET ;
485
                                   IF_NONE { PUSH int 289 ; FAILWITH } {} ;
486
                                   DUP 6 ;
487
                                   ADD ;
488
                                   SOME ;
489
                                   SWAP ;
490
                                   UPDATE ;
491
                                   UPDATE 37 ;
492
                                   DUG 2 }
493
                                 { DIG 2 ;
494
                                   DUP ;
495
                                   GET 47 ;
496
                                   DUP ;
497
                                   SENDER ;
498
                                   DUP ;
499
                                   DUG 2 ;
500
                                   GET ;
501
                                   IF_NONE { PUSH int 291 ; FAILWITH } {} ;
502
                                   DUP 6 ;
503
                                   ADD ;
504
                                   SOME ;
505
                                   SWAP ;
506
                                   UPDATE ;
507
                                   UPDATE 47 ;
508
                                   DUG 2 } ;
509
                               DIG 2 ;
510
                               DUP ;
511
                               GET 39 ;
512
                               DUP 4 ;
513
                               ADD ;
514
                               UPDATE 39 ;
515
                               DUG 2 }
516
                             { DUP 3 ;
517
                               GET 21 ;
518
                               SENDER ;
519
                               MEM ;
520
                               IF
521
                                 { LEVEL ;
522
                                   DUP 4 ;
523
                                   GET 21 ;
524
                                   SENDER ;
525
                                   GET ;
526
                                   IF_NONE { PUSH int 302 ; FAILWITH } {} ;
527
                                   CAR ;
528
                                   COMPARE ;
529
                                   LT ;
530
                                   IF
531
                                     {}
532
                                     { PUSH string "ONLY_ONE_TRANSACTION_PER_LEVEL" ;
533
                                       FAILWITH } ;
534
                                   DIG 2 ;
535
                                   DUP ;
536
                                   GET 21 ;
537
                                   DUP ;
538
                                   SENDER ;
539
                                   DUP ;
540
                                   DUG 2 ;
541
                                   GET ;
542
                                   IF_NONE { PUSH int 303 ; FAILWITH } {} ;
543
                                   DUP ;
544
                                   CDR ;
545
                                   DUP 7 ;
546
                                   ADD ;
547
                                   UPDATE 2 ;
548
                                   SOME ;
549
                                   SWAP ;
550
                                   UPDATE ;
551
                                   UPDATE 21 ;
552
                                   DUP ;
553
                                   GET 21 ;
554
                                   DUP ;
555
                                   SENDER ;
556
                                   DUP ;
557
                                   DUG 2 ;
558
                                   GET ;
559
                                   IF_NONE { PUSH int 304 ; FAILWITH } {} ;
560
                                   LEVEL ;
561
                                   DIG 5 ;
562
                                   DROP ;
563
                                   UPDATE 1 ;
564
                                   SOME ;
565
                                   SWAP ;
566
                                   UPDATE ;
567
                                   UPDATE 21 ;
568
                                   SWAP }
569
                                 { DIG 2 ;
570
                                   DUP ;
571
                                   GET 21 ;
572
                                   DUP 4 ;
573
                                   LEVEL ;
574
                                   DIG 4 ;
575
                                   DROP ;
576
                                   PAIR ;
577
                                   SOME ;
578
                                   SENDER ;
579
                                   UPDATE ;
580
                                   UPDATE 21 ;
581
                                   SWAP } ;
582
                               SWAP ;
583
                               DUP ;
584
                               GET 13 ;
585
                               SWAP ;
586
                               DUP ;
587
                               DUG 3 ;
588
                               GET 21 ;
589
                               SENDER ;
590
                               GET ;
591
                               IF_NONE { PUSH int 306 ; FAILWITH } {} ;
592
                               CDR ;
593
                               COMPARE ;
594
                               LE ;
595
                               IF
596
                                 {}
597
                                 { PUSH string "TOTAL_MINT_LIMIT_EXCEEDED" ; FAILWITH } ;
598
                               SWAP ;
599
                               DUP ;
600
                               DUG 2 ;
601
                               GET 51 ;
602
                               SWAP ;
603
                               DUP ;
604
                               DUG 2 ;
605
                               MUL } } ;
606
                       DUP ;
607
                       AMOUNT ;
608
                       COMPARE ;
609
                       EQ ;
610
                       IF {} { PUSH string "INVALID_PRICE" ; FAILWITH } ;
611
                       PUSH nat 0 ;
612
                       NIL (pair address (pair nat (pair bytes nat))) ;
613
                       DUP 5 ;
614
                       GET 17 ;
615
                       DUP 5 ;
616
                       DUP 4 ;
617
                       COMPARE ;
618
                       LT ;
619
                       LOOP { DUP 7 ;
620
                              SWAP ;
621
                              DUP ;
622
                              DUG 2 ;
623
                              SWAP ;
624
                              DIG 7 ;
625
                              DIG 2 ;
626
                              PAIR ;
627
                              EXEC ;
628
                              UNPAIR ;
629
                              DIG 7 ;
630
                              DIG 2 ;
631
                              DUG 7 ;
632
                              DUG 7 ;
633
                              DUP 3 ;
634
                              DUP 3 ;
635
                              DUP 3 ;
636
                              PUSH nat 1 ;
637
                              SENDER ;
638
                              PAIR 4 ;
639
                              DIG 2 ;
640
                              DROP ;
641
                              DIG 3 ;
642
                              DROP ;
643
                              CONS ;
644
                              SWAP ;
645
                              PUSH nat 1 ;
646
                              ADD ;
647
                              DUP 6 ;
648
                              GET 58 ;
649
                              SWAP ;
650
                              DUP ;
651
                              DUG 2 ;
652
                              COMPARE ;
653
                              GT ;
654
                              IF { DROP ; PUSH nat 1 } {} ;
655
                              PUSH nat 1 ;
656
                              DIG 3 ;
657
                              ADD ;
658
                              DUG 2 ;
659
                              DUP 5 ;
660
                              DUP 4 ;
661
                              COMPARE ;
662
                              LT } ;
663
                       DIG 2 ;
664
                       DROP ;
665
                       DIG 5 ;
666
                       DROP ;
667
                       NIL operation ;
668
                       DUP 6 ;
669
                       GET 7 ;
670
                       CONTRACT %mint (list (pair (address %address)
671
                                                 (pair (nat %amount)
672
                                                       (pair (bytes %metadata)
673
                                                             (nat %token_id))))) ;
674
                       IF_NONE { PUSH int 318 ; FAILWITH } {} ;
675
                       PUSH mutez 0 ;
676
                       DIG 4 ;
677
                       TRANSFER_TOKENS ;
678
                       CONS ;
679
                       DIG 4 ;
680
                       DUP ;
681
                       GET 57 ;
682
                       DIG 5 ;
683
                       ADD ;
684
                       UPDATE 57 ;
685
                       DIG 2 ;
686
                       UPDATE 17 ;
687
                       DUG 2 ;
688
                       PUSH nat 100 ;
689
                       PUSH nat 10 ;
690
                       DUP 4 ;
691
                       MUL ;
692
                       EDIV ;
693
                       IF_NONE { PUSH int 341 ; FAILWITH } {} ;
694
                       CAR ;
695
                       SWAP ;
696
                       DUP 4 ;
697
                       GET 5 ;
698
                       CONTRACT unit ;
699
                       IF_NONE { PUSH int 342 ; FAILWITH } {} ;
700
                       DUP 3 ;
701
                       UNIT ;
702
                       TRANSFER_TOKENS ;
703
                       CONS ;
704
                       DUP 4 ;
705
                       GET 3 ;
706
                       CONTRACT unit ;
707
                       IF_NONE { PUSH int 344 ; FAILWITH } {} ;
708
                       DIG 2 ;
709
                       DIG 3 ;
710
                       SUB_MUTEZ ;
711
                       IF_NONE { PUSH int 344 ; FAILWITH } {} ;
712
                       UNIT ;
713
                       TRANSFER_TOKENS ;
714
                       CONS }
715
                     { DIG 2 ;
716
                       DROP ;
717
                       SWAP ;
718
                       DUP ;
719
                       DUG 2 ;
720
                       GET 25 ;
721
                       IF {} { PUSH string "NOT_ALLOWED" ; FAILWITH } ;
722
                       SWAP ;
723
                       DUP ;
724
                       DUG 2 ;
725
                       PUSH nat 1 ;
726
                       DIG 3 ;
727
                       GET 58 ;
728
                       DIG 3 ;
729
                       GET 4 ;
730
                       EDIV ;
731
                       IF_NONE { PUSH int 190 ; FAILWITH } { CDR } ;
732
                       ADD ;
733
                       UPDATE 17 ;
734
                       PUSH bool False ;
735
                       UPDATE 25 ;
736
                       NIL operation } }
737
                 { IF_LEFT
738
                     { DIG 2 ;
739
                       DROP ;
740
                       SWAP ;
741
                       DUP ;
742
                       DUG 2 ;
743
                       CAR ;
744
                       SENDER ;
745
                       COMPARE ;
746
                       EQ ;
747
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
748
                       UPDATE 7 ;
749
                       NIL operation }
750
                     { SWAP ;
751
                       DUP ;
752
                       DUG 2 ;
753
                       CAR ;
754
                       SENDER ;
755
                       COMPARE ;
756
                       EQ ;
757
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
758
                       SWAP ;
759
                       DUP ;
760
                       DUG 2 ;
761
                       GET 9 ;
762
                       SWAP ;
763
                       DUP ;
764
                       DUG 2 ;
765
                       CDR ;
766
                       DUP 4 ;
767
                       GET 11 ;
768
                       ADD ;
769
                       COMPARE ;
770
                       LE ;
771
                       IF {} { PUSH string "GIVEAWAY_LIMIT_EXCEEDED" ; FAILWITH } ;
772
                       SWAP ;
773
                       DUP ;
774
                       DUG 2 ;
775
                       GET 58 ;
776
                       SWAP ;
777
                       DUP ;
778
                       DUG 2 ;
779
                       CDR ;
780
                       DUP 4 ;
781
                       GET 57 ;
782
                       ADD ;
783
                       COMPARE ;
784
                       LE ;
785
                       IF {} { PUSH string "TOTAL_SUPPLY_EXCEEDED" ; FAILWITH } ;
786
                       PUSH nat 0 ;
787
                       NIL (pair address (pair nat (pair bytes nat))) ;
788
                       DUP 4 ;
789
                       GET 17 ;
790
                       DUP 4 ;
791
                       CDR ;
792
                       DUP 4 ;
793
                       COMPARE ;
794
                       LT ;
795
                       LOOP { DUP 6 ;
796
                              SWAP ;
797
                              DUP ;
798
                              DUG 2 ;
799
                              SWAP ;
800
                              DIG 6 ;
801
                              DIG 2 ;
802
                              PAIR ;
803
                              EXEC ;
804
                              UNPAIR ;
805
                              DIG 6 ;
806
                              DIG 2 ;
807
                              DUG 6 ;
808
                              DUG 6 ;
809
                              DUP 3 ;
810
                              DUP 3 ;
811
                              DUP 3 ;
812
                              PUSH nat 1 ;
813
                              DUP 9 ;
814
                              CAR ;
815
                              PAIR 4 ;
816
                              DIG 2 ;
817
                              DROP ;
818
                              DIG 3 ;
819
                              DROP ;
820
                              CONS ;
821
                              SWAP ;
822
                              PUSH nat 1 ;
823
                              ADD ;
824
                              DUP 5 ;
825
                              GET 58 ;
826
                              SWAP ;
827
                              DUP ;
828
                              DUG 2 ;
829
                              COMPARE ;
830
                              GT ;
831
                              IF { DROP ; PUSH nat 1 } {} ;
832
                              PUSH nat 1 ;
833
                              DIG 3 ;
834
                              ADD ;
835
                              DUG 2 ;
836
                              DUP 4 ;
837
                              CDR ;
838
                              DUP 4 ;
839
                              COMPARE ;
840
                              LT } ;
841
                       DIG 2 ;
842
                       DROP ;
843
                       DIG 4 ;
844
                       DROP ;
845
                       NIL operation ;
846
                       DUP 5 ;
847
                       GET 7 ;
848
                       CONTRACT %mint (list (pair (address %address)
849
                                                 (pair (nat %amount)
850
                                                       (pair (bytes %metadata)
851
                                                             (nat %token_id))))) ;
852
                       IF_NONE { PUSH int 234 ; FAILWITH } {} ;
853
                       PUSH mutez 0 ;
854
                       DIG 4 ;
855
                       TRANSFER_TOKENS ;
856
                       CONS ;
857
                       DIG 3 ;
858
                       DUP ;
859
                       GET 57 ;
860
                       DUP 5 ;
861
                       CDR ;
862
                       ADD ;
863
                       UPDATE 57 ;
864
                       DIG 2 ;
865
                       UPDATE 17 ;
866
                       DUP ;
867
                       GET 11 ;
868
                       DIG 3 ;
869
                       CDR ;
870
                       ADD ;
871
                       UPDATE 11 ;
872
                       SWAP } } } }
873
         { IF_LEFT
874
             { IF_LEFT
875
                 { IF_LEFT
876
                     { DIG 2 ;
877
                       DROP ;
878
                       SWAP ;
879
                       DUP ;
880
                       DUG 2 ;
881
                       CAR ;
882
                       SENDER ;
883
                       COMPARE ;
884
                       EQ ;
885
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
886
                       NIL operation ;
887
                       DUP 3 ;
888
                       GET 7 ;
889
                       CONTRACT %update_token_metadata (list (pair (bytes %metadata)
890
                                                                  (nat %token_id))) ;
891
                       IF_NONE { PUSH int 360 ; FAILWITH } {} ;
892
                       PUSH mutez 0 ;
893
                       DIG 3 ;
894
                       TRANSFER_TOKENS ;
895
                       CONS }
896
                     { DIG 2 ;
897
                       DROP ;
898
                       SWAP ;
899
                       DUP ;
900
                       DUG 2 ;
901
                       CAR ;
902
                       SENDER ;
903
                       COMPARE ;
904
                       EQ ;
905
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
906
                       UPDATE 1 ;
907
                       NIL operation } }
908
                 { DIG 2 ;
909
                   DROP ;
910
                   IF_LEFT
911
                     { SWAP ;
912
                       DUP ;
913
                       DUG 2 ;
914
                       CAR ;
915
                       SENDER ;
916
                       COMPARE ;
917
                       EQ ;
918
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
919
                       UPDATE 9 }
920
                     { SWAP ;
921
                       DUP ;
922
                       DUG 2 ;
923
                       CAR ;
924
                       SENDER ;
925
                       COMPARE ;
926
                       EQ ;
927
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
928
                       DUP ;
929
                       DUG 2 ;
930
                       CAR ;
931
                       UPDATE 31 ;
932
                       SWAP ;
933
                       CDR ;
934
                       UPDATE 41 } ;
935
                   NIL operation } }
936
             { IF_LEFT
937
                 { DIG 2 ;
938
                   DROP ;
939
                   IF_LEFT
940
                     { SWAP ;
941
                       DUP ;
942
                       DUG 2 ;
943
                       CAR ;
944
                       SENDER ;
945
                       COMPARE ;
946
                       EQ ;
947
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
948
                       DUP ;
949
                       DUG 2 ;
950
                       GET 4 ;
951
                       UPDATE 51 ;
952
                       SWAP ;
953
                       DUP ;
954
                       DUG 2 ;
955
                       CAR ;
956
                       UPDATE 33 ;
957
                       SWAP ;
958
                       GET 3 ;
959
                       UPDATE 43 }
960
                     { SWAP ;
961
                       DUP ;
962
                       DUG 2 ;
963
                       CAR ;
964
                       SENDER ;
965
                       COMPARE ;
966
                       EQ ;
967
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
968
                       DUP ;
969
                       GET 3 ;
970
                       SWAP ;
971
                       DUP ;
972
                       DUG 2 ;
973
                       CAR ;
974
                       COMPARE ;
975
                       LT ;
976
                       IF {} { PUSH string "INVALID_TIME" ; FAILWITH } ;
977
                       DUP ;
978
                       GET 4 ;
979
                       SWAP ;
980
                       DUP ;
981
                       DUG 2 ;
982
                       GET 3 ;
983
                       COMPARE ;
984
                       LT ;
985
                       IF {} { PUSH string "INVALID_TIME" ; FAILWITH } ;
986
                       DUP ;
987
                       DUG 2 ;
988
                       CAR ;
989
                       UPDATE 35 ;
990
                       SWAP ;
991
                       DUP ;
992
                       DUG 2 ;
993
                       GET 3 ;
994
                       UPDATE 45 ;
995
                       SWAP ;
996
                       GET 4 ;
997
                       UPDATE 53 } ;
998
                   NIL operation }
999
                 { IF_LEFT
1000
                     { DROP ;
1001
                       SWAP ;
1002
                       DROP ;
1003
                       DUP ;
1004
                       CAR ;
1005
                       SENDER ;
1006
                       COMPARE ;
1007
                       EQ ;
1008
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1009
                       PUSH bool True ;
1010
                       UPDATE 25 ;
1011
                       DUP ;
1012
                       GET 23 ;
1013
                       CONTRACT %get (pair string
1014
                                           (contract (pair (string %currency_pair)
1015
                                                          (pair (timestamp %last_update)
1016
                                                                (nat %rate))))) ;
1017
                       IF_NONE { PUSH string "Invalid contract" ; FAILWITH } {} ;
1018
                       NIL operation ;
1019
                       SWAP ;
1020
                       PUSH mutez 0 ;
1021
                       SELF %oracle_callback ;
1022
                       PUSH string "XTZ-USD" ;
1023
                       PAIR ;
1024
                       TRANSFER_TOKENS ;
1025
                       CONS }
1026
                     { DIG 2 ;
1027
                       DROP ;
1028
                       SWAP ;
1029
                       DUP ;
1030
                       DUG 2 ;
1031
                       CAR ;
1032
                       SENDER ;
1033
                       COMPARE ;
1034
                       EQ ;
1035
                       IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1036
                       DUP ;
1037
                       DUG 2 ;
1038
                       CAR ;
1039
                       UPDATE 13 ;
1040
                       SWAP ;
1041
                       CDR ;
1042
                       UPDATE 19 ;
1043
                       NIL operation } } } } ;
1044
       NIL operation ;
1045
       SWAP ;
1046
       ITER { CONS } ;
1047
       PAIR }