BCD

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