BCD

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