BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Ghostnet
  • /
  • Temple Multiple Edition Test Final
FA2Ledger
operations (10)Storage Code Interact Tokens Metadata Fork Views Events Statistics Details
Latest
​x
798
1583
 
1
{ parameter (or
2
              (or
3
                (or
4
                  (or (unit %accept_admin)
5
                      (pair %balance_of
6
                        (list %requests (pair (address %owner) (nat %token_id)))
7
                        (contract %callback (list (pair
8
                                                  (pair %request (address %owner)
9
                                                                 (nat %token_id))
10
                                                  (nat %balance))))))
11
                  (or
12
                    (list %burn (pair (address %from_)
13
                                     (pair (nat %token_id) (nat %amount))))
14
                    (nat %cancel_listing)))
15
                (or
16
                  (or (pair %collect (nat %collect_id) (nat %amount))
17
                      (pair %create_listing (nat %token_id)
18
                                            (pair (timestamp %start_time)
19
                                                  (pair (option %end_time timestamp)
20
                                                        (pair (nat %token_edition_size)
21
                                                              (pair (mutez %token_price)
22
                                                                    (pair
23
                                                                      (nat %max_editions_per_wallet)
24
                                                                      (pair
25
                                                                        (list %sale_split (pair
26
                                                                                           (address %address)
27
                                                                                           (nat %royalties)))
28
                                                                        (option %special_split (list (pair
29
                                                                                                     (address %address)
30
                                                                                                     (mutez %amount))))))))))))
31
                  (or
32
                    (list %create_tokens (pair (map %metadata string bytes)
33
                                              (list %royalties (pair (address %address)
34
                                                                    (nat %royalties)))))
35
                    (or
36
                      (list %mint (pair (nat %token_id)
37
                                       (list %recipients (pair (address %address)
38
                                                              (nat %amount)))))
39
                      (address %propose_admin)))))
40
              (or
41
                (or
42
                  (or (map %set_metadata string bytes)
43
                      (pair %set_pause_states (option %mint_paused bool)
44
                                              (pair (option %listing_paused bool)
45
                                                    (option %collects_paused bool))))
46
                  (or
47
                    (list %transfer (pair (address %from_)
48
                                         (list %txs (pair (address %to_)
49
                                                         (pair (nat %token_id)
50
                                                               (nat %amount))))))
51
                    (list %update_helpers (pair (address %address) (bool %is_admin)))))
52
                (or
53
                  (or
54
                    (list %update_info_maps (pair (address %address)
55
                                                 (pair (list %token_ids nat)
56
                                                       (pair (bool %delete)
57
                                                             (bool %is_temp)))))
58
                    (list %update_operators (or
59
                                             (pair %add_operator (address %owner)
60
                                                                 (pair
61
                                                                   (address %operator)
62
                                                                   (nat %token_id)))
63
                                             (pair %remove_operator (address %owner)
64
                                                                    (pair
65
                                                                      (address %operator)
66
                                                                      (nat %token_id))))))
67
                  (or
68
                    (list %update_token_metadata (pair (nat %token_id)
69
                                                      (map %new_metadata string bytes)))
70
                    (or (pair %withdraw_tez (address %address) (mutez %amount))
71
                        (pair %withdraw_token (nat %token_id)
72
                                              (address %receiver_address))))))) ;
73
  storage (pair
74
            (pair
75
              (pair
76
                (pair (big_map %additional_infos (pair address nat) unit)
77
                      (address %admin))
78
                (pair (bool %collects_paused) (big_map %helpers address unit)))
79
              (pair (pair (nat %last_token_id) (big_map %ledger (pair address nat) nat))
80
                    (pair (bool %listing_paused)
81
                          (big_map %listings nat
82
                                             (pair
83
                                               (pair
84
                                                 (pair (bool %active) (address %creator))
85
                                                 (pair (option %end_time timestamp)
86
                                                       (pair
87
                                                         (nat %max_editions_per_wallet)
88
                                                         (list %sale_split (pair
89
                                                                            (address %address)
90
                                                                            (nat %royalties))))))
91
                                               (pair
92
                                                 (pair
93
                                                   (option %special_split (list (pair
94
                                                                                (address %address)
95
                                                                                (mutez %amount))))
96
                                                   (timestamp %start_time))
97
                                                 (pair (nat %token_edition_size)
98
                                                       (pair (nat %token_id)
99
                                                             (mutez %token_price)))))))))
100
            (pair
101
              (pair (pair (big_map %metadata string bytes) (bool %mint_paused))
102
                    (pair (big_map %minted nat nat)
103
                          (big_map %operators
104
                            (pair (address %owner)
105
                                  (pair (address %operator) (nat %token_id)))
106
                            unit)))
107
              (pair (pair (option %proposed_admin address) (big_map %supply nat nat))
108
                    (pair (big_map %temp_infos (pair address nat) unit)
109
                          (pair
110
                            (big_map %token_metadata nat
111
                                                     (pair (nat %token_id)
112
                                                           (map %token_info string bytes)))
113
                            (big_map %token_royalties nat
114
                                                      (list (pair (address %address)
115
                                                                 (nat %royalties))))))))) ;
116
  code { UNPAIR ;
117
         IF_LEFT
118
           { IF_LEFT
119
               { IF_LEFT
120
                   { IF_LEFT
121
                       { DROP ;
122
                         PUSH mutez 0 ;
123
                         AMOUNT ;
124
                         COMPARE ;
125
                         EQ ;
126
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
127
                         DUP ;
128
                         GET 5 ;
129
                         CAR ;
130
                         IF_NONE
131
                           { PUSH string "NO_ADMIN_PROPOSED" ; FAILWITH }
132
                           { DROP } ;
133
                         DUP ;
134
                         GET 5 ;
135
                         CAR ;
136
                         IF_NONE { PUSH int 640 ; FAILWITH } {} ;
137
                         SENDER ;
138
                         COMPARE ;
139
                         EQ ;
140
                         IF {} { PUSH string "NOT_PROPOSED_ADMIN" ; FAILWITH } ;
141
                         UNPAIR ;
142
                         UNPAIR ;
143
                         UNPAIR ;
144
                         CAR ;
145
                         SENDER ;
146
                         SWAP ;
147
                         PAIR ;
148
                         PAIR ;
149
                         PAIR ;
150
                         SWAP ;
151
                         UNPAIR ;
152
                         SWAP ;
153
                         UNPAIR ;
154
                         CDR ;
155
                         NONE address ;
156
                         PAIR ;
157
                         PAIR ;
158
                         SWAP ;
159
                         PAIR ;
160
                         SWAP ;
161
                         PAIR ;
162
                         NIL operation ;
163
                         DUP 2 ;
164
                         CAR ;
165
                         CAR ;
166
                         CAR ;
167
                         CDR ;
168
                         SENDER ;
169
                         PAIR ;
170
                         EMIT %admin_accepted (pair (address %new_admin)
171
                                                    (address %old_admin)) ;
172
                         CONS }
173
                       { NIL operation ;
174
                         DUP ;
175
                         DUP 3 ;
176
                         CDR ;
177
                         PUSH mutez 0 ;
178
                         DUP 5 ;
179
                         CAR ;
180
                         MAP { DUP 7 ;
181
                               GET 9 ;
182
                               DUP 2 ;
183
                               CDR ;
184
                               MEM ;
185
                               IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
186
                               DUP 7 ;
187
                               CAR ;
188
                               GET 3 ;
189
                               CDR ;
190
                               DUP 2 ;
191
                               CDR ;
192
                               DUP 3 ;
193
                               CAR ;
194
                               PAIR ;
195
                               GET ;
196
                               IF_NONE { PUSH nat 0 } {} ;
197
                               SWAP ;
198
                               PAIR } ;
199
                         DIG 4 ;
200
                         DROP ;
201
                         DIG 4 ;
202
                         DROP ;
203
                         TRANSFER_TOKENS ;
204
                         CONS } }
205
                   { IF_LEFT
206
                       { DUP ;
207
                         ITER { DUP 3 ;
208
                                GET 9 ;
209
                                DUP 2 ;
210
                                GET 3 ;
211
                                MEM ;
212
                                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
213
                                DUP ;
214
                                CAR ;
215
                                SENDER ;
216
                                COMPARE ;
217
                                EQ ;
218
                                IF
219
                                  { PUSH bool True }
220
                                  { DUP 3 ; GET 3 ; GET 4 ; DUP 2 ; GET 3 ; SENDER ; DUP 4 ; CAR ; PAIR 3 ; MEM } ;
221
                                IF {} { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;
222
                                DUP 3 ;
223
                                UNPAIR ;
224
                                UNPAIR ;
225
                                SWAP ;
226
                                UNPAIR ;
227
                                UNPAIR ;
228
                                SWAP ;
229
                                DUP 6 ;
230
                                GET 4 ;
231
                                DIG 8 ;
232
                                CAR ;
233
                                GET 3 ;
234
                                CDR ;
235
                                DUP 8 ;
236
                                GET 3 ;
237
                                DUP 9 ;
238
                                CAR ;
239
                                PAIR ;
240
                                GET ;
241
                                IF_NONE { PUSH nat 0 } {} ;
242
                                SUB ;
243
                                ISNAT ;
244
                                IF_NONE
245
                                  { PUSH string "FA2_INSUFFICIENT_BALANCE" ; FAILWITH }
246
                                  {} ;
247
                                SOME ;
248
                                DUP 7 ;
249
                                GET 3 ;
250
                                DUP 8 ;
251
                                CAR ;
252
                                PAIR ;
253
                                UPDATE ;
254
                                SWAP ;
255
                                PAIR ;
256
                                PAIR ;
257
                                SWAP ;
258
                                PAIR ;
259
                                PAIR ;
260
                                DUG 2 ;
261
                                DUP ;
262
                                GET 4 ;
263
                                DUP 4 ;
264
                                GET 5 ;
265
                                CDR ;
266
                                DUP 3 ;
267
                                GET 3 ;
268
                                GET ;
269
                                IF_NONE { PUSH nat 0 } {} ;
270
                                SUB ;
271
                                ISNAT ;
272
                                IF_NONE
273
                                  { DIG 2 ;
274
                                    UNPAIR ;
275
                                    SWAP ;
276
                                    UNPAIR ;
277
                                    SWAP ;
278
                                    UNPAIR ;
279
                                    UNPAIR ;
280
                                    SWAP ;
281
                                    PUSH (option nat) (Some 0) ;
282
                                    DIG 6 ;
283
                                    GET 3 ;
284
                                    UPDATE ;
285
                                    SWAP ;
286
                                    PAIR ;
287
                                    PAIR ;
288
                                    SWAP ;
289
                                    PAIR ;
290
                                    SWAP ;
291
                                    PAIR ;
292
                                    SWAP }
293
                                  { DIG 3 ;
294
                                    UNPAIR ;
295
                                    SWAP ;
296
                                    UNPAIR ;
297
                                    SWAP ;
298
                                    UNPAIR ;
299
                                    UNPAIR ;
300
                                    SWAP ;
301
                                    DIG 5 ;
302
                                    SOME ;
303
                                    DIG 6 ;
304
                                    GET 3 ;
305
                                    UPDATE ;
306
                                    SWAP ;
307
                                    PAIR ;
308
                                    PAIR ;
309
                                    SWAP ;
310
                                    PAIR ;
311
                                    SWAP ;
312
                                    PAIR ;
313
                                    SWAP } } ;
314
                         DROP }
315
                       { PUSH mutez 0 ;
316
                         AMOUNT ;
317
                         COMPARE ;
318
                         EQ ;
319
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
320
                         DUP 2 ;
321
                         CAR ;
322
                         GET 6 ;
323
                         DUP 2 ;
324
                         MEM ;
325
                         IF {} { PUSH string "LISTING_NOT_FOUND" ; FAILWITH } ;
326
                         DUP 2 ;
327
                         CAR ;
328
                         CAR ;
329
                         CAR ;
330
                         CDR ;
331
                         SENDER ;
332
                         COMPARE ;
333
                         EQ ;
334
                         IF
335
                           { PUSH bool True }
336
                           { DUP 2 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
337
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
338
                         SWAP ;
339
                         UNPAIR ;
340
                         UNPAIR ;
341
                         SWAP ;
342
                         UNPAIR ;
343
                         SWAP ;
344
                         UNPAIR ;
345
                         SWAP ;
346
                         NONE (pair
347
                                (pair (pair bool address)
348
                                      (pair (option timestamp)
349
                                            (pair nat (list (pair address nat)))))
350
                                (pair
351
                                  (pair (option (list (pair address mutez))) timestamp)
352
                                  (pair nat (pair nat mutez)))) ;
353
                         DIG 6 ;
354
                         UPDATE ;
355
                         SWAP ;
356
                         PAIR ;
357
                         SWAP ;
358
                         PAIR ;
359
                         SWAP ;
360
                         PAIR ;
361
                         PAIR } ;
362
                     NIL operation } }
363
               { IF_LEFT
364
                   { IF_LEFT
365
                       { DUP 2 ;
366
                         CAR ;
367
                         CAR ;
368
                         GET 3 ;
369
                         IF { PUSH string "COLLECTS_PAUSED" ; FAILWITH } {} ;
370
                         PUSH nat 0 ;
371
                         DUP 2 ;
372
                         CDR ;
373
                         COMPARE ;
374
                         GT ;
375
                         IF {} { PUSH string "ZERO_AMOUNT_NOT_ALLOWED" ; FAILWITH } ;
376
                         DUP 2 ;
377
                         CAR ;
378
                         GET 6 ;
379
                         DUP 2 ;
380
                         CAR ;
381
                         MEM ;
382
                         IF {} { PUSH string "COLLECT_ID_NOT_FOUND" ; FAILWITH } ;
383
                         DUP 2 ;
384
                         CAR ;
385
                         GET 6 ;
386
                         DUP 2 ;
387
                         CAR ;
388
                         GET ;
389
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
390
                         CAR ;
391
                         CAR ;
392
                         CAR ;
393
                         IF {} { PUSH string "LISTING_NOT_ACTIVE" ; FAILWITH } ;
394
                         DUP 2 ;
395
                         CAR ;
396
                         GET 6 ;
397
                         DUP 2 ;
398
                         CAR ;
399
                         GET ;
400
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
401
                         GET 3 ;
402
                         CDR ;
403
                         NOW ;
404
                         COMPARE ;
405
                         GE ;
406
                         IF {} { PUSH string "LISTING_NOT_STARTED" ; FAILWITH } ;
407
                         DUP 2 ;
408
                         CAR ;
409
                         GET 6 ;
410
                         DUP 2 ;
411
                         CAR ;
412
                         GET ;
413
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
414
                         CAR ;
415
                         GET 3 ;
416
                         IF_NONE
417
                           {}
418
                           { DROP ;
419
                             DUP 2 ;
420
                             CAR ;
421
                             GET 6 ;
422
                             DUP 2 ;
423
                             CAR ;
424
                             GET ;
425
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
426
                             CAR ;
427
                             GET 3 ;
428
                             IF_NONE { PUSH int 265 ; FAILWITH } {} ;
429
                             NOW ;
430
                             COMPARE ;
431
                             LT ;
432
                             IF {} { PUSH string "LISTING_ENDED" ; FAILWITH } } ;
433
                         DUP 2 ;
434
                         CAR ;
435
                         GET 6 ;
436
                         DUP 2 ;
437
                         CAR ;
438
                         GET ;
439
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
440
                         GET 5 ;
441
                         DUP 2 ;
442
                         CDR ;
443
                         DUP 4 ;
444
                         GET 3 ;
445
                         GET 3 ;
446
                         DUP 4 ;
447
                         CAR ;
448
                         GET ;
449
                         IF_NONE { PUSH nat 0 } {} ;
450
                         ADD ;
451
                         COMPARE ;
452
                         LE ;
453
                         IF {} { PUSH string "NOT_ENOUGH_EDITIONS_LEFT" ; FAILWITH } ;
454
                         DUP 2 ;
455
                         CAR ;
456
                         CAR ;
457
                         CAR ;
458
                         CAR ;
459
                         DUP 3 ;
460
                         CAR ;
461
                         GET 6 ;
462
                         DUP 3 ;
463
                         CAR ;
464
                         GET ;
465
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
466
                         GET 7 ;
467
                         SENDER ;
468
                         PAIR ;
469
                         MEM ;
470
                         IF { PUSH string "RESTRICTED_COLLECT" ; FAILWITH } {} ;
471
                         PUSH nat 0 ;
472
                         DUP 3 ;
473
                         CAR ;
474
                         GET 6 ;
475
                         DUP 3 ;
476
                         CAR ;
477
                         GET ;
478
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
479
                         CAR ;
480
                         GET 5 ;
481
                         COMPARE ;
482
                         NEQ ;
483
                         IF
484
                           { DUP 2 ;
485
                             CAR ;
486
                             GET 6 ;
487
                             DUP 2 ;
488
                             CAR ;
489
                             GET ;
490
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
491
                             CAR ;
492
                             GET 5 ;
493
                             DUP 2 ;
494
                             CDR ;
495
                             DUP 4 ;
496
                             CAR ;
497
                             GET 3 ;
498
                             CDR ;
499
                             DUP 5 ;
500
                             CAR ;
501
                             GET 6 ;
502
                             DUP 5 ;
503
                             CAR ;
504
                             GET ;
505
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
506
                             GET 7 ;
507
                             SENDER ;
508
                             PAIR ;
509
                             GET ;
510
                             IF_NONE { PUSH nat 0 } {} ;
511
                             ADD ;
512
                             COMPARE ;
513
                             LE ;
514
                             IF {} { PUSH string "MAX_EDITIONS_EXCEEDED" ; FAILWITH } }
515
                           {} ;
516
                         PUSH mutez 0 ;
517
                         DUP 3 ;
518
                         CAR ;
519
                         GET 6 ;
520
                         DUP 3 ;
521
                         CAR ;
522
                         GET ;
523
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
524
                         GET 3 ;
525
                         CAR ;
526
                         IF_NONE
527
                           {}
528
                           { DROP ;
529
                             DUP 3 ;
530
                             CAR ;
531
                             GET 6 ;
532
                             DUP 3 ;
533
                             CAR ;
534
                             GET ;
535
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
536
                             GET 3 ;
537
                             CAR ;
538
                             IF_NONE { PUSH int 288 ; FAILWITH } {} ;
539
                             ITER { CDR ; DUP 3 ; CDR ; MUL ; ADD } } ;
540
                         DUP ;
541
                         DUP 4 ;
542
                         CAR ;
543
                         GET 6 ;
544
                         DUP 4 ;
545
                         CAR ;
546
                         GET ;
547
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
548
                         GET 8 ;
549
                         DUP 4 ;
550
                         CDR ;
551
                         MUL ;
552
                         ADD ;
553
                         AMOUNT ;
554
                         COMPARE ;
555
                         EQ ;
556
                         IF {} { PUSH string "INCORRECT_AMOUNT_SENT" ; FAILWITH } ;
557
                         PUSH mutez 0 ;
558
                         DUP 2 ;
559
                         DUP 5 ;
560
                         CAR ;
561
                         GET 6 ;
562
                         DUP 5 ;
563
                         CAR ;
564
                         GET ;
565
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
566
                         GET 8 ;
567
                         DUP 5 ;
568
                         CDR ;
569
                         MUL ;
570
                         ADD ;
571
                         COMPARE ;
572
                         GT ;
573
                         IF
574
                           { DUP 3 ;
575
                             CAR ;
576
                             GET 6 ;
577
                             DUP 3 ;
578
                             CAR ;
579
                             GET ;
580
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
581
                             GET 3 ;
582
                             CAR ;
583
                             IF_NONE
584
                               { NIL operation }
585
                               { DROP ;
586
                                 NIL operation ;
587
                                 DUP 4 ;
588
                                 CAR ;
589
                                 GET 6 ;
590
                                 DUP 4 ;
591
                                 CAR ;
592
                                 GET ;
593
                                 IF_NONE { PUSH int 255 ; FAILWITH } {} ;
594
                                 GET 3 ;
595
                                 CAR ;
596
                                 IF_NONE { PUSH int 288 ; FAILWITH } {} ;
597
                                 ITER { PUSH mutez 0 ;
598
                                        DUP 2 ;
599
                                        CDR ;
600
                                        DUP 6 ;
601
                                        CDR ;
602
                                        MUL ;
603
                                        COMPARE ;
604
                                        GT ;
605
                                        IF
606
                                          { SWAP ;
607
                                            DUP 2 ;
608
                                            CAR ;
609
                                            CONTRACT unit ;
610
                                            IF_NONE { PUSH int 308 ; FAILWITH } {} ;
611
                                            DIG 2 ;
612
                                            CDR ;
613
                                            DUP 5 ;
614
                                            CDR ;
615
                                            MUL ;
616
                                            UNIT ;
617
                                            TRANSFER_TOKENS ;
618
                                            CONS }
619
                                          { DROP } } } ;
620
                             DUP 4 ;
621
                             CAR ;
622
                             GET 6 ;
623
                             DUP 4 ;
624
                             CAR ;
625
                             GET ;
626
                             IF_NONE { PUSH int 255 ; FAILWITH } {} ;
627
                             CAR ;
628
                             GET 6 ;
629
                             ITER { PUSH mutez 0 ;
630
                                    PUSH nat 10000 ;
631
                                    DUP 3 ;
632
                                    CDR ;
633
                                    DUP 8 ;
634
                                    CAR ;
635
                                    GET 6 ;
636
                                    DUP 8 ;
637
                                    CAR ;
638
                                    GET ;
639
                                    IF_NONE { PUSH int 255 ; FAILWITH } {} ;
640
                                    GET 8 ;
641
                                    DUP 8 ;
642
                                    CDR ;
643
                                    MUL ;
644
                                    MUL ;
645
                                    EDIV ;
646
                                    IF_NONE { PUSH int 312 ; FAILWITH } {} ;
647
                                    CAR ;
648
                                    COMPARE ;
649
                                    GT ;
650
                                    IF
651
                                      { SWAP ;
652
                                        DUP 2 ;
653
                                        CAR ;
654
                                        CONTRACT unit ;
655
                                        IF_NONE { PUSH int 314 ; FAILWITH } {} ;
656
                                        PUSH nat 10000 ;
657
                                        DIG 3 ;
658
                                        CDR ;
659
                                        DUP 7 ;
660
                                        CAR ;
661
                                        GET 6 ;
662
                                        DUP 7 ;
663
                                        CAR ;
664
                                        GET ;
665
                                        IF_NONE { PUSH int 255 ; FAILWITH } {} ;
666
                                        GET 8 ;
667
                                        DUP 7 ;
668
                                        CDR ;
669
                                        MUL ;
670
                                        MUL ;
671
                                        EDIV ;
672
                                        IF_NONE { PUSH int 312 ; FAILWITH } {} ;
673
                                        CAR ;
674
                                        UNIT ;
675
                                        TRANSFER_TOKENS ;
676
                                        CONS }
677
                                      { DROP } } ;
678
                             SWAP ;
679
                             DROP }
680
                           { DROP ; NIL operation } ;
681
                         DUP 3 ;
682
                         UNPAIR ;
683
                         UNPAIR ;
684
                         SWAP ;
685
                         UNPAIR ;
686
                         UNPAIR ;
687
                         SWAP ;
688
                         DUP 7 ;
689
                         CDR ;
690
                         DUP 9 ;
691
                         CAR ;
692
                         GET 3 ;
693
                         CDR ;
694
                         DUP 10 ;
695
                         CAR ;
696
                         GET 6 ;
697
                         DUP 10 ;
698
                         CAR ;
699
                         GET ;
700
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
701
                         GET 7 ;
702
                         SENDER ;
703
                         PAIR ;
704
                         GET ;
705
                         IF_NONE { PUSH nat 0 } {} ;
706
                         ADD ;
707
                         SOME ;
708
                         DIG 8 ;
709
                         CAR ;
710
                         GET 6 ;
711
                         DUP 9 ;
712
                         CAR ;
713
                         GET ;
714
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
715
                         GET 7 ;
716
                         SENDER ;
717
                         PAIR ;
718
                         UPDATE ;
719
                         SWAP ;
720
                         PAIR ;
721
                         PAIR ;
722
                         SWAP ;
723
                         PAIR ;
724
                         PAIR ;
725
                         DUG 2 ;
726
                         DUP 3 ;
727
                         UNPAIR ;
728
                         SWAP ;
729
                         UNPAIR ;
730
                         SWAP ;
731
                         UNPAIR ;
732
                         UNPAIR ;
733
                         SWAP ;
734
                         DUP 7 ;
735
                         CDR ;
736
                         DUP 9 ;
737
                         GET 5 ;
738
                         CDR ;
739
                         DUP 10 ;
740
                         CAR ;
741
                         GET 6 ;
742
                         DUP 10 ;
743
                         CAR ;
744
                         GET ;
745
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
746
                         GET 7 ;
747
                         GET ;
748
                         IF_NONE { PUSH nat 0 } {} ;
749
                         ADD ;
750
                         SOME ;
751
                         DIG 8 ;
752
                         CAR ;
753
                         GET 6 ;
754
                         DUP 9 ;
755
                         CAR ;
756
                         GET ;
757
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
758
                         GET 7 ;
759
                         UPDATE ;
760
                         SWAP ;
761
                         PAIR ;
762
                         PAIR ;
763
                         SWAP ;
764
                         PAIR ;
765
                         SWAP ;
766
                         PAIR ;
767
                         DUG 2 ;
768
                         DUP 3 ;
769
                         UNPAIR ;
770
                         SWAP ;
771
                         UNPAIR ;
772
                         UNPAIR ;
773
                         SWAP ;
774
                         UNPAIR ;
775
                         DUP 7 ;
776
                         CDR ;
777
                         DIG 8 ;
778
                         GET 3 ;
779
                         GET 3 ;
780
                         DUP 9 ;
781
                         CAR ;
782
                         GET ;
783
                         IF_NONE { PUSH nat 0 } {} ;
784
                         ADD ;
785
                         SOME ;
786
                         DUP 8 ;
787
                         CAR ;
788
                         UPDATE ;
789
                         PAIR ;
790
                         SWAP ;
791
                         PAIR ;
792
                         PAIR ;
793
                         SWAP ;
794
                         PAIR ;
795
                         DUG 2 ;
796
                         DUP 3 ;
797
                         CAR ;
798
                         GET 6 ;
799
                         DUP 3 ;
800
                         CAR ;
801
                         GET ;
802
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
803
                         GET 5 ;
804
                         DUP 4 ;
805
                         GET 3 ;
806
                         GET 3 ;
807
                         DUP 4 ;
808
                         CAR ;
809
                         GET ;
810
                         IF_NONE { PUSH int 327 ; FAILWITH } {} ;
811
                         COMPARE ;
812
                         EQ ;
813
                         IF
814
                           { DIG 2 ;
815
                             UNPAIR ;
816
                             UNPAIR ;
817
                             SWAP ;
818
                             UNPAIR ;
819
                             SWAP ;
820
                             UNPAIR ;
821
                             SWAP ;
822
                             DUP ;
823
                             DUP 8 ;
824
                             CAR ;
825
                             DUP ;
826
                             DUG 2 ;
827
                             GET ;
828
                             IF_NONE { PUSH int 328 ; FAILWITH } {} ;
829
                             UNPAIR ;
830
                             UNPAIR ;
831
                             CDR ;
832
                             PUSH bool False ;
833
                             PAIR ;
834
                             PAIR ;
835
                             PAIR ;
836
                             SOME ;
837
                             SWAP ;
838
                             UPDATE ;
839
                             SWAP ;
840
                             PAIR ;
841
                             SWAP ;
842
                             PAIR ;
843
                             SWAP ;
844
                             PAIR ;
845
                             PAIR ;
846
                             DUG 2 }
847
                           {} ;
848
                         AMOUNT ;
849
                         DUP 4 ;
850
                         CAR ;
851
                         GET 6 ;
852
                         DUP 4 ;
853
                         CAR ;
854
                         GET ;
855
                         IF_NONE { PUSH int 255 ; FAILWITH } {} ;
856
                         GET 7 ;
857
                         PAIR ;
858
                         SENDER ;
859
                         DIG 3 ;
860
                         CDR ;
861
                         PAIR ;
862
                         PAIR ;
863
                         EMIT %collect (pair (pair (nat %amount) (address %collector))
864
                                             (pair (nat %token_id) (mutez %total_paid))) ;
865
                         CONS }
866
                       { DUP 2 ;
867
                         CAR ;
868
                         GET 5 ;
869
                         IF { PUSH string "LISTINGS_PAUSED" ; FAILWITH } {} ;
870
                         PUSH mutez 0 ;
871
                         AMOUNT ;
872
                         COMPARE ;
873
                         EQ ;
874
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
875
                         DUP 2 ;
876
                         CAR ;
877
                         CAR ;
878
                         CAR ;
879
                         CDR ;
880
                         SENDER ;
881
                         COMPARE ;
882
                         EQ ;
883
                         IF
884
                           { PUSH bool True }
885
                           { DUP 2 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
886
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
887
                         DUP 2 ;
888
                         CAR ;
889
                         GET 6 ;
890
                         DUP 2 ;
891
                         CAR ;
892
                         MEM ;
893
                         IF { PUSH string "LISTING_ALREADY_EXISTS" ; FAILWITH } {} ;
894
                         PUSH nat 0 ;
895
                         DUP 2 ;
896
                         GET 7 ;
897
                         COMPARE ;
898
                         GT ;
899
                         IF {} { PUSH string "LIST_AT_LEAST_1_EDITION" ; FAILWITH } ;
900
                         NOW ;
901
                         DUP 2 ;
902
                         GET 3 ;
903
                         COMPARE ;
904
                         GE ;
905
                         IF {} { PUSH string "START_TIME_IN_PAST" ; FAILWITH } ;
906
                         DUP ;
907
                         GET 5 ;
908
                         IF_NONE
909
                           {}
910
                           { DROP ;
911
                             DUP ;
912
                             GET 3 ;
913
                             DUP 2 ;
914
                             GET 5 ;
915
                             IF_NONE { PUSH int 187 ; FAILWITH } {} ;
916
                             COMPARE ;
917
                             GT ;
918
                             IF
919
                               {}
920
                               { PUSH string "END_TIME_BEFORE_START_TIME" ; FAILWITH } } ;
921
                         PUSH nat 30 ;
922
                         DUP 2 ;
923
                         GET 13 ;
924
                         SIZE ;
925
                         COMPARE ;
926
                         LE ;
927
                         IF {} { PUSH string "TOO_MANY_SALE_SPLITS" ; FAILWITH } ;
928
                         PUSH nat 0 ;
929
                         EMPTY_SET address ;
930
                         DUP 3 ;
931
                         GET 13 ;
932
                         ITER { DUP 2 ;
933
                                DUP 2 ;
934
                                CAR ;
935
                                MEM ;
936
                                IF
937
                                  { PUSH string "DUPLICATE_SPLIT_ADDRESS" ; FAILWITH }
938
                                  {} ;
939
                                SWAP ;
940
                                PUSH bool True ;
941
                                DUP 3 ;
942
                                CAR ;
943
                                UPDATE ;
944
                                SWAP ;
945
                                DIG 2 ;
946
                                SWAP ;
947
                                CDR ;
948
                                ADD ;
949
                                SWAP } ;
950
                         PUSH nat 10000 ;
951
                         DUP 3 ;
952
                         COMPARE ;
953
                         EQ ;
954
                         IF {} { PUSH string "SALE_SPLIT_NOT_100" ; FAILWITH } ;
955
                         DUP 3 ;
956
                         GET 14 ;
957
                         IF_NONE
958
                           { DROP 2 }
959
                           { DROP ;
960
                             SWAP ;
961
                             DROP ;
962
                             PUSH nat 10 ;
963
                             DUP 3 ;
964
                             GET 14 ;
965
                             IF_NONE { PUSH int 210 ; FAILWITH } {} ;
966
                             SIZE ;
967
                             COMPARE ;
968
                             LE ;
969
                             IF
970
                               {}
971
                               { PUSH string "TOO_MANY_SPECIAL_SPLITS" ; FAILWITH } ;
972
                             DUP 2 ;
973
                             GET 14 ;
974
                             IF_NONE { PUSH int 210 ; FAILWITH } {} ;
975
                             ITER { DUP 2 ;
976
                                    DUP 2 ;
977
                                    CAR ;
978
                                    MEM ;
979
                                    IF
980
                                      { PUSH string "DUPLICATE_SPLIT_ADDRESS" ; FAILWITH }
981
                                      {} ;
982
                                    SWAP ;
983
                                    PUSH bool True ;
984
                                    DUP 3 ;
985
                                    CAR ;
986
                                    UPDATE ;
987
                                    SWAP ;
988
                                    CDR ;
989
                                    PUSH mutez 0 ;
990
                                    COMPARE ;
991
                                    LT ;
992
                                    IF
993
                                      {}
994
                                      { PUSH string "SOME_SPECIAL_SPLIT_IS_ZERO" ;
995
                                        FAILWITH } } ;
996
                             DROP } ;
997
                         SWAP ;
998
                         UNPAIR ;
999
                         UNPAIR ;
1000
                         SWAP ;
1001
                         UNPAIR ;
1002
                         SWAP ;
1003
                         UNPAIR ;
1004
                         SWAP ;
1005
                         DUP 6 ;
1006
                         GET 9 ;
1007
                         DUP 7 ;
1008
                         CAR ;
1009
                         PAIR ;
1010
                         DUP 7 ;
1011
                         GET 7 ;
1012
                         PAIR ;
1013
                         DUP 7 ;
1014
                         GET 3 ;
1015
                         DUP 8 ;
1016
                         GET 14 ;
1017
                         PAIR ;
1018
                         PAIR ;
1019
                         DUP 7 ;
1020
                         GET 13 ;
1021
                         DUP 8 ;
1022
                         GET 11 ;
1023
                         PAIR ;
1024
                         DUP 8 ;
1025
                         GET 5 ;
1026
                         PAIR ;
1027
                         SENDER ;
1028
                         PUSH bool True ;
1029
                         PAIR ;
1030
                         PAIR ;
1031
                         PAIR ;
1032
                         SOME ;
1033
                         DUP 7 ;
1034
                         CAR ;
1035
                         UPDATE ;
1036
                         SWAP ;
1037
                         PAIR ;
1038
                         SWAP ;
1039
                         PAIR ;
1040
                         SWAP ;
1041
                         PAIR ;
1042
                         PAIR ;
1043
                         SWAP ;
1044
                         NIL operation ;
1045
                         SWAP ;
1046
                         SENDER ;
1047
                         PAIR ;
1048
                         EMIT %create_listing (pair (address %creator)
1049
                                                    (pair %listing (nat %token_id)
1050
                                                                   (pair
1051
                                                                     (timestamp %start_time)
1052
                                                                     (pair
1053
                                                                       (option %end_time timestamp)
1054
                                                                       (pair
1055
                                                                         (nat %token_edition_size)
1056
                                                                         (pair
1057
                                                                           (mutez %token_price)
1058
                                                                           (pair
1059
                                                                             (nat %max_editions_per_wallet)
1060
                                                                             (pair
1061
                                                                               (list %sale_split (pair
1062
                                                                                                  (address %address)
1063
                                                                                                  (nat %royalties)))
1064
                                                                               (option %special_split (list (pair
1065
                                                                                                            (address %address)
1066
                                                                                                            (mutez %amount)))))))))))) ;
1067
                         CONS } }
1068
                   { IF_LEFT
1069
                       { PUSH mutez 0 ;
1070
                         AMOUNT ;
1071
                         COMPARE ;
1072
                         EQ ;
1073
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1074
                         DUP 2 ;
1075
                         GET 3 ;
1076
                         CAR ;
1077
                         CDR ;
1078
                         IF { PUSH string "MINT_PAUSED" ; FAILWITH } {} ;
1079
                         DUP 2 ;
1080
                         CAR ;
1081
                         CAR ;
1082
                         CAR ;
1083
                         CDR ;
1084
                         SENDER ;
1085
                         COMPARE ;
1086
                         EQ ;
1087
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1088
                         PUSH nat 20 ;
1089
                         DUP 2 ;
1090
                         SIZE ;
1091
                         COMPARE ;
1092
                         LE ;
1093
                         IF {} { PUSH string "TOO_MANY_TOKENS_IN_BATCH" ; FAILWITH } ;
1094
                         NIL operation ;
1095
                         DUP 2 ;
1096
                         ITER { PUSH nat 40 ;
1097
                                DUP 2 ;
1098
                                CDR ;
1099
                                SIZE ;
1100
                                COMPARE ;
1101
                                LE ;
1102
                                IF
1103
                                  {}
1104
                                  { PUSH string "TOO_MANY_ROYALTY_RECIPIENTS" ; FAILWITH } ;
1105
                                PUSH nat 0 ;
1106
                                EMPTY_SET address ;
1107
                                DUP 3 ;
1108
                                CDR ;
1109
                                ITER { DUP 2 ;
1110
                                       DUP 2 ;
1111
                                       CAR ;
1112
                                       MEM ;
1113
                                       IF
1114
                                         { PUSH string "DUPLICATE_SPLIT_ADDRESS" ;
1115
                                           FAILWITH }
1116
                                         {} ;
1117
                                       SWAP ;
1118
                                       PUSH bool True ;
1119
                                       DUP 3 ;
1120
                                       CAR ;
1121
                                       UPDATE ;
1122
                                       SWAP ;
1123
                                       DIG 2 ;
1124
                                       SWAP ;
1125
                                       CDR ;
1126
                                       ADD ;
1127
                                       SWAP } ;
1128
                                DROP ;
1129
                                PUSH nat 10000 ;
1130
                                SWAP ;
1131
                                COMPARE ;
1132
                                LE ;
1133
                                IF
1134
                                  {}
1135
                                  { PUSH string "ROYALTIES_EXCEED_MAX_PERCENTAGE" ;
1136
                                    FAILWITH } ;
1137
                                DUP 4 ;
1138
                                CAR ;
1139
                                GET 3 ;
1140
                                CAR ;
1141
                                DIG 4 ;
1142
                                DUP ;
1143
                                GET 9 ;
1144
                                DUP 4 ;
1145
                                CAR ;
1146
                                DUP 4 ;
1147
                                PAIR ;
1148
                                SOME ;
1149
                                DUP 4 ;
1150
                                UPDATE ;
1151
                                UPDATE 9 ;
1152
                                UNPAIR ;
1153
                                SWAP ;
1154
                                UNPAIR ;
1155
                                SWAP ;
1156
                                UNPAIR ;
1157
                                UNPAIR ;
1158
                                SWAP ;
1159
                                PUSH (option nat) (Some 0) ;
1160
                                DUP 7 ;
1161
                                UPDATE ;
1162
                                SWAP ;
1163
                                PAIR ;
1164
                                PAIR ;
1165
                                SWAP ;
1166
                                PAIR ;
1167
                                SWAP ;
1168
                                PAIR ;
1169
                                DUP ;
1170
                                GET 10 ;
1171
                                DUP 4 ;
1172
                                CDR ;
1173
                                SOME ;
1174
                                DIG 3 ;
1175
                                UPDATE ;
1176
                                UPDATE 10 ;
1177
                                UNPAIR ;
1178
                                UNPAIR ;
1179
                                SWAP ;
1180
                                UNPAIR ;
1181
                                UNPAIR ;
1182
                                PUSH nat 1 ;
1183
                                ADD ;
1184
                                PAIR ;
1185
                                PAIR ;
1186
                                SWAP ;
1187
                                PAIR ;
1188
                                PAIR ;
1189
                                DUG 3 ;
1190
                                SENDER ;
1191
                                PAIR ;
1192
                                EMIT %create_token (pair (address %creator)
1193
                                                         (pair %tokens
1194
                                                           (map %metadata string bytes)
1195
                                                           (list %royalties (pair
1196
                                                                             (address %address)
1197
                                                                             (nat %royalties))))) ;
1198
                                CONS } ;
1199
                         SWAP ;
1200
                         DROP }
1201
                       { IF_LEFT
1202
                           { PUSH mutez 0 ;
1203
                             AMOUNT ;
1204
                             COMPARE ;
1205
                             EQ ;
1206
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1207
                             NIL operation ;
1208
                             DUP 2 ;
1209
                             ITER { DUP 4 ;
1210
                                    GET 9 ;
1211
                                    DUP 2 ;
1212
                                    CAR ;
1213
                                    MEM ;
1214
                                    IF
1215
                                      {}
1216
                                      { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1217
                                    DUP 4 ;
1218
                                    CAR ;
1219
                                    CAR ;
1220
                                    CAR ;
1221
                                    CDR ;
1222
                                    SENDER ;
1223
                                    COMPARE ;
1224
                                    EQ ;
1225
                                    IF
1226
                                      { PUSH bool True }
1227
                                      { DUP 4 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
1228
                                    IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1229
                                    DUP ;
1230
                                    CDR ;
1231
                                    ITER { DUP 5 ;
1232
                                           UNPAIR ;
1233
                                           UNPAIR ;
1234
                                           SWAP ;
1235
                                           UNPAIR ;
1236
                                           UNPAIR ;
1237
                                           SWAP ;
1238
                                           DUP 6 ;
1239
                                           CDR ;
1240
                                           DIG 10 ;
1241
                                           CAR ;
1242
                                           GET 3 ;
1243
                                           CDR ;
1244
                                           DUP 9 ;
1245
                                           CAR ;
1246
                                           DUP 9 ;
1247
                                           CAR ;
1248
                                           PAIR ;
1249
                                           GET ;
1250
                                           IF_NONE { PUSH nat 0 } {} ;
1251
                                           ADD ;
1252
                                           SOME ;
1253
                                           DUP 8 ;
1254
                                           CAR ;
1255
                                           DUP 8 ;
1256
                                           CAR ;
1257
                                           PAIR ;
1258
                                           UPDATE ;
1259
                                           SWAP ;
1260
                                           PAIR ;
1261
                                           PAIR ;
1262
                                           SWAP ;
1263
                                           PAIR ;
1264
                                           PAIR ;
1265
                                           DUG 4 ;
1266
                                           DUP 5 ;
1267
                                           UNPAIR ;
1268
                                           SWAP ;
1269
                                           UNPAIR ;
1270
                                           SWAP ;
1271
                                           UNPAIR ;
1272
                                           UNPAIR ;
1273
                                           SWAP ;
1274
                                           DUP 6 ;
1275
                                           CDR ;
1276
                                           DIG 10 ;
1277
                                           GET 5 ;
1278
                                           CDR ;
1279
                                           DUP 9 ;
1280
                                           CAR ;
1281
                                           GET ;
1282
                                           IF_NONE { PUSH nat 0 } {} ;
1283
                                           ADD ;
1284
                                           SOME ;
1285
                                           DUP 8 ;
1286
                                           CAR ;
1287
                                           UPDATE ;
1288
                                           SWAP ;
1289
                                           PAIR ;
1290
                                           PAIR ;
1291
                                           SWAP ;
1292
                                           PAIR ;
1293
                                           SWAP ;
1294
                                           PAIR ;
1295
                                           DUG 4 ;
1296
                                           DIG 2 ;
1297
                                           DUP 3 ;
1298
                                           CAR ;
1299
                                           DUP 3 ;
1300
                                           CAR ;
1301
                                           PAIR ;
1302
                                           SENDER ;
1303
                                           DIG 3 ;
1304
                                           CDR ;
1305
                                           PAIR ;
1306
                                           PAIR ;
1307
                                           EMIT %mint (pair
1308
                                                        (pair (nat %amount)
1309
                                                              (address %minter))
1310
                                                        (pair (address %recipient)
1311
                                                              (nat %token_id))) ;
1312
                                           CONS ;
1313
                                           SWAP } ;
1314
                                    DROP } ;
1315
                             SWAP ;
1316
                             DROP }
1317
                           { PUSH mutez 0 ;
1318
                             AMOUNT ;
1319
                             COMPARE ;
1320
                             EQ ;
1321
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1322
                             DUP 2 ;
1323
                             CAR ;
1324
                             CAR ;
1325
                             CAR ;
1326
                             CDR ;
1327
                             SENDER ;
1328
                             COMPARE ;
1329
                             EQ ;
1330
                             IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1331
                             SWAP ;
1332
                             UNPAIR ;
1333
                             SWAP ;
1334
                             UNPAIR ;
1335
                             SWAP ;
1336
                             UNPAIR ;
1337
                             CDR ;
1338
                             DUP 5 ;
1339
                             SOME ;
1340
                             PAIR ;
1341
                             PAIR ;
1342
                             SWAP ;
1343
                             PAIR ;
1344
                             SWAP ;
1345
                             PAIR ;
1346
                             SWAP ;
1347
                             NIL operation ;
1348
                             SWAP ;
1349
                             DUP 3 ;
1350
                             CAR ;
1351
                             CAR ;
1352
                             CAR ;
1353
                             CDR ;
1354
                             PAIR ;
1355
                             EMIT %admin_proposed (pair (address %current_admin)
1356
                                                        (address %proposed_admin)) ;
1357
                             CONS } } } } }
1358
           { IF_LEFT
1359
               { IF_LEFT
1360
                   { IF_LEFT
1361
                       { PUSH mutez 0 ;
1362
                         AMOUNT ;
1363
                         COMPARE ;
1364
                         EQ ;
1365
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1366
                         DUP 2 ;
1367
                         CAR ;
1368
                         CAR ;
1369
                         CAR ;
1370
                         CDR ;
1371
                         SENDER ;
1372
                         COMPARE ;
1373
                         EQ ;
1374
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1375
                         DUP ;
1376
                         ITER { DIG 2 ;
1377
                                UNPAIR ;
1378
                                SWAP ;
1379
                                UNPAIR ;
1380
                                UNPAIR ;
1381
                                UNPAIR ;
1382
                                DUP 6 ;
1383
                                CDR ;
1384
                                SOME ;
1385
                                DIG 6 ;
1386
                                CAR ;
1387
                                UPDATE ;
1388
                                PAIR ;
1389
                                PAIR ;
1390
                                PAIR ;
1391
                                SWAP ;
1392
                                PAIR ;
1393
                                SWAP } ;
1394
                         DROP ;
1395
                         NIL operation ;
1396
                         SENDER ;
1397
                         EMIT %metadata_updated address ;
1398
                         CONS }
1399
                       { DUP 2 ;
1400
                         CAR ;
1401
                         CAR ;
1402
                         CAR ;
1403
                         CDR ;
1404
                         SENDER ;
1405
                         COMPARE ;
1406
                         EQ ;
1407
                         IF
1408
                           { PUSH bool True }
1409
                           { DUP 2 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
1410
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1411
                         PUSH mutez 0 ;
1412
                         AMOUNT ;
1413
                         COMPARE ;
1414
                         EQ ;
1415
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1416
                         DUP ;
1417
                         CAR ;
1418
                         IF_NONE
1419
                           {}
1420
                           { DROP ;
1421
                             SWAP ;
1422
                             UNPAIR ;
1423
                             SWAP ;
1424
                             UNPAIR ;
1425
                             UNPAIR ;
1426
                             CAR ;
1427
                             DUP 5 ;
1428
                             CAR ;
1429
                             IF_NONE { PUSH int 439 ; FAILWITH } {} ;
1430
                             SWAP ;
1431
                             PAIR ;
1432
                             PAIR ;
1433
                             PAIR ;
1434
                             SWAP ;
1435
                             PAIR ;
1436
                             SWAP } ;
1437
                         DUP ;
1438
                         GET 3 ;
1439
                         IF_NONE
1440
                           {}
1441
                           { DROP ;
1442
                             SWAP ;
1443
                             UNPAIR ;
1444
                             UNPAIR ;
1445
                             SWAP ;
1446
                             UNPAIR ;
1447
                             SWAP ;
1448
                             CDR ;
1449
                             DUP 5 ;
1450
                             GET 3 ;
1451
                             IF_NONE { PUSH int 443 ; FAILWITH } {} ;
1452
                             PAIR ;
1453
                             SWAP ;
1454
                             PAIR ;
1455
                             SWAP ;
1456
                             PAIR ;
1457
                             PAIR ;
1458
                             SWAP } ;
1459
                         DUP ;
1460
                         GET 4 ;
1461
                         IF_NONE
1462
                           { DROP }
1463
                           { DROP ;
1464
                             SWAP ;
1465
                             UNPAIR ;
1466
                             UNPAIR ;
1467
                             UNPAIR ;
1468
                             SWAP ;
1469
                             CDR ;
1470
                             DIG 4 ;
1471
                             GET 4 ;
1472
                             IF_NONE { PUSH int 447 ; FAILWITH } {} ;
1473
                             PAIR ;
1474
                             SWAP ;
1475
                             PAIR ;
1476
                             PAIR ;
1477
                             PAIR } ;
1478
                         NIL operation } }
1479
                   { IF_LEFT
1480
                       { DUP ;
1481
                         ITER { DUP ;
1482
                                CDR ;
1483
                                ITER { DUP 4 ;
1484
                                       CAR ;
1485
                                       CAR ;
1486
                                       CAR ;
1487
                                       CAR ;
1488
                                       DUP 2 ;
1489
                                       GET 3 ;
1490
                                       DUP 3 ;
1491
                                       CAR ;
1492
                                       PAIR ;
1493
                                       MEM ;
1494
                                       IF
1495
                                         { PUSH string "RESTRICTED_TRANSFER" ; FAILWITH }
1496
                                         {} ;
1497
                                       DUP 4 ;
1498
                                       GET 7 ;
1499
                                       DUP 2 ;
1500
                                       GET 3 ;
1501
                                       DUP 3 ;
1502
                                       CAR ;
1503
                                       PAIR ;
1504
                                       MEM ;
1505
                                       IF
1506
                                         { DUP 4 ;
1507
                                           CAR ;
1508
                                           GET 6 ;
1509
                                           DUP 2 ;
1510
                                           GET 3 ;
1511
                                           GET ;
1512
                                           IF_NONE { PUSH int 509 ; FAILWITH } {} ;
1513
                                           CAR ;
1514
                                           CAR ;
1515
                                           CAR ;
1516
                                           IF
1517
                                             { PUSH string "SALE_ONGOING" ; FAILWITH }
1518
                                             {} }
1519
                                         {} ;
1520
                                       DUP 4 ;
1521
                                       GET 9 ;
1522
                                       DUP 2 ;
1523
                                       GET 3 ;
1524
                                       MEM ;
1525
                                       IF
1526
                                         {}
1527
                                         { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1528
                                       DUP 2 ;
1529
                                       CAR ;
1530
                                       SENDER ;
1531
                                       COMPARE ;
1532
                                       EQ ;
1533
                                       IF
1534
                                         { PUSH bool True }
1535
                                         { DUP 4 ;
1536
                                           GET 3 ;
1537
                                           GET 4 ;
1538
                                           DUP 2 ;
1539
                                           GET 3 ;
1540
                                           SENDER ;
1541
                                           DUP 5 ;
1542
                                           CAR ;
1543
                                           PAIR 3 ;
1544
                                           MEM } ;
1545
                                       IF
1546
                                         {}
1547
                                         { PUSH string "FA2_NOT_OPERATOR" ; FAILWITH } ;
1548
                                       PUSH nat 0 ;
1549
                                       DUP 2 ;
1550
                                       GET 4 ;
1551
                                       COMPARE ;
1552
                                       GT ;
1553
                                       IF
1554
                                         { DUP 4 ;
1555
                                           UNPAIR ;
1556
                                           UNPAIR ;
1557
                                           SWAP ;
1558
                                           UNPAIR ;
1559
                                           UNPAIR ;
1560
                                           SWAP ;
1561
                                           DUP 6 ;
1562
                                           GET 4 ;
1563
                                           DIG 9 ;
1564
                                           CAR ;
1565
                                           GET 3 ;
1566
                                           CDR ;
1567
                                           DUP 8 ;
1568
                                           GET 3 ;
1569
                                           DUP 10 ;
1570
                                           CAR ;
1571
                                           PAIR ;
1572
                                           GET ;
1573
                                           IF_NONE { PUSH nat 0 } {} ;
1574
                                           SUB ;
1575
                                           ISNAT ;
1576
                                           IF_NONE
1577
                                             { PUSH string "FA2_INSUFFICIENT_BALANCE" ;
1578
                                               FAILWITH }
1579
                                             {} ;
1580
                                           SOME ;
1581
                                           DUP 7 ;
1582
                                           GET 3 ;
1583
                                           DUP 9 ;
1584
                                           CAR ;
1585
                                           PAIR ;
1586
                                           UPDATE ;
1587
                                           SWAP ;
1588
                                           PAIR ;
1589
                                           PAIR ;
1590
                                           SWAP ;
1591
                                           PAIR ;
1592
                                           PAIR ;
1593
                                           DUG 3 ;
1594
                                           DUP 4 ;
1595
                                           UNPAIR ;
1596
                                           UNPAIR ;
1597
                                           SWAP ;
1598
                                           UNPAIR ;
1599
                                           UNPAIR ;
1600
                                           SWAP ;
1601
                                           DUP 6 ;
1602
                                           GET 4 ;
1603
                                           DIG 9 ;
1604
                                           CAR ;
1605
                                           GET 3 ;
1606
                                           CDR ;
1607
                                           DUP 8 ;
1608
                                           GET 3 ;
1609
                                           DUP 9 ;
1610
                                           CAR ;
1611
                                           PAIR ;
1612
                                           GET ;
1613
                                           IF_NONE { PUSH nat 0 } {} ;
1614
                                           ADD ;
1615
                                           SOME ;
1616
                                           DUP 7 ;
1617
                                           GET 3 ;
1618
                                           DIG 7 ;
1619
                                           CAR ;
1620
                                           PAIR ;
1621
                                           UPDATE ;
1622
                                           SWAP ;
1623
                                           PAIR ;
1624
                                           PAIR ;
1625
                                           SWAP ;
1626
                                           PAIR ;
1627
                                           PAIR ;
1628
                                           DUG 2 }
1629
                                         { DROP } } ;
1630
                                DROP } ;
1631
                         DROP }
1632
                       { DUP 2 ;
1633
                         CAR ;
1634
                         CAR ;
1635
                         CAR ;
1636
                         CDR ;
1637
                         SENDER ;
1638
                         COMPARE ;
1639
                         EQ ;
1640
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1641
                         DUP ;
1642
                         ITER { DUP ;
1643
                                CDR ;
1644
                                IF
1645
                                  { DIG 2 ;
1646
                                    UNPAIR ;
1647
                                    UNPAIR ;
1648
                                    UNPAIR ;
1649
                                    SWAP ;
1650
                                    UNPAIR ;
1651
                                    SWAP ;
1652
                                    PUSH (option unit) (Some Unit) ;
1653
                                    DIG 6 ;
1654
                                    CAR ;
1655
                                    UPDATE ;
1656
                                    SWAP ;
1657
                                    PAIR ;
1658
                                    SWAP ;
1659
                                    PAIR ;
1660
                                    PAIR ;
1661
                                    PAIR ;
1662
                                    SWAP }
1663
                                  { DIG 2 ;
1664
                                    UNPAIR ;
1665
                                    UNPAIR ;
1666
                                    UNPAIR ;
1667
                                    SWAP ;
1668
                                    UNPAIR ;
1669
                                    SWAP ;
1670
                                    NONE unit ;
1671
                                    DIG 6 ;
1672
                                    CAR ;
1673
                                    UPDATE ;
1674
                                    SWAP ;
1675
                                    PAIR ;
1676
                                    SWAP ;
1677
                                    PAIR ;
1678
                                    PAIR ;
1679
                                    PAIR ;
1680
                                    SWAP } } ;
1681
                         DROP } ;
1682
                     NIL operation } }
1683
               { IF_LEFT
1684
                   { IF_LEFT
1685
                       { DUP 2 ;
1686
                         CAR ;
1687
                         CAR ;
1688
                         CAR ;
1689
                         CDR ;
1690
                         SENDER ;
1691
                         COMPARE ;
1692
                         EQ ;
1693
                         IF
1694
                           { PUSH bool True }
1695
                           { DUP 2 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
1696
                         IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1697
                         DUP ;
1698
                         ITER { DUP ;
1699
                                GET 3 ;
1700
                                ITER { DUP 2 ;
1701
                                       GET 6 ;
1702
                                       IF
1703
                                         { DUP 2 ;
1704
                                           GET 5 ;
1705
                                           IF
1706
                                             { DIG 3 ;
1707
                                               DUP ;
1708
                                               GET 7 ;
1709
                                               NONE unit ;
1710
                                               DIG 3 ;
1711
                                               DUP 5 ;
1712
                                               CAR ;
1713
                                               PAIR ;
1714
                                               UPDATE ;
1715
                                               UPDATE 7 ;
1716
                                               DUG 2 }
1717
                                             { DIG 3 ;
1718
                                               DUP ;
1719
                                               GET 7 ;
1720
                                               PUSH (option unit) (Some Unit) ;
1721
                                               DIG 3 ;
1722
                                               DUP 5 ;
1723
                                               CAR ;
1724
                                               PAIR ;
1725
                                               UPDATE ;
1726
                                               UPDATE 7 ;
1727
                                               DUG 2 } }
1728
                                         { DUP 2 ;
1729
                                           GET 5 ;
1730
                                           IF
1731
                                             { DIG 3 ;
1732
                                               UNPAIR ;
1733
                                               UNPAIR ;
1734
                                               UNPAIR ;
1735
                                               UNPAIR ;
1736
                                               NONE unit ;
1737
                                               DIG 6 ;
1738
                                               DUP 8 ;
1739
                                               CAR ;
1740
                                               PAIR ;
1741
                                               UPDATE ;
1742
                                               PAIR ;
1743
                                               PAIR ;
1744
                                               PAIR ;
1745
                                               PAIR ;
1746
                                               DUG 2 }
1747
                                             { DIG 3 ;
1748
                                               UNPAIR ;
1749
                                               UNPAIR ;
1750
                                               UNPAIR ;
1751
                                               UNPAIR ;
1752
                                               PUSH (option unit) (Some Unit) ;
1753
                                               DIG 6 ;
1754
                                               DUP 8 ;
1755
                                               CAR ;
1756
                                               PAIR ;
1757
                                               UPDATE ;
1758
                                               PAIR ;
1759
                                               PAIR ;
1760
                                               PAIR ;
1761
                                               PAIR ;
1762
                                               DUG 2 } } } ;
1763
                                DROP } ;
1764
                         DROP }
1765
                       { DUP ;
1766
                         ITER { IF_LEFT
1767
                                  { SENDER ;
1768
                                    DUP 2 ;
1769
                                    CAR ;
1770
                                    COMPARE ;
1771
                                    EQ ;
1772
                                    IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
1773
                                    DUP 3 ;
1774
                                    CAR ;
1775
                                    CAR ;
1776
                                    CAR ;
1777
                                    CAR ;
1778
                                    DUP 2 ;
1779
                                    GET 4 ;
1780
                                    DUP 3 ;
1781
                                    GET 3 ;
1782
                                    PAIR ;
1783
                                    MEM ;
1784
                                    IF
1785
                                      { PUSH string "RESTRICTED_OPERATOR" ; FAILWITH }
1786
                                      {} ;
1787
                                    DUP 3 ;
1788
                                    GET 7 ;
1789
                                    DUP 2 ;
1790
                                    GET 4 ;
1791
                                    DUP 3 ;
1792
                                    GET 3 ;
1793
                                    PAIR ;
1794
                                    MEM ;
1795
                                    IF
1796
                                      { DUP 3 ;
1797
                                        CAR ;
1798
                                        GET 6 ;
1799
                                        DUP 2 ;
1800
                                        GET 4 ;
1801
                                        GET ;
1802
                                        IF_NONE { PUSH int 491 ; FAILWITH } {} ;
1803
                                        CAR ;
1804
                                        CAR ;
1805
                                        CAR ;
1806
                                        IF
1807
                                          { PUSH string "SALE_ONGOING" ; FAILWITH }
1808
                                          {} }
1809
                                      {} ;
1810
                                    DIG 2 ;
1811
                                    UNPAIR ;
1812
                                    SWAP ;
1813
                                    UNPAIR ;
1814
                                    UNPAIR ;
1815
                                    SWAP ;
1816
                                    UNPAIR ;
1817
                                    SWAP ;
1818
                                    PUSH (option unit) (Some Unit) ;
1819
                                    DIG 6 ;
1820
                                    UPDATE ;
1821
                                    SWAP ;
1822
                                    PAIR ;
1823
                                    SWAP ;
1824
                                    PAIR ;
1825
                                    PAIR ;
1826
                                    SWAP ;
1827
                                    PAIR ;
1828
                                    SWAP }
1829
                                  { SENDER ;
1830
                                    DUP 2 ;
1831
                                    CAR ;
1832
                                    COMPARE ;
1833
                                    EQ ;
1834
                                    IF {} { PUSH string "FA2_NOT_OWNER" ; FAILWITH } ;
1835
                                    DIG 2 ;
1836
                                    UNPAIR ;
1837
                                    SWAP ;
1838
                                    UNPAIR ;
1839
                                    UNPAIR ;
1840
                                    SWAP ;
1841
                                    UNPAIR ;
1842
                                    SWAP ;
1843
                                    NONE unit ;
1844
                                    DIG 6 ;
1845
                                    UPDATE ;
1846
                                    SWAP ;
1847
                                    PAIR ;
1848
                                    SWAP ;
1849
                                    PAIR ;
1850
                                    PAIR ;
1851
                                    SWAP ;
1852
                                    PAIR ;
1853
                                    SWAP } } ;
1854
                         DROP } ;
1855
                     NIL operation }
1856
                   { IF_LEFT
1857
                       { PUSH mutez 0 ;
1858
                         AMOUNT ;
1859
                         COMPARE ;
1860
                         EQ ;
1861
                         IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1862
                         DUP ;
1863
                         ITER { DUP 3 ;
1864
                                GET 9 ;
1865
                                DUP 2 ;
1866
                                CAR ;
1867
                                MEM ;
1868
                                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1869
                                DUP 3 ;
1870
                                CAR ;
1871
                                CAR ;
1872
                                CAR ;
1873
                                CDR ;
1874
                                SENDER ;
1875
                                COMPARE ;
1876
                                EQ ;
1877
                                IF
1878
                                  { PUSH bool True }
1879
                                  { DUP 3 ; CAR ; CAR ; GET 4 ; SENDER ; MEM } ;
1880
                                IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1881
                                DIG 2 ;
1882
                                DUP ;
1883
                                GET 9 ;
1884
                                DUP ;
1885
                                DUP 4 ;
1886
                                CAR ;
1887
                                DUP ;
1888
                                DUG 2 ;
1889
                                GET ;
1890
                                IF_NONE { PUSH int 416 ; FAILWITH } {} ;
1891
                                DIG 4 ;
1892
                                CDR ;
1893
                                UPDATE 2 ;
1894
                                SOME ;
1895
                                SWAP ;
1896
                                UPDATE ;
1897
                                UPDATE 9 ;
1898
                                SWAP } ;
1899
                         DROP ;
1900
                         NIL operation }
1901
                       { IF_LEFT
1902
                           { PUSH mutez 0 ;
1903
                             AMOUNT ;
1904
                             COMPARE ;
1905
                             EQ ;
1906
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1907
                             DUP 2 ;
1908
                             CAR ;
1909
                             CAR ;
1910
                             CAR ;
1911
                             CDR ;
1912
                             SENDER ;
1913
                             COMPARE ;
1914
                             EQ ;
1915
                             IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1916
                             NIL operation ;
1917
                             DUP 2 ;
1918
                             CAR ;
1919
                             CONTRACT unit ;
1920
                             IF_NONE { PUSH int 602 ; FAILWITH } {} ;
1921
                             DIG 2 ;
1922
                             CDR ;
1923
                             UNIT ;
1924
                             TRANSFER_TOKENS ;
1925
                             CONS }
1926
                           { PUSH mutez 0 ;
1927
                             AMOUNT ;
1928
                             COMPARE ;
1929
                             EQ ;
1930
                             IF {} { PUSH string "TEZ_TRANSFER" ; FAILWITH } ;
1931
                             DUP 2 ;
1932
                             CAR ;
1933
                             CAR ;
1934
                             CAR ;
1935
                             CDR ;
1936
                             SENDER ;
1937
                             COMPARE ;
1938
                             EQ ;
1939
                             IF {} { PUSH string "NOT_ADMIN" ; FAILWITH } ;
1940
                             PUSH nat 0 ;
1941
                             DUP 3 ;
1942
                             CAR ;
1943
                             GET 3 ;
1944
                             CDR ;
1945
                             DUP 3 ;
1946
                             CAR ;
1947
                             SELF_ADDRESS ;
1948
                             PAIR ;
1949
                             GET ;
1950
                             IF_NONE { PUSH nat 0 } {} ;
1951
                             COMPARE ;
1952
                             GT ;
1953
                             IF {} { PUSH string "FA2_TOKEN_NOT_FOUND" ; FAILWITH } ;
1954
                             NIL operation ;
1955
                             SELF_ADDRESS ;
1956
                             CONTRACT %transfer (list (pair (address %from_)
1957
                                                           (list %txs (pair
1958
                                                                       (address %to_)
1959
                                                                       (pair
1960
                                                                         (nat %token_id)
1961
                                                                         (nat %amount)))))) ;
1962
                             IF_NONE
1963
                               { PUSH string "TRANSFER_EP_MISSING" ; FAILWITH }
1964
                               {} ;
1965
                             PUSH mutez 0 ;
1966
                             NIL (pair address (list (pair address (pair nat nat)))) ;
1967
                             NIL (pair address (pair nat nat)) ;
1968
                             PUSH nat 1 ;
1969
                             DIG 6 ;
1970
                             UNPAIR ;
1971
                             SWAP ;
1972
                             PAIR 3 ;
1973
                             CONS ;
1974
                             SELF_ADDRESS ;
1975
                             PAIR ;
1976
                             CONS ;
1977
                             TRANSFER_TOKENS ;
1978
                             CONS } } } } } ;
1979
         NIL operation ;
1980
         SWAP ;
1981
         ITER { CONS } ;
1982
         PAIR } ;
1983
  view "get_balance_of" (list (pair (address %owner) (nat %token_id)))
1984
        (list (pair (pair %request (address %owner) (nat %token_id)) (nat %balance)))
1985
        { UNPAIR ;
1986
          DUP ;
1987
          MAP { DUP 3 ;
1988
                GET 9 ;
1989
                DUP 2 ;
1990
                CDR ;
1991
                MEM ;
1992
                IF {} { PUSH string "FA2_TOKEN_UNDEFINED" ; FAILWITH } ;
1993
                DUP 3 ;
1994
                CAR ;
1995
                GET 3 ;
1996
                CDR ;
1997
                DUP 2 ;
1998
                CDR ;
1999
                DUP 3 ;
2000
                CAR ;
2001
                PAIR ;
2002
                GET ;
2003
                IF_NONE { PUSH nat 0 } {} ;
2004
                SWAP ;
2005
                PAIR } ;
2006
          SWAP ;
2007
          DROP ;
2008
          SWAP ;
2009
          DROP } ;
2010
  view "token_royalties" nat (list (pair (address %address) (nat %royalties)))
2011
        { UNPAIR ; SWAP ; GET 10 ; SWAP ; GET ; IF_NONE { PUSH int 687 ; FAILWITH } {} } }