BCD

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