BCD

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