BCD

Tezos Contract Explorer
Search Networks Deploy
  • Home
  • /
  • Mainnet
  • /
  • USDt/tzBTC/XTZ Target MultiToken Pool
Delegatable
operations (301K)Storage Code Interact Tokens Fork Views Statistics Details
Latest
​x
801
1623
 
1
{ parameter (or
2
              (or
3
                (or
4
                  (or
5
                    (pair %add_liquidity (address %owner)
6
                                         (pair (nat %min_lqt_minted)
7
                                               (pair
8
                                                 (or %src_token (address %fa1)
9
                                                                (or
10
                                                                  (pair %fa2
11
                                                                    (address %contract)
12
                                                                    (nat %token_id))
13
                                                                  (unit %tez)))
14
                                                 (pair (nat %src_token_amount)
15
                                                       (pair
16
                                                         (map %other_tokens_max_deposited
17
                                                           (or (address %fa1)
18
                                                               (or
19
                                                                 (pair %fa2
20
                                                                   (address %contract)
21
                                                                   (nat %token_id))
22
                                                                 (unit %tez)))
23
                                                           nat)
24
                                                         (timestamp %deadline))))))
25
                    (pair %add_liquidity_internal
26
                      (pair %param (address %owner)
27
                                   (pair (nat %min_lqt_minted)
28
                                         (pair
29
                                           (or %src_token (address %fa1)
30
                                                          (or
31
                                                            (pair %fa2
32
                                                              (address %contract)
33
                                                              (nat %token_id))
34
                                                            (unit %tez)))
35
                                           (pair (nat %src_token_amount)
36
                                                 (pair
37
                                                   (map %other_tokens_max_deposited
38
                                                     (or (address %fa1)
39
                                                         (or
40
                                                           (pair %fa2
41
                                                             (address %contract)
42
                                                             (nat %token_id))
43
                                                           (unit %tez)))
44
                                                     nat)
45
                                                   (timestamp %deadline))))))
46
                      (address %sender)))
47
                  (or (unit %default)
48
                      (or (bool %enable) (address %propose_administrator))))
49
                (or
50
                  (or (address %remove_administrator)
51
                      (or
52
                        (pair %remove_liquidity (address %receiver)
53
                                                (pair (nat %lqt_burned)
54
                                                      (pair
55
                                                        (map %min_tokens_withdrawn
56
                                                          (or (address %fa1)
57
                                                              (or
58
                                                                (pair %fa2
59
                                                                  (address %contract)
60
                                                                  (nat %token_id))
61
                                                                (unit %tez)))
62
                                                          nat)
63
                                                        (timestamp %deadline))))
64
                        (pair %remove_liquidity_internal
65
                          (pair %param (address %receiver)
66
                                       (pair (nat %lqt_burned)
67
                                             (pair
68
                                               (map %min_tokens_withdrawn
69
                                                 (or (address %fa1)
70
                                                     (or
71
                                                       (pair %fa2 (address %contract)
72
                                                                  (nat %token_id))
73
                                                       (unit %tez)))
74
                                                 nat)
75
                                               (timestamp %deadline))))
76
                          (address %sender))))
77
                  (or (unit %request_own_balances)
78
                      (or (unit %set_administrator) (nat %set_amplitude)))))
79
              (or
80
                (or
81
                  (or (option %set_baker key_hash)
82
                      (address %set_baking_rewards_receiver))
83
                  (or (nat %set_fa1_balance)
84
                      (or
85
                        (list %set_fa2_balance (pair
86
                                                (pair %request (address %owner)
87
                                                               (nat %token_id))
88
                                                (nat %balance)))
89
                        (address %set_lqt_address))))
90
                (or
91
                  (or (pair %set_rewards_ratio (nat %numerator) (nat %denominator))
92
                      (or (address %set_rewards_receiver)
93
                          (pair %set_swap_fee (nat %numerator) (nat %denominator))))
94
                  (or (address %set_target_oracle)
95
                      (or
96
                        (pair %token_swap
97
                          (or %src_token (address %fa1)
98
                                         (or
99
                                           (pair %fa2 (address %contract)
100
                                                      (nat %token_id))
101
                                           (unit %tez)))
102
                          (pair
103
                            (or %dst_token (address %fa1)
104
                                           (or
105
                                             (pair %fa2 (address %contract)
106
                                                        (nat %token_id))
107
                                             (unit %tez)))
108
                            (pair (nat %amount_sold)
109
                                  (pair (nat %min_amount_bought)
110
                                        (pair (address %receiver) (timestamp %deadline))))))
111
                        (pair %token_swap_internal
112
                          (pair %param
113
                            (or %src_token (address %fa1)
114
                                           (or
115
                                             (pair %fa2 (address %contract)
116
                                                        (nat %token_id))
117
                                             (unit %tez)))
118
                            (pair
119
                              (or %dst_token (address %fa1)
120
                                             (or
121
                                               (pair %fa2 (address %contract)
122
                                                          (nat %token_id))
123
                                               (unit %tez)))
124
                              (pair (nat %amount_sold)
125
                                    (pair (nat %min_amount_bought)
126
                                          (pair (address %receiver)
127
                                                (timestamp %deadline))))))
128
                          (address %sender))))))) ;
129
  storage (pair
130
            (pair (pair (big_map %administrators address nat) (nat %amplitude))
131
                  (pair (address %baking_rewards_receiver)
132
                        (pair (bool %enabled) (address %lqt_address))))
133
            (pair
134
              (pair (nat %lqt_total)
135
                    (pair (pair %rewards_ratio (nat %numerator) (nat %denominator))
136
                          (address %rewards_receiver)))
137
              (pair (pair %swap_fee (nat %numerator) (nat %denominator))
138
                    (pair (address %target_oracle)
139
                          (map %tokens
140
                            (or (address %fa1)
141
                                (or (pair %fa2 (address %contract) (nat %token_id))
142
                                    (unit %tez)))
143
                            (pair (nat %funds) (nat %multiplier))))))) ;
144
  code { LAMBDA
145
           (pair
146
             (pair (or address (or (pair address nat) unit))
147
                   (pair address (pair address nat)))
148
             (pair (list operation)
149
                   (pair
150
                     (pair (pair (big_map address nat) nat)
151
                           (pair address (pair bool address)))
152
                     (pair (pair nat (pair (pair nat nat) address))
153
                           (pair (pair nat nat)
154
                                 (pair address
155
                                       (map (or address (or (pair address nat) unit))
156
                                            (pair nat nat))))))))
157
           (pair unit
158
                 (pair (list operation)
159
                       (pair
160
                         (pair (pair (big_map address nat) nat)
161
                               (pair address (pair bool address)))
162
                         (pair (pair nat (pair (pair nat nat) address))
163
                               (pair (pair nat nat)
164
                                     (pair address
165
                                           (map
166
                                             (or address (or (pair address nat) unit))
167
                                             (pair nat nat))))))))
168
           { UNPAIR 3 ;
169
             SWAP ;
170
             DUP 2 ;
171
             CAR ;
172
             IF_LEFT
173
               { PUSH nat 0 ;
174
                 DUP 4 ;
175
                 GET 6 ;
176
                 COMPARE ;
177
                 GT ;
178
                 IF
179
                   { CONTRACT %transfer (pair (address %from)
180
                                              (pair (address %to) (nat %value))) ;
181
                     IF_NONE { PUSH int 21 ; FAILWITH } {} ;
182
                     PUSH mutez 0 ;
183
                     DUP 4 ;
184
                     GET 6 ;
185
                     DUP 5 ;
186
                     GET 5 ;
187
                     DIG 5 ;
188
                     GET 3 ;
189
                     PAIR 3 ;
190
                     TRANSFER_TOKENS ;
191
                     CONS }
192
                   { DROP ; SWAP ; DROP } }
193
               { IF_LEFT
194
                   { PUSH nat 0 ;
195
                     DUP 4 ;
196
                     GET 6 ;
197
                     COMPARE ;
198
                     GT ;
199
                     IF
200
                       { SWAP ;
201
                         DUP 2 ;
202
                         CAR ;
203
                         CONTRACT %transfer (list (pair (address %from_)
204
                                                       (list %txs (pair (address %to_)
205
                                                                       (pair
206
                                                                         (nat %token_id)
207
                                                                         (nat %amount)))))) ;
208
                         IF_NONE { PUSH int 38 ; FAILWITH } {} ;
209
                         PUSH mutez 0 ;
210
                         NIL (pair address (list (pair address (pair nat nat)))) ;
211
                         NIL (pair address (pair nat nat)) ;
212
                         DUP 7 ;
213
                         GET 6 ;
214
                         DIG 6 ;
215
                         CDR ;
216
                         DUP 8 ;
217
                         GET 5 ;
218
                         PAIR 3 ;
219
                         CONS ;
220
                         DIG 5 ;
221
                         GET 3 ;
222
                         PAIR ;
223
                         CONS ;
224
                         TRANSFER_TOKENS ;
225
                         CONS }
226
                       { DROP ; SWAP ; DROP } }
227
                   { DROP ;
228
                     SELF_ADDRESS ;
229
                     DUP 3 ;
230
                     GET 3 ;
231
                     COMPARE ;
232
                     EQ ;
233
                     IF
234
                       { PUSH nat 0 ;
235
                         DUP 3 ;
236
                         GET 6 ;
237
                         COMPARE ;
238
                         GT ;
239
                         IF
240
                           { DUP 2 ;
241
                             GET 5 ;
242
                             CONTRACT unit ;
243
                             IF_NONE { PUSH int 188 ; FAILWITH } {} ;
244
                             PUSH mutez 1 ;
245
                             DIG 3 ;
246
                             GET 6 ;
247
                             MUL ;
248
                             UNIT ;
249
                             TRANSFER_TOKENS ;
250
                             CONS }
251
                           { SWAP ; DROP } }
252
                       { SWAP ; DROP } } } ;
253
             UNIT ;
254
             PAIR 3 } ;
255
         SWAP ;
256
         LAMBDA
257
           (pair (pair int address)
258
                 (pair (list operation)
259
                       (pair
260
                         (pair (pair (big_map address nat) nat)
261
                               (pair address (pair bool address)))
262
                         (pair (pair nat (pair (pair nat nat) address))
263
                               (pair (pair nat nat)
264
                                     (pair address
265
                                           (map
266
                                             (or address (or (pair address nat) unit))
267
                                             (pair nat nat))))))))
268
           (pair unit
269
                 (pair (list operation)
270
                       (pair
271
                         (pair (pair (big_map address nat) nat)
272
                               (pair address (pair bool address)))
273
                         (pair (pair nat (pair (pair nat nat) address))
274
                               (pair (pair nat nat)
275
                                     (pair address
276
                                           (map
277
                                             (or address (or (pair address nat) unit))
278
                                             (pair nat nat))))))))
279
           { UNPAIR 3 ;
280
             SWAP ;
281
             DUP 3 ;
282
             CAR ;
283
             GET 6 ;
284
             CONTRACT %mintOrBurn (pair (int %quantity) (address %target)) ;
285
             IF_NONE { PUSH string "InvalidEntrypoint: mintOrBurn" ; FAILWITH } {} ;
286
             PUSH mutez 0 ;
287
             DIG 3 ;
288
             TRANSFER_TOKENS ;
289
             CONS ;
290
             UNIT ;
291
             PAIR 3 } ;
292
         SWAP ;
293
         LAMBDA
294
           unit
295
           unit
296
           { DROP ; SELF_ADDRESS ; SENDER ; COMPARE ; EQ ; IF {} { PUSH int 400 ; FAILWITH } ; UNIT } ;
297
         SWAP ;
298
         LAMBDA
299
           (pair unit
300
                 (pair
301
                   (pair (pair (big_map address nat) nat)
302
                         (pair address (pair bool address)))
303
                   (pair (pair nat (pair (pair nat nat) address))
304
                         (pair (pair nat nat)
305
                               (pair address
306
                                     (map (or address (or (pair address nat) unit))
307
                                          (pair nat nat)))))))
308
           (pair unit
309
                 (pair
310
                   (pair (pair (big_map address nat) nat)
311
                         (pair address (pair bool address)))
312
                   (pair (pair nat (pair (pair nat nat) address))
313
                         (pair (pair nat nat)
314
                               (pair address
315
                                     (map (or address (or (pair address nat) unit))
316
                                          (pair nat nat)))))))
317
           { CDR ;
318
             PUSH nat 1 ;
319
             DUP 2 ;
320
             CAR ;
321
             CAR ;
322
             CAR ;
323
             SENDER ;
324
             GET ;
325
             IF_NONE { PUSH int 21 ; FAILWITH } {} ;
326
             COMPARE ;
327
             EQ ;
328
             IF {} { PUSH int 401 ; FAILWITH } ;
329
             UNIT ;
330
             PAIR } ;
331
         SWAP ;
332
         UNPAIR ;
333
         IF_LEFT
334
           { IF_LEFT
335
               { IF_LEFT
336
                   { IF_LEFT
337
                       { DUP ;
338
                         GET 9 ;
339
                         DUP 2 ;
340
                         GET 7 ;
341
                         SOME ;
342
                         DUP 3 ;
343
                         GET 5 ;
344
                         UPDATE ;
345
                         PUSH bool True ;
346
                         DUP 4 ;
347
                         CAR ;
348
                         GET 5 ;
349
                         COMPARE ;
350
                         EQ ;
351
                         IF {} { PUSH string "PoolDisabled" ; FAILWITH } ;
352
                         NOW ;
353
                         DUP 3 ;
354
                         GET 10 ;
355
                         COMPARE ;
356
                         GE ;
357
                         IF {} { PUSH string "DeadlinePassed" ; FAILWITH } ;
358
                         DUP 3 ;
359
                         GET 8 ;
360
                         SIZE ;
361
                         DUP 2 ;
362
                         SIZE ;
363
                         COMPARE ;
364
                         EQ ;
365
                         IF {} { PUSH string "InvalidNumberOfTokens" ; FAILWITH } ;
366
                         DUP ;
367
                         PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
368
                         MEM ;
369
                         IF
370
                           { PUSH mutez 1 ;
371
                             AMOUNT ;
372
                             EDIV ;
373
                             IF_NONE { UNIT ; FAILWITH } {} ;
374
                             CAR ;
375
                             DUP 2 ;
376
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
377
                             GET ;
378
                             IF_NONE { PUSH int 220 ; FAILWITH } {} ;
379
                             COMPARE ;
380
                             EQ ;
381
                             IF {} { PUSH string "InvalidTezAmountSent" ; FAILWITH } }
382
                           { PUSH mutez 0 ;
383
                             AMOUNT ;
384
                             COMPARE ;
385
                             EQ ;
386
                             IF {} { PUSH string "InvalidTezAmountSent" ; FAILWITH } } ;
387
                         PUSH mutez 1 ;
388
                         BALANCE ;
389
                         EDIV ;
390
                         IF_NONE { UNIT ; FAILWITH } {} ;
391
                         CAR ;
392
                         PUSH mutez 1 ;
393
                         AMOUNT ;
394
                         EDIV ;
395
                         IF_NONE { UNIT ; FAILWITH } {} ;
396
                         CAR ;
397
                         DUP ;
398
                         DUP 3 ;
399
                         SUB ;
400
                         ISNAT ;
401
                         IF_NONE { PUSH int 227 ; FAILWITH } {} ;
402
                         DUP 6 ;
403
                         GET 8 ;
404
                         PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
405
                         MEM ;
406
                         IF
407
                           { SWAP ;
408
                             DROP ;
409
                             SWAP ;
410
                             DROP ;
411
                             SWAP ;
412
                             DROP ;
413
                             DIG 3 ;
414
                             DROP ;
415
                             DIG 3 ;
416
                             DROP ;
417
                             DIG 3 ;
418
                             DROP ;
419
                             DIG 3 ;
420
                             DROP ;
421
                             DUP 3 ;
422
                             DUP ;
423
                             GET 8 ;
424
                             DIG 4 ;
425
                             GET 8 ;
426
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
427
                             GET ;
428
                             IF_NONE { PUSH int 229 ; FAILWITH } {} ;
429
                             CDR ;
430
                             DIG 3 ;
431
                             PAIR ;
432
                             SOME ;
433
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
434
                             UPDATE ;
435
                             UPDATE 8 ;
436
                             SWAP ;
437
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
438
                             DUP 2 ;
439
                             GET 5 ;
440
                             COMPARE ;
441
                             EQ ;
442
                             IF
443
                               {}
444
                               { PUSH string "TezMustBeTheSourceToken" ; FAILWITH } }
445
                           { DROP 4 ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } ;
446
                         NIL operation ;
447
                         SELF %request_own_balances ;
448
                         PUSH mutez 0 ;
449
                         UNIT ;
450
                         TRANSFER_TOKENS ;
451
                         CONS ;
452
                         SELF %add_liquidity_internal ;
453
                         PUSH mutez 0 ;
454
                         SENDER ;
455
                         DIG 4 ;
456
                         PAIR ;
457
                         TRANSFER_TOKENS ;
458
                         CONS }
459
                       { AMOUNT ;
460
                         PUSH mutez 0 ;
461
                         COMPARE ;
462
                         EQ ;
463
                         IF {} { AMOUNT ; FAILWITH } ;
464
                         DUP 4 ;
465
                         UNIT ;
466
                         EXEC ;
467
                         DUP 3 ;
468
                         GET 8 ;
469
                         DUP 3 ;
470
                         CAR ;
471
                         GET 5 ;
472
                         MEM ;
473
                         IF {} { PUSH string "UnknownToken" ; FAILWITH } ;
474
                         DUP 3 ;
475
                         GET 8 ;
476
                         DUP 3 ;
477
                         CAR ;
478
                         GET 5 ;
479
                         GET ;
480
                         IF_NONE { PUSH int 249 ; FAILWITH } {} ;
481
                         CAR ;
482
                         DUP 3 ;
483
                         CAR ;
484
                         GET 9 ;
485
                         DUP 4 ;
486
                         CAR ;
487
                         GET 7 ;
488
                         SOME ;
489
                         DUP 5 ;
490
                         CAR ;
491
                         GET 5 ;
492
                         UPDATE ;
493
                         NIL operation ;
494
                         DUP 2 ;
495
                         ITER { DUP 7 ;
496
                                GET 8 ;
497
                                DUP 2 ;
498
                                CAR ;
499
                                MEM ;
500
                                IF {} { PUSH string "UnknownToken" ; FAILWITH } ;
501
                                DUP 4 ;
502
                                DUP 8 ;
503
                                GET 8 ;
504
                                DUP 3 ;
505
                                CAR ;
506
                                GET ;
507
                                IF_NONE { PUSH int 259 ; FAILWITH } {} ;
508
                                CAR ;
509
                                DUP 8 ;
510
                                CAR ;
511
                                GET 7 ;
512
                                MUL ;
513
                                EDIV ;
514
                                IF_NONE { PUSH int 259 ; FAILWITH } { CAR } ;
515
                                DUP 2 ;
516
                                CDR ;
517
                                DUP 2 ;
518
                                COMPARE ;
519
                                LE ;
520
                                IF
521
                                  {}
522
                                  { PUSH string "CannotDepositMoreThanSetValue" ;
523
                                    FAILWITH } ;
524
                                DUP 8 ;
525
                                DUP ;
526
                                GET 8 ;
527
                                DUP 10 ;
528
                                GET 8 ;
529
                                DUP 5 ;
530
                                CAR ;
531
                                GET ;
532
                                IF_NONE { PUSH int 264 ; FAILWITH } {} ;
533
                                CDR ;
534
                                DUP 4 ;
535
                                DIG 11 ;
536
                                GET 8 ;
537
                                DUP 7 ;
538
                                CAR ;
539
                                GET ;
540
                                IF_NONE { PUSH int 263 ; FAILWITH } {} ;
541
                                CAR ;
542
                                ADD ;
543
                                PAIR ;
544
                                SOME ;
545
                                DUP 5 ;
546
                                CAR ;
547
                                UPDATE ;
548
                                UPDATE 8 ;
549
                                DUG 7 ;
550
                                DUP 12 ;
551
                                DUP 2 ;
552
                                SELF_ADDRESS ;
553
                                DUP 10 ;
554
                                CDR ;
555
                                DUP 6 ;
556
                                CAR ;
557
                                PAIR 4 ;
558
                                DIG 2 ;
559
                                DROP ;
560
                                DIG 2 ;
561
                                DROP ;
562
                                SWAP ;
563
                                DIG 7 ;
564
                                DIG 3 ;
565
                                DIG 3 ;
566
                                PAIR 3 ;
567
                                EXEC ;
568
                                CDR ;
569
                                UNPAIR ;
570
                                DIG 9 ;
571
                                DIG 9 ;
572
                                DIG 9 ;
573
                                DIG 9 ;
574
                                DIG 5 ;
575
                                DIG 9 ;
576
                                DIG 9 ;
577
                                DIG 9 ;
578
                                DIG 9 ;
579
                                DIG 9 } ;
580
                         SWAP ;
581
                         DROP ;
582
                         DIG 2 ;
583
                         DROP ;
584
                         DIG 4 ;
585
                         DROP ;
586
                         DIG 4 ;
587
                         DROP ;
588
                         DIG 5 ;
589
                         DROP ;
590
                         SWAP ;
591
                         DUP 4 ;
592
                         GET 3 ;
593
                         CAR ;
594
                         DUP 4 ;
595
                         CAR ;
596
                         GET 7 ;
597
                         MUL ;
598
                         EDIV ;
599
                         IF_NONE { PUSH int 276 ; FAILWITH } { CAR } ;
600
                         DUP 3 ;
601
                         CAR ;
602
                         GET 3 ;
603
                         DUP 2 ;
604
                         COMPARE ;
605
                         GE ;
606
                         IF {} { PUSH string "CannotMintEnoughLiquidity" ; FAILWITH } ;
607
                         DIG 3 ;
608
                         UNPAIR ;
609
                         SWAP ;
610
                         UNPAIR ;
611
                         UNPAIR ;
612
                         DUP 5 ;
613
                         ADD ;
614
                         PAIR ;
615
                         PAIR ;
616
                         SWAP ;
617
                         PAIR ;
618
                         DUG 3 ;
619
                         DIG 4 ;
620
                         DIG 3 ;
621
                         CAR ;
622
                         CAR ;
623
                         DIG 2 ;
624
                         INT ;
625
                         PAIR ;
626
                         SWAP ;
627
                         DUG 3 ;
628
                         PAIR 3 ;
629
                         EXEC ;
630
                         CDR ;
631
                         UNPAIR } }
632
                   { IF_LEFT
633
                       { DROP ;
634
                         SWAP ;
635
                         DROP ;
636
                         SWAP ;
637
                         DROP ;
638
                         SWAP ;
639
                         DROP ;
640
                         SWAP ;
641
                         DROP ;
642
                         SELF_ADDRESS ;
643
                         DUP 2 ;
644
                         CAR ;
645
                         GET 3 ;
646
                         COMPARE ;
647
                         NEQ ;
648
                         IF
649
                           { NIL operation ;
650
                             DUP 2 ;
651
                             CAR ;
652
                             GET 3 ;
653
                             CONTRACT unit ;
654
                             IF_NONE { PUSH int 204 ; FAILWITH } {} ;
655
                             AMOUNT ;
656
                             UNIT ;
657
                             TRANSFER_TOKENS ;
658
                             CONS }
659
                           { NIL operation } }
660
                       { IF_LEFT
661
                           { DIG 3 ;
662
                             DROP ;
663
                             DIG 3 ;
664
                             DROP ;
665
                             DIG 3 ;
666
                             DROP ;
667
                             AMOUNT ;
668
                             PUSH mutez 0 ;
669
                             COMPARE ;
670
                             EQ ;
671
                             IF {} { AMOUNT ; FAILWITH } ;
672
                             DIG 2 ;
673
                             UNIT ;
674
                             SWAP ;
675
                             DIG 3 ;
676
                             DIG 2 ;
677
                             PAIR ;
678
                             EXEC ;
679
                             CDR ;
680
                             UNPAIR ;
681
                             UNPAIR ;
682
                             SWAP ;
683
                             UNPAIR ;
684
                             SWAP ;
685
                             CDR ;
686
                             DIG 4 ;
687
                             PAIR ;
688
                             SWAP ;
689
                             PAIR ;
690
                             SWAP ;
691
                             PAIR ;
692
                             PAIR }
693
                           { DIG 3 ;
694
                             DROP ;
695
                             DIG 3 ;
696
                             DROP ;
697
                             DIG 3 ;
698
                             DROP ;
699
                             AMOUNT ;
700
                             PUSH mutez 0 ;
701
                             COMPARE ;
702
                             EQ ;
703
                             IF {} { AMOUNT ; FAILWITH } ;
704
                             DIG 2 ;
705
                             UNIT ;
706
                             SWAP ;
707
                             DIG 3 ;
708
                             DIG 2 ;
709
                             PAIR ;
710
                             EXEC ;
711
                             CDR ;
712
                             UNPAIR ;
713
                             UNPAIR ;
714
                             UNPAIR ;
715
                             PUSH (option nat) (Some 0) ;
716
                             DIG 5 ;
717
                             UPDATE ;
718
                             PAIR ;
719
                             PAIR ;
720
                             PAIR } ;
721
                         NIL operation } } }
722
               { IF_LEFT
723
                   { IF_LEFT
724
                       { DIG 3 ;
725
                         DROP ;
726
                         DIG 3 ;
727
                         DROP ;
728
                         DIG 3 ;
729
                         DROP ;
730
                         AMOUNT ;
731
                         PUSH mutez 0 ;
732
                         COMPARE ;
733
                         EQ ;
734
                         IF {} { AMOUNT ; FAILWITH } ;
735
                         DIG 2 ;
736
                         UNIT ;
737
                         SWAP ;
738
                         DIG 3 ;
739
                         DIG 2 ;
740
                         PAIR ;
741
                         EXEC ;
742
                         CDR ;
743
                         UNPAIR ;
744
                         UNPAIR ;
745
                         UNPAIR ;
746
                         NONE nat ;
747
                         DIG 5 ;
748
                         UPDATE ;
749
                         PAIR ;
750
                         PAIR ;
751
                         PAIR ;
752
                         NIL operation }
753
                       { IF_LEFT
754
                           { AMOUNT ;
755
                             PUSH mutez 0 ;
756
                             COMPARE ;
757
                             EQ ;
758
                             IF {} { AMOUNT ; FAILWITH } ;
759
                             PUSH bool True ;
760
                             DUP 3 ;
761
                             CAR ;
762
                             GET 5 ;
763
                             COMPARE ;
764
                             EQ ;
765
                             IF {} { PUSH string "PoolDisabled" ; FAILWITH } ;
766
                             NOW ;
767
                             DUP 2 ;
768
                             GET 6 ;
769
                             COMPARE ;
770
                             GE ;
771
                             IF {} { PUSH string "DeadlinePassed" ; FAILWITH } ;
772
                             DUP 2 ;
773
                             GET 8 ;
774
                             SIZE ;
775
                             DUP 2 ;
776
                             GET 5 ;
777
                             SIZE ;
778
                             COMPARE ;
779
                             EQ ;
780
                             IF {} { PUSH string "InvalidNumberOfTokens" ; FAILWITH } ;
781
                             PUSH mutez 1 ;
782
                             BALANCE ;
783
                             EDIV ;
784
                             IF_NONE { UNIT ; FAILWITH } {} ;
785
                             CAR ;
786
                             DUP 3 ;
787
                             GET 8 ;
788
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
789
                             MEM ;
790
                             IF
791
                               { DIG 3 ;
792
                                 DROP ;
793
                                 DIG 3 ;
794
                                 DROP ;
795
                                 DIG 3 ;
796
                                 DROP ;
797
                                 DIG 3 ;
798
                                 DROP ;
799
                                 DUP 3 ;
800
                                 DUP ;
801
                                 GET 8 ;
802
                                 DIG 4 ;
803
                                 GET 8 ;
804
                                 PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
805
                                 GET ;
806
                                 IF_NONE { PUSH int 298 ; FAILWITH } {} ;
807
                                 CDR ;
808
                                 DIG 3 ;
809
                                 PAIR ;
810
                                 SOME ;
811
                                 PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
812
                                 UPDATE ;
813
                                 UPDATE 8 ;
814
                                 SWAP }
815
                               { DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } ;
816
                             NIL operation ;
817
                             SELF %request_own_balances ;
818
                             PUSH mutez 0 ;
819
                             UNIT ;
820
                             TRANSFER_TOKENS ;
821
                             CONS ;
822
                             SELF %remove_liquidity_internal ;
823
                             PUSH mutez 0 ;
824
                             SENDER ;
825
                             DIG 4 ;
826
                             PAIR ;
827
                             TRANSFER_TOKENS ;
828
                             CONS }
829
                           { AMOUNT ;
830
                             PUSH mutez 0 ;
831
                             COMPARE ;
832
                             EQ ;
833
                             IF {} { AMOUNT ; FAILWITH } ;
834
                             DUP 4 ;
835
                             UNIT ;
836
                             EXEC ;
837
                             NIL operation ;
838
                             DUP 3 ;
839
                             CAR ;
840
                             GET 5 ;
841
                             ITER { DUP 5 ;
842
                                    GET 8 ;
843
                                    DUP 2 ;
844
                                    CAR ;
845
                                    MEM ;
846
                                    IF {} { PUSH string "UnknownToken" ; FAILWITH } ;
847
                                    DUP 5 ;
848
                                    GET 3 ;
849
                                    CAR ;
850
                                    DUP 6 ;
851
                                    GET 8 ;
852
                                    DUP 3 ;
853
                                    CAR ;
854
                                    GET ;
855
                                    IF_NONE { PUSH int 322 ; FAILWITH } {} ;
856
                                    CAR ;
857
                                    DUP 6 ;
858
                                    CAR ;
859
                                    GET 3 ;
860
                                    MUL ;
861
                                    EDIV ;
862
                                    IF_NONE { PUSH int 322 ; FAILWITH } { CAR } ;
863
                                    DUP 2 ;
864
                                    CDR ;
865
                                    DUP 2 ;
866
                                    COMPARE ;
867
                                    GE ;
868
                                    IF
869
                                      {}
870
                                      { PUSH string "CannotWithdrawLessThanSetValue" ;
871
                                        FAILWITH } ;
872
                                    DUP 6 ;
873
                                    DUP ;
874
                                    GET 8 ;
875
                                    DUP 8 ;
876
                                    GET 8 ;
877
                                    DUP 5 ;
878
                                    CAR ;
879
                                    GET ;
880
                                    IF_NONE { PUSH int 328 ; FAILWITH } {} ;
881
                                    CDR ;
882
                                    DUP 4 ;
883
                                    DIG 9 ;
884
                                    GET 8 ;
885
                                    DUP 7 ;
886
                                    CAR ;
887
                                    GET ;
888
                                    IF_NONE { PUSH int 327 ; FAILWITH } {} ;
889
                                    CAR ;
890
                                    SUB ;
891
                                    ISNAT ;
892
                                    IF_NONE
893
                                      { PUSH string "TooManyTokensWithdrawn" ; FAILWITH }
894
                                      {} ;
895
                                    PAIR ;
896
                                    SOME ;
897
                                    DUP 5 ;
898
                                    CAR ;
899
                                    UPDATE ;
900
                                    UPDATE 8 ;
901
                                    DUG 5 ;
902
                                    DUP 10 ;
903
                                    DUP 2 ;
904
                                    DUP 7 ;
905
                                    CAR ;
906
                                    CAR ;
907
                                    SELF_ADDRESS ;
908
                                    DUP 6 ;
909
                                    CAR ;
910
                                    PAIR 4 ;
911
                                    DIG 2 ;
912
                                    DROP ;
913
                                    DIG 2 ;
914
                                    DROP ;
915
                                    SWAP ;
916
                                    DIG 5 ;
917
                                    DIG 3 ;
918
                                    DIG 3 ;
919
                                    PAIR 3 ;
920
                                    EXEC ;
921
                                    CDR ;
922
                                    UNPAIR ;
923
                                    DIG 7 ;
924
                                    DIG 7 ;
925
                                    DIG 7 ;
926
                                    DIG 7 ;
927
                                    DIG 5 ;
928
                                    DIG 7 ;
929
                                    DIG 7 ;
930
                                    DIG 7 } ;
931
                             SWAP ;
932
                             DROP ;
933
                             DIG 3 ;
934
                             DROP ;
935
                             DIG 3 ;
936
                             DROP ;
937
                             DIG 4 ;
938
                             DROP ;
939
                             DUP 2 ;
940
                             CAR ;
941
                             GET 3 ;
942
                             DUP 4 ;
943
                             GET 3 ;
944
                             CAR ;
945
                             SUB ;
946
                             ISNAT ;
947
                             IF_NONE { PUSH string "TooMuchLqtBurned" ; FAILWITH } {} ;
948
                             DIG 3 ;
949
                             UNPAIR ;
950
                             SWAP ;
951
                             UNPAIR ;
952
                             CDR ;
953
                             DIG 3 ;
954
                             PAIR ;
955
                             PAIR ;
956
                             SWAP ;
957
                             PAIR ;
958
                             DUG 2 ;
959
                             DIG 3 ;
960
                             DIG 2 ;
961
                             DUP ;
962
                             CDR ;
963
                             SWAP ;
964
                             CAR ;
965
                             GET 3 ;
966
                             PUSH nat 0 ;
967
                             SUB ;
968
                             PAIR ;
969
                             SWAP ;
970
                             DUG 3 ;
971
                             PAIR 3 ;
972
                             EXEC ;
973
                             CDR ;
974
                             UNPAIR } } }
975
                   { IF_LEFT
976
                       { AMOUNT ;
977
                         PUSH mutez 0 ;
978
                         COMPARE ;
979
                         EQ ;
980
                         IF {} { AMOUNT ; FAILWITH } ;
981
                         SELF_ADDRESS ;
982
                         SENDER ;
983
                         COMPARE ;
984
                         EQ ;
985
                         IF { PUSH bool True } { SOURCE ; SENDER ; COMPARE ; EQ } ;
986
                         IF {} { PUSH string "SenderNotAllowed" ; FAILWITH } ;
987
                         NIL operation ;
988
                         DUP 3 ;
989
                         GET 8 ;
990
                         ITER { CAR ;
991
                                IF_LEFT
992
                                  { CONTRACT %getBalance (pair address (contract nat)) ;
993
                                    IF_NONE
994
                                      { PUSH string "InvalidEntrypoint: getBalance" ;
995
                                        FAILWITH }
996
                                      {} ;
997
                                    PUSH mutez 0 ;
998
                                    SELF_ADDRESS ;
999
                                    CONTRACT %set_fa1_balance nat ;
1000
                                    IF_NONE
1001
                                      { PUSH string "InvalidFA1SetterEntrypoint" ;
1002
                                        FAILWITH }
1003
                                      {} ;
1004
                                    SELF_ADDRESS ;
1005
                                    PAIR ;
1006
                                    TRANSFER_TOKENS ;
1007
                                    CONS }
1008
                                  { IF_LEFT
1009
                                      { SWAP ;
1010
                                        DUP 2 ;
1011
                                        CAR ;
1012
                                        CONTRACT %balance_of (pair
1013
                                                               (list %requests (pair
1014
                                                                                (address %owner)
1015
                                                                                (nat %token_id)))
1016
                                                               (contract %callback (list (pair
1017
                                                                                         (pair %request
1018
                                                                                           (address %owner)
1019
                                                                                           (nat %token_id))
1020
                                                                                         (nat %balance))))) ;
1021
                                        IF_NONE
1022
                                          { PUSH string "InvalidEntrypoint: balance_of" ;
1023
                                            FAILWITH }
1024
                                          {} ;
1025
                                        PUSH mutez 0 ;
1026
                                        SELF_ADDRESS ;
1027
                                        CONTRACT %set_fa2_balance (list (pair
1028
                                                                         (pair %request
1029
                                                                           (address %owner)
1030
                                                                           (nat %token_id))
1031
                                                                         (nat %balance))) ;
1032
                                        IF_NONE
1033
                                          { PUSH string "InvalidFa2SetterEntrypoint" ;
1034
                                            FAILWITH }
1035
                                          {} ;
1036
                                        NIL (pair address nat) ;
1037
                                        DIG 5 ;
1038
                                        CDR ;
1039
                                        SELF_ADDRESS ;
1040
                                        PAIR ;
1041
                                        CONS ;
1042
                                        PAIR ;
1043
                                        TRANSFER_TOKENS ;
1044
                                        CONS }
1045
                                      { DROP ;
1046
                                        DUP 3 ;
1047
                                        GET 8 ;
1048
                                        PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
1049
                                        MEM ;
1050
                                        IF
1051
                                          {}
1052
                                          { PUSH string "InvalidTezToken" ; FAILWITH } } } } ;
1053
                         SWAP ;
1054
                         DROP ;
1055
                         DIG 2 ;
1056
                         DROP ;
1057
                         DIG 2 ;
1058
                         DROP ;
1059
                         DIG 2 ;
1060
                         DROP ;
1061
                         DIG 2 ;
1062
                         DROP }
1063
                       { IF_LEFT
1064
                           { DROP ;
1065
                             SWAP ;
1066
                             DROP ;
1067
                             SWAP ;
1068
                             DROP ;
1069
                             SWAP ;
1070
                             DROP ;
1071
                             SWAP ;
1072
                             DROP ;
1073
                             AMOUNT ;
1074
                             PUSH mutez 0 ;
1075
                             COMPARE ;
1076
                             EQ ;
1077
                             IF {} { AMOUNT ; FAILWITH } ;
1078
                             PUSH nat 0 ;
1079
                             DUP 2 ;
1080
                             CAR ;
1081
                             CAR ;
1082
                             CAR ;
1083
                             SENDER ;
1084
                             GET ;
1085
                             IF_NONE { PUSH int 46 ; FAILWITH } {} ;
1086
                             COMPARE ;
1087
                             EQ ;
1088
                             IF {} { PUSH int 405 ; FAILWITH } ;
1089
                             UNPAIR ;
1090
                             UNPAIR ;
1091
                             UNPAIR ;
1092
                             PUSH (option nat) (Some 1) ;
1093
                             SENDER ;
1094
                             UPDATE ;
1095
                             PAIR ;
1096
                             PAIR ;
1097
                             PAIR }
1098
                           { DIG 3 ;
1099
                             DROP ;
1100
                             DIG 3 ;
1101
                             DROP ;
1102
                             DIG 3 ;
1103
                             DROP ;
1104
                             AMOUNT ;
1105
                             PUSH mutez 0 ;
1106
                             COMPARE ;
1107
                             EQ ;
1108
                             IF {} { AMOUNT ; FAILWITH } ;
1109
                             DIG 2 ;
1110
                             UNIT ;
1111
                             SWAP ;
1112
                             DIG 3 ;
1113
                             DIG 2 ;
1114
                             PAIR ;
1115
                             EXEC ;
1116
                             CDR ;
1117
                             UNPAIR ;
1118
                             UNPAIR ;
1119
                             CAR ;
1120
                             DIG 3 ;
1121
                             SWAP ;
1122
                             PAIR ;
1123
                             PAIR ;
1124
                             PAIR } ;
1125
                         NIL operation } } } }
1126
           { IF_LEFT
1127
               { IF_LEFT
1128
                   { IF_LEFT
1129
                       { DIG 3 ;
1130
                         DROP ;
1131
                         DIG 3 ;
1132
                         DROP ;
1133
                         DIG 3 ;
1134
                         DROP ;
1135
                         AMOUNT ;
1136
                         PUSH mutez 0 ;
1137
                         COMPARE ;
1138
                         EQ ;
1139
                         IF {} { AMOUNT ; FAILWITH } ;
1140
                         DIG 2 ;
1141
                         UNIT ;
1142
                         SWAP ;
1143
                         DIG 3 ;
1144
                         DIG 2 ;
1145
                         PAIR ;
1146
                         EXEC ;
1147
                         CDR ;
1148
                         SWAP ;
1149
                         SET_DELEGATE ;
1150
                         NIL operation ;
1151
                         SWAP ;
1152
                         CONS }
1153
                       { DIG 3 ;
1154
                         DROP ;
1155
                         DIG 3 ;
1156
                         DROP ;
1157
                         DIG 3 ;
1158
                         DROP ;
1159
                         AMOUNT ;
1160
                         PUSH mutez 0 ;
1161
                         COMPARE ;
1162
                         EQ ;
1163
                         IF {} { AMOUNT ; FAILWITH } ;
1164
                         DIG 2 ;
1165
                         UNIT ;
1166
                         SWAP ;
1167
                         DIG 3 ;
1168
                         DIG 2 ;
1169
                         PAIR ;
1170
                         EXEC ;
1171
                         CDR ;
1172
                         UNPAIR ;
1173
                         UNPAIR ;
1174
                         SWAP ;
1175
                         CDR ;
1176
                         DIG 3 ;
1177
                         PAIR ;
1178
                         SWAP ;
1179
                         PAIR ;
1180
                         PAIR ;
1181
                         NIL operation } }
1182
                   { IF_LEFT
1183
                       { DIG 2 ;
1184
                         DROP ;
1185
                         DIG 2 ;
1186
                         DROP ;
1187
                         DIG 2 ;
1188
                         DROP ;
1189
                         DIG 2 ;
1190
                         DROP ;
1191
                         AMOUNT ;
1192
                         PUSH mutez 0 ;
1193
                         COMPARE ;
1194
                         EQ ;
1195
                         IF {} { AMOUNT ; FAILWITH } ;
1196
                         DUP 2 ;
1197
                         GET 8 ;
1198
                         SENDER ;
1199
                         LEFT (or (pair address nat) unit) ;
1200
                         MEM ;
1201
                         IF {} { PUSH string "UnknownFA1Token" ; FAILWITH } ;
1202
                         DUP 2 ;
1203
                         DUP ;
1204
                         GET 8 ;
1205
                         DIG 3 ;
1206
                         GET 8 ;
1207
                         SENDER ;
1208
                         LEFT (or (pair address nat) unit) ;
1209
                         GET ;
1210
                         IF_NONE { PUSH int 517 ; FAILWITH } {} ;
1211
                         CDR ;
1212
                         DIG 3 ;
1213
                         PAIR ;
1214
                         SOME ;
1215
                         SENDER ;
1216
                         LEFT (or (pair address nat) unit) ;
1217
                         UPDATE ;
1218
                         UPDATE 8 }
1219
                       { IF_LEFT
1220
                           { AMOUNT ;
1221
                             PUSH mutez 0 ;
1222
                             COMPARE ;
1223
                             EQ ;
1224
                             IF {} { AMOUNT ; FAILWITH } ;
1225
                             DUP ;
1226
                             IF_CONS
1227
                               { SWAP ;
1228
                                 DROP ;
1229
                                 SWAP ;
1230
                                 DROP ;
1231
                                 DIG 2 ;
1232
                                 DROP ;
1233
                                 DIG 2 ;
1234
                                 DROP ;
1235
                                 DIG 2 ;
1236
                                 DROP ;
1237
                                 DIG 2 ;
1238
                                 DROP ;
1239
                                 SELF_ADDRESS ;
1240
                                 DUP 2 ;
1241
                                 CAR ;
1242
                                 CAR ;
1243
                                 COMPARE ;
1244
                                 EQ ;
1245
                                 IF
1246
                                   {}
1247
                                   { PUSH string "InvalidBalanceOfResponse" ; FAILWITH } ;
1248
                                 DUP 2 ;
1249
                                 GET 8 ;
1250
                                 DUP 2 ;
1251
                                 CAR ;
1252
                                 CDR ;
1253
                                 SENDER ;
1254
                                 PAIR ;
1255
                                 LEFT unit ;
1256
                                 RIGHT address ;
1257
                                 MEM ;
1258
                                 IF {} { PUSH string "UnknownFA2Token" ; FAILWITH } ;
1259
                                 DUP 2 ;
1260
                                 DUP ;
1261
                                 GET 8 ;
1262
                                 DIG 3 ;
1263
                                 GET 8 ;
1264
                                 DUP 4 ;
1265
                                 CAR ;
1266
                                 CDR ;
1267
                                 SENDER ;
1268
                                 PAIR ;
1269
                                 LEFT unit ;
1270
                                 RIGHT address ;
1271
                                 GET ;
1272
                                 IF_NONE { PUSH int 509 ; FAILWITH } {} ;
1273
                                 CDR ;
1274
                                 DUP 4 ;
1275
                                 CDR ;
1276
                                 PAIR ;
1277
                                 SOME ;
1278
                                 DIG 3 ;
1279
                                 CAR ;
1280
                                 CDR ;
1281
                                 SENDER ;
1282
                                 PAIR ;
1283
                                 LEFT unit ;
1284
                                 RIGHT address ;
1285
                                 UPDATE ;
1286
                                 UPDATE 8 }
1287
                               { DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP ; SWAP ; DROP } }
1288
                           { DIG 3 ;
1289
                             DROP ;
1290
                             DIG 3 ;
1291
                             DROP ;
1292
                             DIG 3 ;
1293
                             DROP ;
1294
                             AMOUNT ;
1295
                             PUSH mutez 0 ;
1296
                             COMPARE ;
1297
                             EQ ;
1298
                             IF {} { AMOUNT ; FAILWITH } ;
1299
                             DIG 2 ;
1300
                             UNIT ;
1301
                             SWAP ;
1302
                             DIG 3 ;
1303
                             DIG 2 ;
1304
                             PAIR ;
1305
                             EXEC ;
1306
                             CDR ;
1307
                             SWAP ;
1308
                             PUSH address "tz1Ke2h7sDdakHJQh8WX4Z372du1KChsksyU" ;
1309
                             DUP 3 ;
1310
                             CAR ;
1311
                             GET 6 ;
1312
                             COMPARE ;
1313
                             EQ ;
1314
                             IF
1315
                               {}
1316
                               { PUSH string "LiquidityAddressAlreadySet" ; FAILWITH } ;
1317
                             SWAP ;
1318
                             UNPAIR ;
1319
                             UNPAIR ;
1320
                             SWAP ;
1321
                             UNPAIR ;
1322
                             SWAP ;
1323
                             CAR ;
1324
                             DIG 4 ;
1325
                             SWAP ;
1326
                             PAIR ;
1327
                             SWAP ;
1328
                             PAIR ;
1329
                             SWAP ;
1330
                             PAIR ;
1331
                             PAIR } } ;
1332
                     NIL operation } }
1333
               { IF_LEFT
1334
                   { IF_LEFT
1335
                       { DIG 3 ;
1336
                         DROP ;
1337
                         DIG 3 ;
1338
                         DROP ;
1339
                         DIG 3 ;
1340
                         DROP ;
1341
                         AMOUNT ;
1342
                         PUSH mutez 0 ;
1343
                         COMPARE ;
1344
                         EQ ;
1345
                         IF {} { AMOUNT ; FAILWITH } ;
1346
                         DIG 2 ;
1347
                         UNIT ;
1348
                         SWAP ;
1349
                         DIG 3 ;
1350
                         DIG 2 ;
1351
                         PAIR ;
1352
                         EXEC ;
1353
                         CDR ;
1354
                         SWAP ;
1355
                         DUP ;
1356
                         CDR ;
1357
                         DUP 2 ;
1358
                         CAR ;
1359
                         COMPARE ;
1360
                         LE ;
1361
                         IF {} { PUSH string "RatioShouldBeLessThanOne" ; FAILWITH } ;
1362
                         PUSH nat 0 ;
1363
                         DUP 2 ;
1364
                         CDR ;
1365
                         COMPARE ;
1366
                         NEQ ;
1367
                         IF {} { PUSH string "DenominatorCannotBeZero" ; FAILWITH } ;
1368
                         SWAP ;
1369
                         UNPAIR ;
1370
                         SWAP ;
1371
                         UNPAIR ;
1372
                         UNPAIR ;
1373
                         SWAP ;
1374
                         CDR ;
1375
                         DIG 4 ;
1376
                         PAIR ;
1377
                         SWAP ;
1378
                         PAIR ;
1379
                         PAIR ;
1380
                         SWAP ;
1381
                         PAIR }
1382
                       { IF_LEFT
1383
                           { DIG 3 ;
1384
                             DROP ;
1385
                             DIG 3 ;
1386
                             DROP ;
1387
                             DIG 3 ;
1388
                             DROP ;
1389
                             AMOUNT ;
1390
                             PUSH mutez 0 ;
1391
                             COMPARE ;
1392
                             EQ ;
1393
                             IF {} { AMOUNT ; FAILWITH } ;
1394
                             DIG 2 ;
1395
                             UNIT ;
1396
                             SWAP ;
1397
                             DIG 3 ;
1398
                             DIG 2 ;
1399
                             PAIR ;
1400
                             EXEC ;
1401
                             CDR ;
1402
                             UNPAIR ;
1403
                             SWAP ;
1404
                             UNPAIR ;
1405
                             UNPAIR ;
1406
                             SWAP ;
1407
                             CAR ;
1408
                             DIG 4 ;
1409
                             SWAP ;
1410
                             PAIR ;
1411
                             SWAP ;
1412
                             PAIR ;
1413
                             PAIR ;
1414
                             SWAP ;
1415
                             PAIR }
1416
                           { DIG 3 ;
1417
                             DROP ;
1418
                             DIG 3 ;
1419
                             DROP ;
1420
                             DIG 3 ;
1421
                             DROP ;
1422
                             AMOUNT ;
1423
                             PUSH mutez 0 ;
1424
                             COMPARE ;
1425
                             EQ ;
1426
                             IF {} { AMOUNT ; FAILWITH } ;
1427
                             DIG 2 ;
1428
                             UNIT ;
1429
                             SWAP ;
1430
                             DIG 3 ;
1431
                             DIG 2 ;
1432
                             PAIR ;
1433
                             EXEC ;
1434
                             CDR ;
1435
                             SWAP ;
1436
                             PUSH nat 0 ;
1437
                             DUP 2 ;
1438
                             CDR ;
1439
                             COMPARE ;
1440
                             NEQ ;
1441
                             IF {} { PUSH string "InvalidZeroDenominator" ; FAILWITH } ;
1442
                             DUP ;
1443
                             CDR ;
1444
                             DUP 2 ;
1445
                             CAR ;
1446
                             COMPARE ;
1447
                             LE ;
1448
                             IF {} { PUSH string "InvalidSwapFee" ; FAILWITH } ;
1449
                             UPDATE 5 } } ;
1450
                     NIL operation }
1451
                   { IF_LEFT
1452
                       { DIG 3 ;
1453
                         DROP ;
1454
                         DIG 3 ;
1455
                         DROP ;
1456
                         DIG 3 ;
1457
                         DROP ;
1458
                         AMOUNT ;
1459
                         PUSH mutez 0 ;
1460
                         COMPARE ;
1461
                         EQ ;
1462
                         IF {} { AMOUNT ; FAILWITH } ;
1463
                         DIG 2 ;
1464
                         UNIT ;
1465
                         SWAP ;
1466
                         DIG 3 ;
1467
                         DIG 2 ;
1468
                         PAIR ;
1469
                         EXEC ;
1470
                         CDR ;
1471
                         SWAP ;
1472
                         UPDATE 7 ;
1473
                         NIL operation }
1474
                       { IF_LEFT
1475
                           { PUSH bool True ;
1476
                             DUP 3 ;
1477
                             CAR ;
1478
                             GET 5 ;
1479
                             COMPARE ;
1480
                             EQ ;
1481
                             IF {} { PUSH string "PoolDisabled" ; FAILWITH } ;
1482
                             NOW ;
1483
                             DUP 2 ;
1484
                             GET 10 ;
1485
                             COMPARE ;
1486
                             GE ;
1487
                             IF {} { PUSH string "DeadlinePassed" ; FAILWITH } ;
1488
                             DUP 2 ;
1489
                             GET 8 ;
1490
                             DUP 2 ;
1491
                             CAR ;
1492
                             MEM ;
1493
                             IF {} { PUSH string "UnknownSrcToken" ; FAILWITH } ;
1494
                             DUP 2 ;
1495
                             GET 8 ;
1496
                             DUP 2 ;
1497
                             GET 3 ;
1498
                             MEM ;
1499
                             IF {} { PUSH string "UnknownDstToken" ; FAILWITH } ;
1500
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
1501
                             DUP 2 ;
1502
                             CAR ;
1503
                             COMPARE ;
1504
                             EQ ;
1505
                             IF
1506
                               { PUSH mutez 1 ;
1507
                                 AMOUNT ;
1508
                                 EDIV ;
1509
                                 IF_NONE { UNIT ; FAILWITH } {} ;
1510
                                 CAR ;
1511
                                 DUP 2 ;
1512
                                 GET 5 ;
1513
                                 COMPARE ;
1514
                                 EQ ;
1515
                                 IF
1516
                                   {}
1517
                                   { PUSH string "InvalidTezAmountSent" ; FAILWITH } }
1518
                               { AMOUNT ;
1519
                                 PUSH mutez 0 ;
1520
                                 COMPARE ;
1521
                                 EQ ;
1522
                                 IF
1523
                                   {}
1524
                                   { PUSH string "InvalidTezAmountSent" ; FAILWITH } } ;
1525
                             PUSH mutez 1 ;
1526
                             BALANCE ;
1527
                             EDIV ;
1528
                             IF_NONE { UNIT ; FAILWITH } {} ;
1529
                             CAR ;
1530
                             PUSH mutez 1 ;
1531
                             AMOUNT ;
1532
                             EDIV ;
1533
                             IF_NONE { UNIT ; FAILWITH } {} ;
1534
                             CAR ;
1535
                             DUP ;
1536
                             DUP 3 ;
1537
                             SUB ;
1538
                             ISNAT ;
1539
                             IF_NONE { PUSH int 363 ; FAILWITH } {} ;
1540
                             DUP 5 ;
1541
                             GET 8 ;
1542
                             PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
1543
                             MEM ;
1544
                             IF
1545
                               { SWAP ;
1546
                                 DROP ;
1547
                                 SWAP ;
1548
                                 DROP ;
1549
                                 DIG 3 ;
1550
                                 DROP ;
1551
                                 DIG 3 ;
1552
                                 DROP ;
1553
                                 DIG 3 ;
1554
                                 DROP ;
1555
                                 DIG 3 ;
1556
                                 DROP ;
1557
                                 DUP 3 ;
1558
                                 DUP ;
1559
                                 GET 8 ;
1560
                                 DIG 4 ;
1561
                                 GET 8 ;
1562
                                 PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
1563
                                 GET ;
1564
                                 IF_NONE { PUSH int 365 ; FAILWITH } {} ;
1565
                                 CDR ;
1566
                                 DIG 3 ;
1567
                                 PAIR ;
1568
                                 SOME ;
1569
                                 PUSH (or address (or (pair address nat) unit)) (Right (Right Unit)) ;
1570
                                 UPDATE ;
1571
                                 UPDATE 8 ;
1572
                                 SWAP }
1573
                               { DROP 3 ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP ; DIG 2 ; DROP } ;
1574
                             NIL operation ;
1575
                             SELF %request_own_balances ;
1576
                             PUSH mutez 0 ;
1577
                             UNIT ;
1578
                             TRANSFER_TOKENS ;
1579
                             CONS ;
1580
                             SELF %token_swap_internal ;
1581
                             PUSH mutez 0 ;
1582
                             SENDER ;
1583
                             DIG 4 ;
1584
                             PAIR ;
1585
                             TRANSFER_TOKENS ;
1586
                             CONS }
1587
                           { DUP 4 ;
1588
                             UNIT ;
1589
                             EXEC ;
1590
                             SELF_ADDRESS ;
1591
                             DUP 3 ;
1592
                             CAR ;
1593
                             GET 5 ;
1594
                             DUP 4 ;
1595
                             CAR ;
1596
                             GET 3 ;
1597
                             DUP 5 ;
1598
                             CAR ;
1599
                             CAR ;
1600
                             PAIR 3 ;
1601
                             VIEW "total_expected_out_amount" nat ;
1602
                             IF_NONE
1603
                               { PUSH string "Invalid view: total_expected_out_amount" ;
1604
                                 FAILWITH }
1605
                               {} ;
1606
                             DUP 4 ;
1607
                             GET 5 ;
1608
                             CDR ;
1609
                             DUP 2 ;
1610
                             DUP 6 ;
1611
                             GET 5 ;
1612
                             CAR ;
1613
                             MUL ;
1614
                             EDIV ;
1615
                             IF_NONE { PUSH int 392 ; FAILWITH } { CAR } ;
1616
                             DUP ;
1617
                             DUP 3 ;
1618
                             SUB ;
1619
                             ISNAT ;
1620
                             IF_NONE { PUSH int 393 ; FAILWITH } {} ;
1621
                             DUP 5 ;
1622
                             CAR ;
1623
                             GET 7 ;
1624
                             DUP 2 ;
1625
                             COMPARE ;
1626
                             GE ;
1627
                             IF
1628
                               {}
1629
                               { PUSH string "MinAmountBoughtGreaterThanTokensBought" ;
1630
                                 FAILWITH } ;
1631
                             DUP 6 ;
1632
                             GET 3 ;
1633
                             GET 3 ;
1634
                             CDR ;
1635
                             DUP 3 ;
1636
                             DUP 8 ;
1637
                             GET 3 ;
1638
                             GET 3 ;
1639
                             CAR ;
1640
                             MUL ;
1641
                             EDIV ;
1642
                             IF_NONE { PUSH int 398 ; FAILWITH } { CAR } ;
1643
                             DUP ;
1644
                             DUP 3 ;
1645
                             ADD ;
1646
                             DIG 7 ;
1647
                             DUP ;
1648
                             GET 8 ;
1649
                             DUP ;
1650
                             DUP 10 ;
1651
                             CAR ;
1652
                             CAR ;
1653
                             DUP ;
1654
                             DUG 2 ;
1655
                             GET ;
1656
                             IF_NONE { PUSH int 401 ; FAILWITH } {} ;
1657
                             DUP ;
1658
                             CAR ;
1659
                             DUP 12 ;
1660
                             CAR ;
1661
                             GET 5 ;
1662
                             ADD ;
1663
                             UPDATE 1 ;
1664
                             SOME ;
1665
                             SWAP ;
1666
                             UPDATE ;
1667
                             UPDATE 8 ;
1668
                             DUG 7 ;
1669
                             DUP ;
1670
                             DUP 9 ;
1671
                             GET 8 ;
1672
                             DUP 9 ;
1673
                             CAR ;
1674
                             GET 3 ;
1675
                             GET ;
1676
                             IF_NONE { PUSH int 402 ; FAILWITH } {} ;
1677
                             CAR ;
1678
                             SUB ;
1679
                             ISNAT ;
1680
                             IF_NONE
1681
                               { PUSH string "DstTokenWouldBeNegative" ; FAILWITH }
1682
                               {} ;
1683
                             DIG 8 ;
1684
                             DUP ;
1685
                             GET 8 ;
1686
                             DUP ;
1687
                             DUP 11 ;
1688
                             CAR ;
1689
                             GET 3 ;
1690
                             DUP ;
1691
                             DUG 2 ;
1692
                             GET ;
1693
                             IF_NONE { PUSH int 402 ; FAILWITH } {} ;
1694
                             DIG 4 ;
1695
                             UPDATE 1 ;
1696
                             SOME ;
1697
                             SWAP ;
1698
                             UPDATE ;
1699
                             UPDATE 8 ;
1700
                             DUG 7 ;
1701
                             NIL operation ;
1702
                             DUP 13 ;
1703
                             DUP 9 ;
1704
                             CAR ;
1705
                             GET 5 ;
1706
                             SELF_ADDRESS ;
1707
                             DUP 11 ;
1708
                             CDR ;
1709
                             DUP 12 ;
1710
                             CAR ;
1711
                             CAR ;
1712
                             PAIR 4 ;
1713
                             SWAP ;
1714
                             DIG 10 ;
1715
                             DIG 3 ;
1716
                             DIG 3 ;
1717
                             PAIR 3 ;
1718
                             EXEC ;
1719
                             UNPAIR 3 ;
1720
                             DIG 13 ;
1721
                             DIG 13 ;
1722
                             DIG 13 ;
1723
                             DIG 13 ;
1724
                             DIG 6 ;
1725
                             DUG 13 ;
1726
                             DUG 13 ;
1727
                             DUG 13 ;
1728
                             DUG 13 ;
1729
                             DUG 13 ;
1730
                             DUP 14 ;
1731
                             DUP 6 ;
1732
                             DUP 11 ;
1733
                             CAR ;
1734
                             GET 9 ;
1735
                             SELF_ADDRESS ;
1736
                             DUP 13 ;
1737
                             CAR ;
1738
                             GET 3 ;
1739
                             PAIR 4 ;
1740
                             SWAP ;
1741
                             DIG 11 ;
1742
                             DIG 4 ;
1743
                             DIG 3 ;
1744
                             PAIR 3 ;
1745
                             EXEC ;
1746
                             UNPAIR 3 ;
1747
                             DIG 14 ;
1748
                             DIG 14 ;
1749
                             DIG 14 ;
1750
                             DIG 14 ;
1751
                             DIG 6 ;
1752
                             DIG 14 ;
1753
                             DIG 14 ;
1754
                             DIG 14 ;
1755
                             DIG 14 ;
1756
                             DIG 14 ;
1757
                             DIG 14 ;
1758
                             DIG 14 ;
1759
                             DIG 13 ;
1760
                             DIG 14 ;
1761
                             DIG 14 ;
1762
                             DUP 15 ;
1763
                             DUP 6 ;
1764
                             DUP 13 ;
1765
                             GET 3 ;
1766
                             GET 4 ;
1767
                             SELF_ADDRESS ;
1768
                             DUP 14 ;
1769
                             CAR ;
1770
                             GET 3 ;
1771
                             PAIR 4 ;
1772
                             DIG 2 ;
1773
                             DROP ;
1774
                             DIG 2 ;
1775
                             DROP ;
1776
                             DIG 3 ;
1777
                             DROP ;
1778
                             DIG 3 ;
1779
                             DROP ;
1780
                             DIG 3 ;
1781
                             DROP ;
1782
                             DIG 3 ;
1783
                             DROP ;
1784
                             DIG 3 ;
1785
                             DROP ;
1786
                             DIG 3 ;
1787
                             DROP ;
1788
                             DIG 3 ;
1789
                             DROP ;
1790
                             DIG 4 ;
1791
                             DROP ;
1792
                             DIG 4 ;
1793
                             DROP ;
1794
                             DIG 4 ;
1795
                             DROP ;
1796
                             DIG 4 ;
1797
                             DROP ;
1798
                             SWAP ;
1799
                             DUG 3 ;
1800
                             PAIR 3 ;
1801
                             EXEC ;
1802
                             CDR ;
1803
                             UNPAIR } } } } } ;
1804
         NIL operation ;
1805
         SWAP ;
1806
         ITER { CONS } ;
1807
         PAIR } ;
1808
  view "get_invariant" unit nat
1809
        { UNPAIR ;
1810
          PUSH nat 0 ;
1811
          PUSH nat 0 ;
1812
          PUSH nat 1 ;
1813
          DUP 5 ;
1814
          GET 8 ;
1815
          SIZE ;
1816
          PUSH nat 1 ;
1817
          DUP 7 ;
1818
          GET 8 ;
1819
          ITER { DUP 8 ;
1820
                 GET 7 ;
1821
                 DUP 2 ;
1822
                 CAR ;
1823
                 VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
1824
                 IF_NONE { PUSH string "InvalidView: get_token_price" ; FAILWITH } {} ;
1825
                 UNPAIR ;
1826
                 DIG 2 ;
1827
                 DUP ;
1828
                 GET 4 ;
1829
                 SWAP ;
1830
                 GET 3 ;
1831
                 MUL ;
1832
                 MUL ;
1833
                 EDIV ;
1834
                 IF_NONE { PUSH int 559 ; FAILWITH } { CAR } ;
1835
                 DIG 4 ;
1836
                 DUP 2 ;
1837
                 ADD ;
1838
                 DUG 4 ;
1839
                 DIG 3 ;
1840
                 MUL ;
1841
                 DUG 2 ;
1842
                 DUP 2 ;
1843
                 SWAP ;
1844
                 MUL } ;
1845
          DUP ;
1846
          DUP 8 ;
1847
          CAR ;
1848
          CAR ;
1849
          CDR ;
1850
          MUL ;
1851
          PUSH nat 2 ;
1852
          DUP 6 ;
1853
          ADD ;
1854
          DUP 6 ;
1855
          PUSH nat 1 ;
1856
          DUP 3 ;
1857
          DUP 3 ;
1858
          SUB ;
1859
          ABS ;
1860
          COMPARE ;
1861
          GT ;
1862
          LOOP { SWAP ;
1863
                 DROP ;
1864
                 DUP 5 ;
1865
                 DUP 4 ;
1866
                 MUL ;
1867
                 DUP 2 ;
1868
                 DUP 3 ;
1869
                 DUP 4 ;
1870
                 DUP 5 ;
1871
                 MUL ;
1872
                 MUL ;
1873
                 MUL ;
1874
                 EDIV ;
1875
                 IF_NONE { PUSH int 572 ; FAILWITH } { CAR } ;
1876
                 DUP ;
1877
                 DUP 8 ;
1878
                 DUP 5 ;
1879
                 MUL ;
1880
                 SUB ;
1881
                 ISNAT ;
1882
                 IF_NONE { PUSH int 573 ; FAILWITH } {} ;
1883
                 PUSH nat 1 ;
1884
                 DUP 5 ;
1885
                 SUB ;
1886
                 ISNAT ;
1887
                 IF_NONE { PUSH int 574 ; FAILWITH } {} ;
1888
                 DUP 2 ;
1889
                 EDIV ;
1890
                 IF_NONE { PUSH int 574 ; FAILWITH } { CAR } ;
1891
                 DUG 2 ;
1892
                 DIG 9 ;
1893
                 PUSH nat 1 ;
1894
                 ADD ;
1895
                 DUG 9 ;
1896
                 PUSH nat 200 ;
1897
                 DUP 11 ;
1898
                 COMPARE ;
1899
                 EQ ;
1900
                 IF { DIG 3 ; DROP 3 ; DUP } { DROP 2 } ;
1901
                 PUSH nat 1 ;
1902
                 DUP 3 ;
1903
                 DUP 3 ;
1904
                 SUB ;
1905
                 ABS ;
1906
                 COMPARE ;
1907
                 GT } ;
1908
          SWAP ;
1909
          DROP ;
1910
          SWAP ;
1911
          DROP ;
1912
          SWAP ;
1913
          DROP ;
1914
          SWAP ;
1915
          DROP ;
1916
          SWAP ;
1917
          DROP ;
1918
          SWAP ;
1919
          DROP ;
1920
          DIG 2 ;
1921
          DROP ;
1922
          DIG 2 ;
1923
          DROP ;
1924
          PUSH nat 200 ;
1925
          DIG 2 ;
1926
          COMPARE ;
1927
          LT ;
1928
          IF {} { PUSH string "InvariantDoesNotConverge" ; FAILWITH } } ;
1929
  view "get_invariant_debug"
1930
        (map
1931
          (or (address %fa1)
1932
              (or (pair %fa2 (address %contract) (nat %token_id)) (unit %tez)))
1933
          nat)
1934
        nat
1935
        { UNPAIR ;
1936
          PUSH nat 0 ;
1937
          PUSH nat 0 ;
1938
          PUSH nat 1 ;
1939
          DUP 4 ;
1940
          SIZE ;
1941
          PUSH nat 1 ;
1942
          DUP 6 ;
1943
          ITER { CDR ; DIG 4 ; DUP 2 ; ADD ; DUG 4 ; DIG 3 ; MUL ; DUG 2 ; DUP 2 ; SWAP ; MUL } ;
1944
          DUP ;
1945
          DUP 8 ;
1946
          CAR ;
1947
          CAR ;
1948
          CDR ;
1949
          MUL ;
1950
          PUSH nat 2 ;
1951
          DUP 6 ;
1952
          ADD ;
1953
          DUP 6 ;
1954
          PUSH nat 1 ;
1955
          DUP 3 ;
1956
          DUP 3 ;
1957
          SUB ;
1958
          ABS ;
1959
          COMPARE ;
1960
          GT ;
1961
          LOOP { SWAP ;
1962
                 DROP ;
1963
                 DUP 5 ;
1964
                 DUP 4 ;
1965
                 MUL ;
1966
                 DUP 2 ;
1967
                 DUP 3 ;
1968
                 DUP 4 ;
1969
                 DUP 5 ;
1970
                 MUL ;
1971
                 MUL ;
1972
                 MUL ;
1973
                 EDIV ;
1974
                 IF_NONE { PUSH int 726 ; FAILWITH } { CAR } ;
1975
                 DUP ;
1976
                 DUP 8 ;
1977
                 DUP 5 ;
1978
                 MUL ;
1979
                 SUB ;
1980
                 ISNAT ;
1981
                 IF_NONE { PUSH int 727 ; FAILWITH } {} ;
1982
                 PUSH nat 1 ;
1983
                 DUP 5 ;
1984
                 SUB ;
1985
                 ISNAT ;
1986
                 IF_NONE { PUSH int 728 ; FAILWITH } {} ;
1987
                 DUP 2 ;
1988
                 EDIV ;
1989
                 IF_NONE { PUSH int 728 ; FAILWITH } { CAR } ;
1990
                 DUG 2 ;
1991
                 DIG 9 ;
1992
                 PUSH nat 1 ;
1993
                 ADD ;
1994
                 DUG 9 ;
1995
                 PUSH nat 200 ;
1996
                 DUP 11 ;
1997
                 COMPARE ;
1998
                 EQ ;
1999
                 IF { DIG 3 ; DROP 3 ; DUP } { DROP 2 } ;
2000
                 PUSH nat 1 ;
2001
                 DUP 3 ;
2002
                 DUP 3 ;
2003
                 SUB ;
2004
                 ABS ;
2005
                 COMPARE ;
2006
                 GT } ;
2007
          SWAP ;
2008
          DROP ;
2009
          SWAP ;
2010
          DROP ;
2011
          SWAP ;
2012
          DROP ;
2013
          SWAP ;
2014
          DROP ;
2015
          SWAP ;
2016
          DROP ;
2017
          SWAP ;
2018
          DROP ;
2019
          DIG 2 ;
2020
          DROP ;
2021
          DIG 2 ;
2022
          DROP ;
2023
          PUSH nat 200 ;
2024
          DIG 2 ;
2025
          COMPARE ;
2026
          LT ;
2027
          IF {} { PUSH string "InvariantDoesNotConverge" ; FAILWITH } } ;
2028
  view "get_liquidity_funds" unit nat { CDR ; GET 3 ; CAR } ;
2029
  view "get_liquidity_usd_price" unit (pair (nat %numerator) (nat %denominator))
2030
        { UNPAIR ;
2031
          PUSH nat 0 ;
2032
          DUP 3 ;
2033
          GET 8 ;
2034
          ITER { DUP 4 ;
2035
                 GET 7 ;
2036
                 DUP 2 ;
2037
                 CAR ;
2038
                 VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
2039
                 IF_NONE { PUSH string "InvalidView: get_token_price" ; FAILWITH } {} ;
2040
                 PUSH nat 100 ;
2041
                 DUP 2 ;
2042
                 CDR ;
2043
                 MUL ;
2044
                 SWAP ;
2045
                 CAR ;
2046
                 DIG 2 ;
2047
                 DUP ;
2048
                 GET 4 ;
2049
                 SWAP ;
2050
                 GET 3 ;
2051
                 MUL ;
2052
                 MUL ;
2053
                 EDIV ;
2054
                 IF_NONE { PUSH int 696 ; FAILWITH } { CAR } ;
2055
                 ADD } ;
2056
          SWAP ;
2057
          DROP ;
2058
          SWAP ;
2059
          GET 3 ;
2060
          CAR ;
2061
          SWAP ;
2062
          PAIR } ;
2063
  view "get_token_funds"
2064
        (or (address %fa1)
2065
            (or (pair %fa2 (address %contract) (nat %token_id)) (unit %tez)))
2066
        nat
2067
        { UNPAIR ;
2068
          DUP 2 ;
2069
          GET 8 ;
2070
          DUP 2 ;
2071
          MEM ;
2072
          IF {} { PUSH string "UnknownToken" ; FAILWITH } ;
2073
          SWAP ;
2074
          GET 8 ;
2075
          SWAP ;
2076
          GET ;
2077
          IF_NONE { PUSH int 661 ; FAILWITH } {} ;
2078
          CAR } ;
2079
  view "get_token_funds_in_usd"
2080
        (or (address %fa1)
2081
            (or (pair %fa2 (address %contract) (nat %token_id)) (unit %tez)))
2082
        (pair (nat %numerator) (nat %denominator))
2083
        { UNPAIR ;
2084
          DUP 2 ;
2085
          GET 8 ;
2086
          DUP 2 ;
2087
          MEM ;
2088
          IF {} { PUSH string "UnknownToken" ; FAILWITH } ;
2089
          DUP 2 ;
2090
          GET 7 ;
2091
          DUP 2 ;
2092
          VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
2093
          IF_NONE { PUSH string "InvalidView: get_token_price" ; FAILWITH } {} ;
2094
          UNPAIR ;
2095
          DIG 3 ;
2096
          GET 8 ;
2097
          DIG 3 ;
2098
          GET ;
2099
          IF_NONE { PUSH int 675 ; FAILWITH } {} ;
2100
          CAR ;
2101
          MUL ;
2102
          PAIR } ;
2103
  view "tokens_bought_debug"
2104
        (pair
2105
          (pair
2106
            (or %dst_token (address %fa1)
2107
                           (or (pair %fa2 (address %contract) (nat %token_id))
2108
                               (unit %tez)))
2109
            (map %funds
2110
              (or (address %fa1)
2111
                  (or (pair %fa2 (address %contract) (nat %token_id)) (unit %tez)))
2112
              nat))
2113
          (pair (nat %sold_amount)
2114
                (or %src_token (address %fa1)
2115
                               (or (pair %fa2 (address %contract) (nat %token_id))
2116
                                   (unit %tez)))))
2117
        nat
2118
        { UNPAIR ;
2119
          SELF_ADDRESS ;
2120
          DUP 2 ;
2121
          CAR ;
2122
          CDR ;
2123
          VIEW "get_invariant_view_complex" nat ;
2124
          IF_NONE { PUSH string "Invalid view" ; FAILWITH } {} ;
2125
          PUSH nat 0 ;
2126
          PUSH nat 1 ;
2127
          DUP 4 ;
2128
          CAR ;
2129
          CDR ;
2130
          SIZE ;
2131
          PUSH nat 1 ;
2132
          DUP 6 ;
2133
          UNPAIR ;
2134
          UNPAIR ;
2135
          SWAP ;
2136
          DUP ;
2137
          DUP 10 ;
2138
          GET 4 ;
2139
          DUP ;
2140
          DUG 2 ;
2141
          GET ;
2142
          IF_NONE { PUSH int 760 ; FAILWITH } {} ;
2143
          DIG 10 ;
2144
          GET 3 ;
2145
          ADD ;
2146
          SOME ;
2147
          SWAP ;
2148
          UPDATE ;
2149
          SWAP ;
2150
          PAIR ;
2151
          PAIR ;
2152
          DUG 5 ;
2153
          DUP 6 ;
2154
          CAR ;
2155
          CDR ;
2156
          ITER { SWAP ;
2157
                 DUP 3 ;
2158
                 SWAP ;
2159
                 MUL ;
2160
                 SWAP ;
2161
                 DUP 7 ;
2162
                 CAR ;
2163
                 CAR ;
2164
                 DUP 2 ;
2165
                 CAR ;
2166
                 COMPARE ;
2167
                 NEQ ;
2168
                 IF
2169
                   { DIG 4 ; DUP 2 ; CDR ; ADD ; DUG 4 ; CDR ; DIG 3 ; MUL ; DUG 2 }
2170
                   { DROP } } ;
2171
          DUP ;
2172
          DUP 8 ;
2173
          CAR ;
2174
          CAR ;
2175
          CDR ;
2176
          MUL ;
2177
          DUP ;
2178
          DUP 7 ;
2179
          EDIV ;
2180
          IF_NONE { PUSH int 768 ; FAILWITH } { CAR } ;
2181
          DUP 6 ;
2182
          ADD ;
2183
          DUP 3 ;
2184
          DUP 3 ;
2185
          DUP 7 ;
2186
          MUL ;
2187
          MUL ;
2188
          DUP 8 ;
2189
          DUP 9 ;
2190
          DUP 10 ;
2191
          DUP 11 ;
2192
          MUL ;
2193
          MUL ;
2194
          MUL ;
2195
          EDIV ;
2196
          IF_NONE { PUSH int 769 ; FAILWITH } { CAR } ;
2197
          DUP 8 ;
2198
          PUSH nat 2 ;
2199
          DUP 10 ;
2200
          ADD ;
2201
          PUSH nat 0 ;
2202
          PUSH nat 1 ;
2203
          DUP 4 ;
2204
          DUP 4 ;
2205
          SUB ;
2206
          ABS ;
2207
          COMPARE ;
2208
          GT ;
2209
          LOOP { SWAP ;
2210
                 DROP ;
2211
                 DUP 2 ;
2212
                 SWAP ;
2213
                 DUP 11 ;
2214
                 DUP 6 ;
2215
                 DUP 5 ;
2216
                 PUSH nat 2 ;
2217
                 MUL ;
2218
                 ADD ;
2219
                 SUB ;
2220
                 ISNAT ;
2221
                 IF_NONE { PUSH int 777 ; FAILWITH } {} ;
2222
                 DUP 5 ;
2223
                 DIG 4 ;
2224
                 DUP ;
2225
                 MUL ;
2226
                 ADD ;
2227
                 EDIV ;
2228
                 IF_NONE { PUSH int 777 ; FAILWITH } { CAR } ;
2229
                 DUG 2 ;
2230
                 PUSH nat 1 ;
2231
                 ADD ;
2232
                 PUSH nat 200 ;
2233
                 DUP 2 ;
2234
                 COMPARE ;
2235
                 EQ ;
2236
                 IF { SWAP ; DROP ; DUP 2 ; SWAP } {} ;
2237
                 PUSH nat 1 ;
2238
                 DUP 4 ;
2239
                 DUP 4 ;
2240
                 SUB ;
2241
                 ABS ;
2242
                 COMPARE ;
2243
                 GT } ;
2244
          SWAP ;
2245
          DROP ;
2246
          DIG 2 ;
2247
          DROP ;
2248
          DIG 2 ;
2249
          DROP ;
2250
          DIG 2 ;
2251
          DROP ;
2252
          DIG 2 ;
2253
          DROP ;
2254
          DIG 2 ;
2255
          DROP ;
2256
          DIG 2 ;
2257
          DROP ;
2258
          DIG 2 ;
2259
          DROP ;
2260
          DIG 2 ;
2261
          DROP ;
2262
          DIG 3 ;
2263
          DROP ;
2264
          PUSH nat 200 ;
2265
          COMPARE ;
2266
          GT ;
2267
          IF {} { PUSH string "dyDoesNotConverge" ; FAILWITH } ;
2268
          PUSH int 1 ;
2269
          SWAP ;
2270
          DIG 2 ;
2271
          DUP ;
2272
          CAR ;
2273
          CDR ;
2274
          SWAP ;
2275
          CAR ;
2276
          CAR ;
2277
          GET ;
2278
          IF_NONE { PUSH int 784 ; FAILWITH } {} ;
2279
          SUB ;
2280
          SUB ;
2281
          ISNAT ;
2282
          IF_NONE { PUSH int 784 ; FAILWITH } {} } ;
2283
  view "total_expected_out_amount"
2284
        (pair
2285
          (or %src_token (address %fa1)
2286
                         (or (pair %fa2 (address %contract) (nat %token_id)) (unit %tez)))
2287
          (pair
2288
            (or %dst_token (address %fa1)
2289
                           (or (pair %fa2 (address %contract) (nat %token_id))
2290
                               (unit %tez)))
2291
            (nat %amount_sold)))
2292
        nat
2293
        { UNPAIR ;
2294
          SELF_ADDRESS ;
2295
          UNIT ;
2296
          VIEW "get_invariant" nat ;
2297
          IF_NONE { PUSH string "Invalid view: get_invariant" ; FAILWITH } {} ;
2298
          PUSH nat 0 ;
2299
          PUSH nat 1 ;
2300
          DUP 5 ;
2301
          GET 8 ;
2302
          SIZE ;
2303
          PUSH nat 1 ;
2304
          DUP 7 ;
2305
          GET 8 ;
2306
          DUP ;
2307
          DUP 8 ;
2308
          CAR ;
2309
          DUP ;
2310
          DUG 2 ;
2311
          GET ;
2312
          IF_NONE { PUSH int 601 ; FAILWITH } {} ;
2313
          DUP ;
2314
          CAR ;
2315
          DUP 10 ;
2316
          GET 4 ;
2317
          ADD ;
2318
          UPDATE 1 ;
2319
          SOME ;
2320
          SWAP ;
2321
          UPDATE ;
2322
          PUSH nat 0 ;
2323
          DUP 2 ;
2324
          ITER { DIG 3 ;
2325
                 DUP 5 ;
2326
                 SWAP ;
2327
                 MUL ;
2328
                 DUG 3 ;
2329
                 DUP 9 ;
2330
                 GET 3 ;
2331
                 DUP 2 ;
2332
                 CAR ;
2333
                 COMPARE ;
2334
                 NEQ ;
2335
                 IF
2336
                   { DUP 10 ;
2337
                     GET 7 ;
2338
                     DUP 2 ;
2339
                     CAR ;
2340
                     VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
2341
                     IF_NONE
2342
                       { PUSH string "InvalidView: get_token_price" ; FAILWITH }
2343
                       {} ;
2344
                     UNPAIR ;
2345
                     DUP 3 ;
2346
                     GET 4 ;
2347
                     DIG 3 ;
2348
                     GET 3 ;
2349
                     MUL ;
2350
                     MUL ;
2351
                     EDIV ;
2352
                     IF_NONE { PUSH int 616 ; FAILWITH } { CAR } ;
2353
                     DIG 6 ;
2354
                     DUP 2 ;
2355
                     ADD ;
2356
                     DUG 6 ;
2357
                     DIG 5 ;
2358
                     MUL ;
2359
                     DUG 4 }
2360
                   { SWAP ;
2361
                     DROP ;
2362
                     DUP 9 ;
2363
                     GET 7 ;
2364
                     DUP 2 ;
2365
                     CAR ;
2366
                     VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
2367
                     IF_NONE
2368
                       { PUSH string "InvalidView: get_token_price" ; FAILWITH }
2369
                       {} ;
2370
                     UNPAIR ;
2371
                     DUP 3 ;
2372
                     GET 4 ;
2373
                     DIG 3 ;
2374
                     GET 3 ;
2375
                     MUL ;
2376
                     MUL ;
2377
                     EDIV ;
2378
                     IF_NONE { PUSH int 627 ; FAILWITH } { CAR } } } ;
2379
          DUP 3 ;
2380
          DUP 10 ;
2381
          CAR ;
2382
          CAR ;
2383
          CDR ;
2384
          MUL ;
2385
          DUP ;
2386
          DUP 9 ;
2387
          EDIV ;
2388
          IF_NONE { PUSH int 631 ; FAILWITH } { CAR } ;
2389
          DUP 8 ;
2390
          ADD ;
2391
          DUP 5 ;
2392
          DUP 3 ;
2393
          DUP 9 ;
2394
          MUL ;
2395
          MUL ;
2396
          DUP 10 ;
2397
          DUP 11 ;
2398
          DUP 12 ;
2399
          DUP 13 ;
2400
          MUL ;
2401
          MUL ;
2402
          MUL ;
2403
          EDIV ;
2404
          IF_NONE { PUSH int 632 ; FAILWITH } { CAR } ;
2405
          DUP 10 ;
2406
          PUSH nat 2 ;
2407
          DUP 12 ;
2408
          ADD ;
2409
          PUSH nat 0 ;
2410
          PUSH nat 1 ;
2411
          DUP 4 ;
2412
          DUP 4 ;
2413
          SUB ;
2414
          ABS ;
2415
          COMPARE ;
2416
          GT ;
2417
          LOOP { SWAP ;
2418
                 DROP ;
2419
                 DUP 2 ;
2420
                 SWAP ;
2421
                 DUP 13 ;
2422
                 DUP 6 ;
2423
                 DUP 5 ;
2424
                 PUSH nat 2 ;
2425
                 MUL ;
2426
                 ADD ;
2427
                 SUB ;
2428
                 ISNAT ;
2429
                 IF_NONE { PUSH int 640 ; FAILWITH } {} ;
2430
                 DUP 5 ;
2431
                 DIG 4 ;
2432
                 DUP ;
2433
                 MUL ;
2434
                 ADD ;
2435
                 EDIV ;
2436
                 IF_NONE { PUSH int 640 ; FAILWITH } { CAR } ;
2437
                 DUG 2 ;
2438
                 PUSH nat 1 ;
2439
                 ADD ;
2440
                 PUSH nat 200 ;
2441
                 DUP 2 ;
2442
                 COMPARE ;
2443
                 EQ ;
2444
                 IF { SWAP ; DROP ; DUP 2 ; SWAP } {} ;
2445
                 PUSH nat 1 ;
2446
                 DUP 4 ;
2447
                 DUP 4 ;
2448
                 SUB ;
2449
                 ABS ;
2450
                 COMPARE ;
2451
                 GT } ;
2452
          SWAP ;
2453
          DROP ;
2454
          DIG 2 ;
2455
          DROP ;
2456
          DIG 2 ;
2457
          DROP ;
2458
          DIG 2 ;
2459
          DROP ;
2460
          DIG 4 ;
2461
          DROP ;
2462
          DIG 4 ;
2463
          DROP ;
2464
          DIG 4 ;
2465
          DROP ;
2466
          DIG 4 ;
2467
          DROP ;
2468
          DIG 4 ;
2469
          DROP ;
2470
          PUSH nat 200 ;
2471
          COMPARE ;
2472
          GT ;
2473
          IF {} { PUSH string "dyDoesNotConverge" ; FAILWITH } ;
2474
          PUSH int 1 ;
2475
          SWAP ;
2476
          DIG 2 ;
2477
          SUB ;
2478
          SUB ;
2479
          ISNAT ;
2480
          IF_NONE { PUSH int 647 ; FAILWITH } {} ;
2481
          DIG 3 ;
2482
          GET 7 ;
2483
          DUP 4 ;
2484
          GET 3 ;
2485
          VIEW "get_token_price" (pair (nat %numerator) (nat %denominator)) ;
2486
          IF_NONE { PUSH string "InvalidView: get_token_price" ; FAILWITH } {} ;
2487
          DUP ;
2488
          CAR ;
2489
          DIG 3 ;
2490
          DIG 4 ;
2491
          GET 3 ;
2492
          GET ;
2493
          IF_NONE { PUSH int 654 ; FAILWITH } {} ;
2494
          CDR ;
2495
          MUL ;
2496
          SWAP ;
2497
          CDR ;
2498
          DIG 2 ;
2499
          MUL ;
2500
          EDIV ;
2501
          IF_NONE { PUSH int 654 ; FAILWITH } { CAR } } }