BCD

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