BCD

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