BCD

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