BCD

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