BCD

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