BCD

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