From 4a4c782063e06ab2e0c0cff816d1e6859b4c3943 Mon Sep 17 00:00:00 2001 From: Jason Ridgway-Taylor Date: Tue, 24 Oct 2023 11:48:19 +0530 Subject: [PATCH] Added a build step to build all contracts --- batcher/Makefile | 6 +- batcher/michelson/batcher-ghostnet.tz | 4391 +++++++++++++++++ batcher/michelson/batcher-storage-ghostnet.tz | 8 + batcher/michelson/btctz-vault-ghostnet.tz | 1136 +++++ .../michelson/btctz-vault-storage-ghostnet.tz | 9 + batcher/michelson/eurl-vault-ghostnet.tz | 1136 +++++ .../michelson/eurl-vault-storage-ghostnet.tz | 9 + batcher/michelson/marketmaker-ghostnet.tz | 1029 ++++ .../michelson/marketmaker-storage-ghostnet.tz | 5 + batcher/michelson/tokenmanager-ghostnet.tz | 1365 +++++ .../tokenmanager-storage-ghostnet.tz | 22 + batcher/michelson/usdt-vault-ghostnet.tz | 1136 +++++ .../michelson/usdt-vault-storage-ghostnet.tz | 9 + batcher/michelson/usdtz-vault-ghostnet.tz | 1136 +++++ .../michelson/usdtz-vault-storage-ghostnet.tz | 10 + 15 files changed, 11405 insertions(+), 2 deletions(-) create mode 100644 batcher/michelson/batcher-ghostnet.tz create mode 100644 batcher/michelson/batcher-storage-ghostnet.tz create mode 100644 batcher/michelson/btctz-vault-ghostnet.tz create mode 100644 batcher/michelson/btctz-vault-storage-ghostnet.tz create mode 100644 batcher/michelson/eurl-vault-ghostnet.tz create mode 100644 batcher/michelson/eurl-vault-storage-ghostnet.tz create mode 100644 batcher/michelson/marketmaker-ghostnet.tz create mode 100644 batcher/michelson/marketmaker-storage-ghostnet.tz create mode 100644 batcher/michelson/tokenmanager-ghostnet.tz create mode 100644 batcher/michelson/tokenmanager-storage-ghostnet.tz create mode 100644 batcher/michelson/usdt-vault-ghostnet.tz create mode 100644 batcher/michelson/usdt-vault-storage-ghostnet.tz create mode 100644 batcher/michelson/usdtz-vault-ghostnet.tz create mode 100644 batcher/michelson/usdtz-vault-storage-ghostnet.tz diff --git a/batcher/Makefile b/batcher/Makefile index 5ac5d570..280612ea 100644 --- a/batcher/Makefile +++ b/batcher/Makefile @@ -53,10 +53,10 @@ clean-ghostnet: clean: $(call clean_mainnet_files) $(call clean_ghostnet_files) -build-mainnet: +build-batcher-mainnet: $(call compile_contract,batcher.mligo, $(MICHELSON_DIRECTORY)/batcher-mainnet.tz) $(call compile_storage,$(STORAGE_DIRECTORY)/batcher_storage_mainnet.mligo, $(MICHELSON_DIRECTORY)/batcher-storage-mainnet.tz) -build-ghostnet: +build-batcher-ghostnet: $(call compile_contract,batcher.mligo, $(MICHELSON_DIRECTORY)/batcher-ghostnet.tz) $(call compile_storage,$(STORAGE_DIRECTORY)/batcher_storage_ghostnet.mligo, $(MICHELSON_DIRECTORY)/batcher-storage-ghostnet.tz) build-mm-mainnet: @@ -109,6 +109,8 @@ build-EURL: build-fa12-tzBTC: $(call compile_contract,$(FA12_DIRECTORY)/main.mligo, $(MICHELSON_DIRECTORY)/tzBTC_fa12_token.tz) $(call compile_storage,$(FA12_STORAGE_DIRECTORY)/tzBTC_storage.mligo, $(MICHELSON_DIRECTORY)/tzBTC_fa12_token_storage.tz) +build-all-ghostnet: build-tm-ghostnet build-btctz-vault-ghostnet build-eurl-vault-ghostnet build-usdt-vault-ghostnet build-btctz-vault-ghostnet build-usdtz-vault-ghostnet build-mm-ghostnet build-batcher-ghostnet +build-all-mainnet: build-tm-mainnet build-btctz-vault-mainnet build-eurl-vault-mainnet build-usdt-vault-mainnet build-btctz-vault-mainnet build-usdtz-vault-mainnet build-mm-mainnet build-batcher-mainnet test-mm: $(call test_ligo,$(TEST_DIRECTORY)/test-market-maker.mligo) test-tm: diff --git a/batcher/michelson/batcher-ghostnet.tz b/batcher/michelson/batcher-ghostnet.tz new file mode 100644 index 00000000..fb553442 --- /dev/null +++ b/batcher/michelson/batcher-ghostnet.tz @@ -0,0 +1,4391 @@ +{ parameter + (or (or (or (or (pair %add_or_update_metadata (string %key) (bytes %value)) + (pair %cancel string string)) + (or (address %change_admin_address) (nat %change_deposit_time_window))) + (or (or (mutez %change_fee) (address %change_fee_recipient_address)) + (or (address %change_marketmaker_address) (address %change_tokenmanager_address)))) + (or (or (pair %deposit + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) + (unit %redeem)) + (or (string %remove_metadata) (string %tick)))) ; + storage + (pair (pair (pair (pair (address %administrator) + (pair %batch_set + (map %current_batch_indices string nat) + (big_map %batches + nat + (pair (nat %batch_number) + (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)) + (pair %pair string string) + (nat %holdings) + (option %market_vault_used address))))) + (nat %deposit_time_window_in_seconds) + (mutez %fee_in_mutez)) + (pair (address %fee_recipient) (nat %last_order_number)) + (nat %limit_on_tokens_or_pairs) + (address %marketmaker)) + (pair (big_map %metadata string bytes) + (big_map %rates_current + string + (pair (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (address %tokenmanager) + (big_map %user_batch_ordertypes + address + (map nat + (map (pair (or %side (unit %buy) (unit %sell)) + (or %tolerance (or (unit %exact) (unit %minus)) (unit %plus))) + nat)))) ; + code { LAMBDA + (pair nat nat) + nat + { UNPAIR ; + PUSH nat 1 ; + DUG 2 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } } ; + PUSH int 1 ; + PUSH int 10000 ; + PAIR ; + PUSH int 1 ; + PUSH int 10001 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + LAMBDA + (pair int int) + int + { UNPAIR ; + SWAP ; + PUSH int 1 ; + PAIR ; + LEFT int ; + LOOP_LEFT + { UNPAIR ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { SWAP ; DROP ; RIGHT (pair int int) } + { PUSH int 1 ; DIG 2 ; SUB ; DUP 3 ; DIG 2 ; MUL ; PAIR ; LEFT int } } ; + SWAP ; + DROP } ; + LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + PUSH int 1 ; + PUSH int 10000 ; + PAIR ; + PUSH int 1 ; + PUSH int 10001 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DIG 5 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 4 ; + DIG 5 ; + DIG 6 ; + DROP 4 ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DIG 2 ; + DROP ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP ; + CAR ; + DUP 5 ; + CDR ; + CAR ; + CAR ; + DUP 5 ; + CAR ; + GET ; + IF_NONE + { DIG 4 ; + CDR ; + CAR ; + CAR ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DROP ; + DIG 4 ; + CDR ; + CAR ; + CAR ; + DUP 5 ; + CDR ; + SOME ; + DIG 5 ; + CAR ; + UPDATE } ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation ; + PAIR } + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + UNPAIR ; + DUP 5 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + DUP 3 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 117 ; FAILWITH } + { DUP 4 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + NOW ; + DUP 7 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP ; + CDR ; + DUP 2 ; + CAR ; + DUP 9 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + NONE address ; + PUSH nat 0 ; + DIG 9 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DUP 7 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DUP 9 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + NONE address ; + PUSH nat 0 ; + DIG 9 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DUP 7 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DIG 8 ; DROP 3 ; DUP 7 ; DIG 2 } } + { DIG 9 ; + DROP ; + DUP 2 ; + INT ; + ADD ; + DIG 4 ; + COMPARE ; + GE ; + IF { DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DROP 2 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { SWAP ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DUP 7 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DROP ; DUP 7 ; DIG 2 } } } ; + DIG 2 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + NOT ; + IF { PUSH nat 140 ; FAILWITH } {} ; + DIG 7 ; + CDR ; + CDR ; + CDR ; + DUP 8 ; + GET ; + IF_NONE + { DROP 8 ; PUSH nat 139 ; FAILWITH } + { DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + GET ; + IF_NONE + { SWAP ; DIG 4 ; DROP 3 ; PUSH nat 139 ; FAILWITH } + { DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CDR ; + DIG 8 ; + CDR ; + CDR ; + CDR ; + DIG 6 ; + DIG 6 ; + NONE (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + SWAP ; + UPDATE ; + SOME ; + DUP 12 ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + SWAP ; + PAIR } ; + UNPAIR ; + DUP 3 ; + GET 5 ; + DUP 2 ; + ITER { UNPAIR ; + UNPAIR ; + IF_LEFT + { DROP ; + DUP 2 ; + DUP 4 ; + GET 7 ; + SUB ; + ABS ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 3 ; + SUB ; + ABS ; + UPDATE 3 ; + SWAP ; + UPDATE 7 } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + CAR ; + SUB ; + ABS ; + UPDATE 1 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 5 ; + SUB ; + ABS ; + UPDATE 5 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 2 ; + DUP 4 ; + GET 14 ; + SUB ; + ABS ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 11 ; + SUB ; + ABS ; + UPDATE 11 ; + SWAP ; + UPDATE 14 } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 9 ; + SUB ; + ABS ; + UPDATE 9 ; + SWAP ; + UPDATE 14 } } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 13 ; + SUB ; + ABS ; + UPDATE 13 ; + SWAP ; + UPDATE 14 } } } ; + PUSH nat 1 ; + DUP 5 ; + GET 9 ; + SUB ; + ABS ; + DIG 4 ; + DIG 2 ; + UPDATE 5 ; + SWAP ; + UPDATE 9 ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP 7 ; + SOME ; + DIG 7 ; + CAR ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP 5 ; + GET 8 ; + DUP 6 ; + GET 7 ; + DUP 7 ; + GET 5 ; + DIG 7 ; + GET 3 ; + DIG 6 ; + PUSH nat 1 ; + DIG 8 ; + PAIR ; + PAIR ; + PAIR 5 ; + PUSH mutez 0 ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + PAIR ; + DIG 3 ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 3 ; + DIG 3 ; + CAR ; + IF_LEFT { DROP ; DUP 4 ; CAR ; CAR ; CAR } { DROP ; DUP 4 ; CAR ; CDR } ; + PAIR ; + PAIR ; + DUP 6 ; + SWAP ; + EXEC ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + SWAP ; + PAIR } ; + SWAP ; + DIG 4 ; + DROP 2 ; + UNPAIR ; + SELF_ADDRESS ; + NIL operation ; + DIG 2 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 8 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 11 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DIG 4 ; + DROP 2 ; + PUSH mutez 0 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CDR ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + CONS } + { SWAP ; DROP } ; + PAIR } } } } + { DIG 2 ; + DROP ; + IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CAR ; + CDR ; + CAR ; + CAR ; + DUP 2 ; + COMPARE ; + EQ ; + IF { PUSH nat 144 ; FAILWITH } {} ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + NIL operation ; + PAIR } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + PUSH nat 600 ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 131 ; FAILWITH } + { PUSH nat 3600 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 2 ; PUSH nat 132 ; FAILWITH } + { DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + NIL operation ; + PAIR } } } } } + { DIG 2 ; + DROP ; + IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + DUP 2 ; + COMPARE ; + EQ ; + IF { PUSH nat 144 ; FAILWITH } {} ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 } } ; + NIL operation ; + PAIR } } + { IF_LEFT + { DIG 2 ; + DIG 4 ; + DIG 5 ; + DROP 3 ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + DUP ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + DUP 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + SWAP ; + IF_LEFT { DROP } { DROP ; DUP ; CAR ; SWAP ; CDR ; PAIR } ; + NOW ; + DUP 4 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + DUP 3 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 8 ; + IF { DROP 5 ; PUSH nat 125 ; FAILWITH } + { DUP 4 ; + CAR ; + DUP 5 ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + IF_LEFT + { DROP ; + SWAP ; + CAR ; + CAR ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + COMPARE ; + EQ ; + IF {} { PUSH nat 156 ; FAILWITH } } + { DROP ; + SWAP ; + CAR ; + CDR ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + COMPARE ; + EQ ; + IF {} { PUSH nat 156 ; FAILWITH } } ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CDR ; + AMOUNT ; + DUP 2 ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 6 ; PUSH nat 113 ; FAILWITH } + { COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 130 ; FAILWITH } + { DUP 4 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP ; + CDR ; + DUP 2 ; + CAR ; + DUP 5 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + NONE address ; + PUSH nat 0 ; + DUP 6 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 4 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DUP 6 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + NONE address ; + PUSH nat 0 ; + DUP 6 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 4 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DROP 2 ; DIG 4 ; DIG 2 } } + { DUP 2 ; + INT ; + ADD ; + DIG 4 ; + COMPARE ; + GE ; + IF { DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DIG 6 ; + DROP 3 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { SWAP ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DIG 4 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DROP ; DIG 4 ; DIG 2 } } } ; + DIG 2 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + IF { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + IF { DIG 3 ; DROP } + { DUP 3 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + DIG 4 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 3 ; + SWAP ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 124 ; FAILWITH } {} ; + CAR ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CAR ; + INT ; + NOW ; + SUB ; + COMPARE ; + LT ; + IF {} { PUSH nat 120 ; FAILWITH } } ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP 6 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP 2 ; + CAR ; + SENDER ; + DUP 3 ; + CAR ; + CDR ; + CDR ; + CDR ; + UNIT ; + VIEW "get_vaults" (map string address) ; + IF_NONE { PUSH nat 166 ; FAILWITH } {} ; + PUSH bool False ; + SWAP ; + ITER { CDR ; DUP 2 ; IF { DROP } { SWAP ; DROP ; DUP 2 ; COMPARE ; EQ } } ; + PUSH nat 1 ; + DUP 5 ; + CAR ; + CDR ; + CAR ; + CDR ; + ADD ; + DUP 5 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + DUP 6 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + DUP 10 ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + DUP 11 ; + GET 6 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; RIGHT unit ; LEFT unit } + { PUSH nat 1 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit ; LEFT unit } + { PUSH nat 2 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT (or unit unit) } { PUSH nat 107 ; FAILWITH } } } ; + SENDER ; + DUP 13 ; + CAR ; + DUP ; + CAR ; + CAR ; + DUP 2 ; + CDR ; + DUP 7 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { SWAP ; DIG 2 ; DIG 6 ; DIG 7 ; DROP 5 ; PUSH nat 110 ; FAILWITH } + { DIG 7 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { SWAP ; DIG 2 ; DIG 3 ; DIG 7 ; DROP 5 ; PUSH nat 110 ; FAILWITH } + { DUP ; + GET 8 ; + DUP 4 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 2 ; + GET 7 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 5 ; + DUP 6 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 3 ; + DUP 7 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 4 ; + CAR ; + DIG 6 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 2 ; + GET 8 ; + DUP 4 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 6 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 7 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 6 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + AND ; + IF { DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DIG 4 ; + DUP 5 ; + IF_LEFT { DROP ; SWAP } { DROP ; DUP 2 ; CAR ; DIG 2 ; CDR ; PAIR } ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + MEM ; + IF {} { PUSH nat 110 ; FAILWITH } } + { DIG 4 ; DROP 2 ; PUSH nat 110 ; FAILWITH } } } ; + PUSH bool False ; + DIG 2 ; + DIG 3 ; + DIG 11 ; + CAR ; + DIG 4 ; + DUP 9 ; + DUP 7 ; + PAIR 7 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP 2 ; + GET 5 ; + GET ; + IF_NONE + { PUSH bool True } + { PUSH nat 0 ; + SWAP ; + ITER { CDR ; SIZE ; ADD } ; + PUSH nat 10 ; + SWAP ; + COMPARE ; + LE } ; + IF { DIG 2 ; + IF { DIG 5 ; DIG 3 ; SOME ; UPDATE 10 } { DIG 2 ; DROP ; DIG 4 } ; + DUP ; + GET 5 ; + DUP 3 ; + GET 9 ; + IF_LEFT + { DROP ; + DUP 3 ; + GET 7 ; + CAR ; + CDR ; + DUP 2 ; + GET 7 ; + ADD ; + DUP 4 ; + GET 11 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 3 ; + ADD ; + UPDATE 3 ; + SWAP ; + UPDATE 7 } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + CAR ; + ADD ; + UPDATE 1 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 5 ; + ADD ; + UPDATE 5 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 3 ; + GET 7 ; + CAR ; + CDR ; + DUP 2 ; + GET 14 ; + ADD ; + DUP 4 ; + GET 11 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 11 ; + ADD ; + UPDATE 11 ; + SWAP ; + UPDATE 14 } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 9 ; + ADD ; + UPDATE 9 ; + SWAP ; + UPDATE 14 } } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 13 ; + ADD ; + UPDATE 13 ; + SWAP ; + UPDATE 14 } } ; + DUP 7 ; + CDR ; + DUG 2 ; + UPDATE 5 ; + SOME ; + DUP 5 ; + UPDATE ; + DUP 5 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + GET 5 ; + GET ; + IF_NONE + { DUP ; + DUP 5 ; + GET ; + IF_NONE + { DROP ; PUSH nat 142 ; FAILWITH } + { PUSH nat 1 ; DUP 2 ; GET 9 ; ADD ; UPDATE 9 ; SOME ; DUP 5 ; UPDATE } } + { DUP 5 ; + GET ; + IF_NONE + { DUP ; + DUP 5 ; + GET ; + IF_NONE + { DROP ; PUSH nat 142 ; FAILWITH } + { PUSH nat 1 ; DUP 2 ; GET 9 ; ADD ; UPDATE 9 ; SOME ; DUP 5 ; UPDATE } } + { DROP } } ; + DUP 2 ; + GET 5 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP 2 ; + GET ; + IF_NONE + { DUP 6 ; + CDR ; + CDR ; + CDR ; + EMPTY_MAP nat (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + EMPTY_MAP (pair (or unit unit) (or (or unit unit) unit)) nat ; + DUP 6 ; + GET 7 ; + CAR ; + CDR ; + DUP 7 ; + GET 11 ; + DUP 8 ; + GET 9 ; + PAIR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 7 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 2 ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DUP ; + DUP 7 ; + GET ; + IF_NONE + { EMPTY_MAP (pair (or unit unit) (or (or unit unit) unit)) nat ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DUP 6 ; + GET 11 ; + DUP 7 ; + GET 9 ; + PAIR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 6 ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DUP 5 ; + GET 11 ; + DUP 6 ; + GET 9 ; + PAIR ; + DUP 2 ; + DUP 2 ; + GET ; + IF_NONE + { SWAP ; DUP 6 ; GET 7 ; CAR ; CDR ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 7 ; GET 7 ; CAR ; CDR ; ADD ; DIG 2 ; SWAP ; SOME ; DIG 2 ; UPDATE } ; + SOME ; + DIG 6 ; + UPDATE } ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + SWAP ; + SOME ; + DIG 2 ; + UPDATE } ; + DUP 5 ; + DIG 5 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 8 ; + DIG 6 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP ; + CAR ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP 3 ; + GET 7 ; + CAR ; + DIG 3 ; + GET 5 ; + SELF_ADDRESS ; + DUP 3 ; + CAR ; + GET 5 ; + IF_NONE + { DROP 3 ; PUSH nat 109 ; FAILWITH } + { DUP 4 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 4 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 4 ; + CDR ; + DIG 3 ; + DIG 4 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 7 ; + CDR ; + DIG 7 ; + CAR ; + CAR ; + DIG 6 ; + PAIR 3 ; + CONS ; + DIG 4 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 4 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } + { DROP 8 ; PUSH nat 112 ; FAILWITH } } + { DROP 5 ; PUSH nat 103 ; FAILWITH } } } } } + { DROP ; + SENDER ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SELF_ADDRESS ; + PUSH mutez 0 ; + PUSH mutez 0 ; + EMPTY_MAP address mutez ; + PAIR ; + DUP 5 ; + CAR ; + CDR ; + CAR ; + CAR ; + DUP 5 ; + PAIR ; + PAIR ; + PAIR ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CDR ; + DUP 5 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 3 ; + DUP 9 ; + GET ; + IF_NONE + { SWAP ; DIG 4 ; DIG 9 ; DIG 10 ; DROP 4 ; DIG 2 ; PAIR ; SWAP } + { NONE nat ; + IF_NONE + { DIG 5 ; + DIG 6 ; + PAIR ; + DIG 3 ; + DIG 5 ; + PAIR ; + DIG 3 ; + DUP 4 ; + PAIR ; + PAIR ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 4 ; + UNPAIR ; + DUP 3 ; + CDR ; + DUP ; + DUP 9 ; + GET ; + IF_NONE + { DIG 7 ; DIG 8 ; DROP 3 ; PAIR ; DUG 2 ; PAIR ; DIG 3 ; DIG 3 } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { CAR ; CDR ; SOME } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } ; + IF_NONE + { SWAP ; DIG 8 ; DIG 9 ; DROP 4 ; PAIR ; DUG 2 ; PAIR ; DIG 3 ; DIG 3 } + { DUP 2 ; + GET 10 ; + DUP 6 ; + DIG 5 ; + PAIR ; + PAIR ; + DUP 7 ; + DUP 4 ; + GET 5 ; + PAIR ; + DIG 9 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR ; + DIG 8 ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 4 ; + UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { PUSH nat 0 ; + DUP 5 ; + GET 14 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { DUP 8 ; + CDR ; + DUP 7 ; + GET 3 ; + DUP 10 ; + CAR ; + IF_LEFT + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } } + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } } } ; + IF { DUP 6 ; + GET 6 ; + CAR ; + DUP 6 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 7 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 9 ; + CAR ; + IF_LEFT + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + GET 5 ; + INT ; + SWAP ; + GET 3 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + CAR ; + INT ; + SWAP ; + GET 6 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 3 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } ; + DUP 4 ; + IF_NONE + { DUP 3 ; DUP 3 ; CDR ; ADD ; DIG 2 ; SWAP ; UPDATE 2 } + { DUP 3 ; + CAR ; + CDR ; + CAR ; + DUP ; + DUP 3 ; + GET ; + IF_NONE + { DUP 5 ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 6 ; ADD ; SOME ; DIG 2 ; UPDATE } ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 } ; + SWAP } + { DUP 6 ; + GET 6 ; + CAR ; + DIG 8 ; + CAR ; + IF_LEFT + { DROP ; + DUP 6 ; + SWAP ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } + { DROP ; + DUP 6 ; + SWAP ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } ; + DUP 3 ; + DUP 3 ; + CAR ; + CDR ; + CDR ; + ADD ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + DIG 7 ; + DIG 8 ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } ; + DUG 3 ; + PAIR ; + PAIR ; + DIG 3 ; + DIG 3 ; + PAIR ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR } ; + UNPAIR ; + CAR ; + CDR ; + SWAP ; + CAR ; + CAR ; + DUP 3 ; + CAR ; + DUP 5 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 4 ; DROP 2 ; PUSH nat 141 ; FAILWITH } + { PUSH nat 1 ; + DUP 2 ; + GET 9 ; + SUB ; + ABS ; + DIG 6 ; + DUG 2 ; + UPDATE 9 ; + SOME ; + DIG 2 ; + UPDATE } ; + DUP ; + DUP 5 ; + CAR ; + GET ; + IF_NONE + { PUSH nat 141 ; FAILWITH } + { PUSH nat 0 ; SWAP ; GET 9 ; COMPARE ; LE } ; + DIG 5 ; + DIG 3 ; + PAIR ; + DIG 6 ; + DIG 2 ; + IF { DIG 2 ; + DROP ; + DUP 5 ; + DIG 5 ; + CDR ; + DIG 5 ; + CAR ; + NONE (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + (option address)) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 4 ; DROP ; DIG 4 ; DIG 3 ; UPDATE 2 } ; + PAIR ; + DIG 2 ; + DIG 3 ; + DIG 4 ; + NONE (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + SWAP ; + UPDATE } } ; + PAIR ; + PAIR ; + PAIR } ; + DIG 5 ; + DIG 6 ; + DROP 2 } + { DUP 2 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 11 ; + DIG 12 ; + DROP 3 ; + DIG 5 ; + DIG 6 ; + PAIR ; + DIG 3 ; + DIG 5 ; + PAIR ; + DIG 3 ; + DIG 3 } + { DUP 7 ; + CDR ; + DUP ; + DUP 4 ; + GET ; + IF_NONE + { SWAP ; + DIG 2 ; + DIG 13 ; + DIG 14 ; + DROP 5 ; + DIG 5 ; + DIG 6 ; + PAIR ; + DIG 3 ; + DIG 5 ; + PAIR ; + DIG 3 ; + DIG 3 } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { CAR ; CDR ; SOME } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } ; + IF_NONE + { SWAP ; + DIG 2 ; + DIG 3 ; + DIG 14 ; + DIG 15 ; + DROP 6 ; + DIG 5 ; + DIG 6 ; + PAIR ; + DIG 3 ; + DIG 5 ; + PAIR ; + DIG 3 ; + DIG 3 } + { DUP 2 ; + GET 10 ; + DUP 12 ; + DIG 13 ; + PAIR ; + PAIR ; + DUP 9 ; + DUP 4 ; + GET 5 ; + PAIR ; + DIG 8 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR ; + DIG 3 ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 4 ; + UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { PUSH nat 0 ; + DUP 5 ; + GET 14 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { DUP 8 ; + CDR ; + DUP 7 ; + GET 3 ; + DUP 10 ; + CAR ; + IF_LEFT + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } } + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } } } ; + IF { DUP 6 ; + GET 6 ; + CAR ; + DUP 6 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 7 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 9 ; + CAR ; + IF_LEFT + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + GET 5 ; + INT ; + SWAP ; + GET 3 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + CAR ; + INT ; + SWAP ; + GET 6 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 3 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } ; + DUP 4 ; + IF_NONE + { DUP 3 ; DUP 3 ; CDR ; ADD ; DIG 2 ; SWAP ; UPDATE 2 } + { DUP 3 ; + CAR ; + CDR ; + CAR ; + DUP ; + DUP 3 ; + GET ; + IF_NONE + { DUP 5 ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 6 ; ADD ; SOME ; DIG 2 ; UPDATE } ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 } ; + SWAP } + { DUP 6 ; + GET 6 ; + CAR ; + DIG 8 ; + CAR ; + IF_LEFT + { DROP ; + DUP 6 ; + SWAP ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } + { DROP ; + DUP 6 ; + SWAP ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } ; + DUP 3 ; + DUP 3 ; + CAR ; + CDR ; + CDR ; + ADD ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + DIG 7 ; + DIG 8 ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } ; + DUG 3 ; + PAIR ; + PAIR ; + DIG 3 ; + DIG 3 ; + PAIR ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR } ; + DIG 12 ; + DIG 13 ; + DROP 2 ; + UNPAIR ; + CAR ; + CDR ; + SWAP ; + CAR ; + CAR ; + DUP 3 ; + CAR ; + DUP 5 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 4 ; DROP 2 ; PUSH nat 141 ; FAILWITH } + { PUSH nat 1 ; + DUP 2 ; + GET 9 ; + SUB ; + ABS ; + DIG 6 ; + DUG 2 ; + UPDATE 9 ; + SOME ; + DIG 2 ; + UPDATE } ; + DUP ; + DUP 5 ; + CAR ; + GET ; + IF_NONE + { PUSH nat 141 ; FAILWITH } + { PUSH nat 0 ; SWAP ; GET 9 ; COMPARE ; LE } ; + DIG 10 ; + DIG 3 ; + PAIR ; + DIG 7 ; + DIG 2 ; + IF { DIG 2 ; + DROP ; + DUP 8 ; + DIG 8 ; + CDR ; + DIG 5 ; + CAR ; + NONE (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + (option address)) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 4 ; DROP ; DIG 7 ; DIG 3 ; UPDATE 2 } ; + PAIR ; + DIG 2 ; + DIG 4 ; + DIG 4 ; + NONE (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + SWAP ; + UPDATE } } } ; + PAIR ; + PAIR ; + PAIR } ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + CAR ; + DIG 3 ; + CAR ; + DIG 3 ; + DIG 2 ; + PAIR ; + DIG 3 ; + DIG 3 ; + SOME ; + DUP 6 ; + UPDATE } ; + DUG 2 ; + UNPAIR ; + NIL operation ; + DIG 2 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 9 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 9 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + DIG 4 ; + DIG 5 ; + DROP 2 ; + PUSH mutez 0 ; + DUP 4 ; + CAR ; + CDR ; + CDR ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { PUSH nat 102 ; FAILWITH } + { DUP 4 ; CAR ; CDR ; CDR ; UNIT ; TRANSFER_TOKENS } ; + CONS } + {} ; + DUP 3 ; + CAR ; + CDR ; + CAR ; + ITER { UNPAIR ; + PUSH mutez 0 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; + SWAP ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + CONS } + { DROP 2 } } ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE + { DIG 2 ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 3 ; CDR ; UNIT ; TRANSFER_TOKENS } ; + CONS } + { DIG 2 ; DROP } ; + DUP 4 ; + DIG 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 5 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + SWAP ; + PAIR } } + { DIG 3 ; + DROP ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DIG 4 ; + DIG 5 ; + DROP 4 ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP ; + CAR ; + DIG 4 ; + CDR ; + CAR ; + CAR ; + DIG 4 ; + NONE bytes ; + SWAP ; + UPDATE ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation ; + PAIR } + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + DUP 2 ; + GET ; + IF_NONE + { DROP 6 ; PUSH nat 117 ; FAILWITH } + { DUP 3 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 3 ; + GET 8 ; + DUP 4 ; + GET 7 ; + DUP 5 ; + GET 5 ; + DIG 5 ; + GET 3 ; + DIG 4 ; + PUSH nat 1 ; + DIG 6 ; + PAIR ; + PAIR ; + PAIR 5 ; + DUP ; + GET 8 ; + DUP 2 ; + GET 7 ; + DUP 3 ; + GET 5 ; + DUP 4 ; + GET 3 ; + DUP 5 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 5 ; + DUP ; + GET 3 ; + SWAP ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 122 ; FAILWITH } {} ; + UNPAIR ; + DUP 5 ; + CDR ; + CAR ; + CDR ; + DUP 5 ; + GET ; + IF_NONE + {} + { DUP 2 ; + SWAP ; + GET 4 ; + COMPARE ; + GE ; + IF { PUSH nat 121 ; FAILWITH } {} } ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + CAR ; + INT ; + DUP 2 ; + SWAP ; + NOW ; + SUB ; + COMPARE ; + LT ; + IF {} { PUSH nat 120 ; FAILWITH } ; + DUP 5 ; + CDR ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + DUP 4 ; + CAR ; + DIG 4 ; + GET 7 ; + DUP ; + DUP 3 ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + GT ; + IF { DUP 2 ; + CAR ; + CAR ; + GET 7 ; + SUB ; + PUSH int 10 ; + PAIR ; + DUP 9 ; + SWAP ; + EXEC ; + DIG 4 ; + MUL ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + CAR ; + GET 7 ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 9 ; + SWAP ; + EXEC ; + SWAP } + { INT ; PUSH int 10 ; PAIR ; DUP 9 ; SWAP ; EXEC ; DIG 4 } ; + INT ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DIG 3 ; + SWAP ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 3 ; + DUP ; + CAR ; + DUP 3 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 3 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + GET 7 ; + SWAP ; + GET 7 ; + SUB ; + DUP ; + ABS ; + INT ; + PUSH int 10 ; + PAIR ; + DIG 6 ; + SWAP ; + EXEC ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; PUSH int 1 ; PUSH int 1 } + { PUSH int 0 ; + DIG 2 ; + COMPARE ; + LT ; + IF { PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + PUSH int 1 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL } + { PUSH int 1 ; SWAP } } ; + PAIR ; + DUP 2 ; + GET 3 ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + UPDATE 3 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CAR ; + DIG 5 ; + CDR ; + CAR ; + CDR ; + DUP ; + DUP 7 ; + GET ; + IF_NONE + { DUP 5 ; DIG 6 ; SWAP ; SOME ; SWAP ; UPDATE } + { GET 4 ; + DUP 6 ; + GET 4 ; + COMPARE ; + GT ; + IF { DUP 5 ; SOME ; DIG 6 ; UPDATE } { DIG 5 ; DROP } } ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP 2 ; + CAR ; + UNIT ; + LEFT unit ; + IF_LEFT { DROP } { DROP ; DUP ; CAR ; SWAP ; CDR ; PAIR } ; + NOW ; + DUP 3 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP ; + CDR ; + DUP 2 ; + CAR ; + DUP 5 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { DIG 2 ; + DROP ; + DIG 2 ; + SWAP ; + NONE (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + (option address)) } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool False } } + { DROP ; PUSH bool False } ; + IF { DIG 3 ; DROP ; DIG 3 } + { DUP 5 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + NONE address ; + PUSH nat 0 ; + DIG 5 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DUP 7 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 3 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 4 ; DROP 2 ; DIG 3 ; DIG 2 } } + { DIG 5 ; + DROP ; + DUP 2 ; + INT ; + ADD ; + DUP 5 ; + COMPARE ; + GE ; + IF { DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DIG 5 ; + DROP 3 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { SWAP ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DIG 3 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DROP ; DIG 3 ; DIG 2 } } ; + DUG 2 } ; + DUG 2 ; + SOME } ; + IF_NONE + { DIG 2 ; DIG 3 ; DIG 4 ; DIG 5 ; DIG 6 ; DROP 6 } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DIG 4 ; DROP 2 ; PUSH bool False } + { CAR ; PUSH int 120 ; ADD ; DIG 4 ; COMPARE ; GT } } + { DIG 4 ; DROP 2 ; PUSH bool False } ; + IF { NOW ; + DUP 2 ; + GET 5 ; + DUP ; + GET 9 ; + INT ; + DUP 2 ; + GET 11 ; + INT ; + DUP 3 ; + GET 13 ; + INT ; + DUP 4 ; + CAR ; + INT ; + DUP 5 ; + GET 3 ; + INT ; + DUP 6 ; + GET 5 ; + INT ; + DIG 3 ; + DIG 4 ; + DIG 5 ; + PAIR ; + PAIR ; + SWAP ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 8 ; + GET 3 ; + DUP 2 ; + CAR ; + CAR ; + DUP 4 ; + UNPAIR ; + UNPAIR ; + DUP 5 ; + DUP 16 ; + DIG 4 ; + DIG 4 ; + DIG 4 ; + ADD ; + ADD ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + DUP 3 ; + CAR ; + UNPAIR ; + DUP 6 ; + UNPAIR ; + CDR ; + DIG 3 ; + DIG 3 ; + ADD ; + DUP 5 ; + DIG 3 ; + DIG 3 ; + ADD ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + DIG 3 ; + UNPAIR ; + UNPAIR ; + DIG 6 ; + CDR ; + DUG 3 ; + ADD ; + ADD ; + DUP 5 ; + CDR ; + DUP 14 ; + CDR ; + MUL ; + DIG 5 ; + CAR ; + DIG 13 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 14 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 16 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 4 ; + CAR ; + DUP 7 ; + CDR ; + MUL ; + DUP 5 ; + CDR ; + DUP 8 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + DUP 6 ; + CAR ; + DUP 8 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DUP 9 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + AND ; + IF { DIG 3 ; DIG 4 ; DIG 5 ; DROP 3 ; UNIT ; RIGHT unit ; LEFT unit } + { DUP 4 ; + CAR ; + DUP 6 ; + CDR ; + MUL ; + DIG 4 ; + CDR ; + DUP 6 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + DUP 6 ; + CAR ; + DUP 6 ; + CDR ; + MUL ; + DIG 6 ; + CDR ; + DIG 6 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + AND ; + IF { UNIT ; LEFT unit ; LEFT unit } { UNIT ; RIGHT (or unit unit) } } ; + DUP 10 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 4 ; + DIG 2 ; + DIG 3 ; + DIG 4 ; + DIG 5 ; + PAIR 3 ; + PAIR 4 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + GET 3 ; + DUP 3 ; + CAR ; + ADD ; + DUP 3 ; + GET 13 ; + DIG 3 ; + GET 11 ; + ADD ; + SWAP } + { DROP ; + DUP 2 ; + GET 13 ; + DUP 3 ; + GET 11 ; + DUP 4 ; + GET 9 ; + ADD ; + ADD ; + DIG 2 ; + CAR } } + { DROP ; + DUP 2 ; + GET 5 ; + DUP 3 ; + GET 3 ; + DUP 4 ; + CAR ; + ADD ; + ADD ; + DIG 2 ; + GET 13 ; + SWAP } ; + DUP 3 ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DIG 9 ; DROP 2 ; DUP 8 } + { DROP ; + DUP 8 ; + GET 3 ; + DUP 10 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 10 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 9 ; + SWAP ; + UPDATE 3 } } + { DROP ; + DUP 8 ; + GET 3 ; + DUP 10 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 10 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 9 ; + SWAP ; + UPDATE 3 } ; + DUP 4 ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; DUP 4 ; CAR ; GET 3 } { DROP ; DUP 4 ; CAR ; CAR } } + { DROP ; DUP 4 ; CAR ; GET 4 } ; + DUP 2 ; + GET 3 ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DIG 13 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 5 ; + DIG 5 ; + DIG 2 ; + DIG 5 ; + DIG 4 ; + PAIR 4 ; + UPDATE 5 ; + SWAP ; + UPDATE 6 ; + DIG 2 ; + DIG 5 ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + LEFT (pair timestamp timestamp) ; + LEFT timestamp ; + UPDATE 3 ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP 3 ; + SOME ; + DUP 4 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 2 ; + CAR ; + DUP 3 ; + CAR ; + SOME ; + DIG 3 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DIG 4 ; DIG 5 ; DIG 6 ; DROP 5 } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation ; + PAIR } } } } } ; + view "get_fee_in_mutez" unit mutez { CDR ; CAR ; CAR ; CDR ; CDR } ; + view "redeemable_holdings_available" + unit + bool + { CDR ; + SENDER ; + SWAP ; + CDR ; + CDR ; + CDR ; + SWAP ; + GET ; + IF_NONE + { PUSH bool False } + { PUSH bool False ; + SWAP ; + ITER { CDR ; + PUSH bool False ; + SWAP ; + ITER { CDR ; PUSH nat 0 ; SWAP ; COMPARE ; GT ; OR } ; + OR } } } ; + view "get_batches_needing_liquidity" + unit + (list (pair (nat %batch_number) + (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)) + (pair %pair string string) + (nat %holdings) + (option %market_vault_used address))) + { CDR ; + NIL (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + (option address)) ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + DUP 3 ; + CAR ; + CAR ; + CAR ; + CDR ; + CDR ; + SWAP ; + GET ; + IF_NONE {} { SOME ; IF_NONE {} { CONS } } } ; + SWAP ; + DROP } } + diff --git a/batcher/michelson/batcher-storage-ghostnet.tz b/batcher/michelson/batcher-storage-ghostnet.tz new file mode 100644 index 00000000..079ebaf6 --- /dev/null +++ b/batcher/michelson/batcher-storage-ghostnet.tz @@ -0,0 +1,8 @@ +(Pair (Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" {} {}) 600 10000) + (Pair "tz1burnburnburnburnburnburnburjAYjjX" 0) + 10 + "KT1XKvKiTTj8N6WKv3MhnZhFjZopFGQGBTdT") + (Pair {} {}) + "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx" + {}) + diff --git a/batcher/michelson/btctz-vault-ghostnet.tz b/batcher/michelson/btctz-vault-ghostnet.tz new file mode 100644 index 00000000..67557279 --- /dev/null +++ b/batcher/michelson/btctz-vault-ghostnet.tz @@ -0,0 +1,1136 @@ +{ parameter + (or (or (or (or (nat %addLiquidity) (mutez %addReward)) + (or (address %change_admin_address) (address %change_batcher_address))) + (or (or (address %change_marketmaker_address) (address %change_tokenmanager_address)) + (or (unit %claim) + (pair %injectLiquidity + (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)))))) + (unit %removeLiquidity)) ; + storage + (pair (pair (pair (address %administrator) (address %batcher)) + (map %foreign_tokens + string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount))) + (address %marketmaker)) + (pair (pair %native_token + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (address %tokenmanager)) + (nat %total_shares) + (pair %vault_holdings + (set %keys address) + (big_map %values + address + (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ; + code { LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + LAMBDA + (pair (lambda + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (pair (pair int int) + (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat)))) + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + { UNPAIR ; + SWAP ; + UNPAIR 3 ; + DUP 2 ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CDR ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 153 ; FAILWITH } + { DUP ; + DUP 3 ; + CDR ; + INT ; + SUB ; + ABS ; + DUP 3 ; + DIG 2 ; + UPDATE 2 ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + EQ ; + IF { DIG 4 ; DROP 2 ; DIG 2 } + { DIG 3 ; SWAP ; PAIR ; DIG 3 ; SWAP ; EXEC } ; + DUG 2 ; + UPDATE 2 ; + PAIR } } ; + DUP 2 ; + APPLY ; + DIG 2 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 3 ; + CDR ; + CAR ; + CAR ; + DIG 2 ; + UPDATE 2 ; + SELF_ADDRESS ; + DUP 2 ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + DIG 3 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 6 ; + CDR ; + DUP 7 ; + CAR ; + CAR ; + DIG 6 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 4 ; + CDR ; + CAR ; + CAR ; + DUP ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + NOT ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 115 ; FAILWITH } + { DUP 3 ; + CDR ; + DUP 6 ; + CDR ; + CDR ; + CAR ; + ADD ; + DUP 2 ; + DUP 5 ; + CDR ; + DIG 3 ; + CDR ; + ADD ; + UPDATE 2 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 7 ; + MEM ; + IF { CDR ; + DUP 6 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { PUSH mutez 0 ; DIG 4 ; CDR ; DUP 6 ; PAIR ; PAIR } + { DIG 4 ; + CDR ; + DUP 2 ; + CAR ; + CDR ; + ADD ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 1 } ; + DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 7 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP ; + DUP 2 ; + CAR ; + DUP 10 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + SWAP ; + CDR ; + DIG 5 ; + DIG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + DIG 2 ; + CONS } + { DUP 2 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 3 ; + CDR ; + CDR ; + CDR ; + EMPTY_MAP address (pair (pair address nat) mutez) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP ; + EMPTY_BIG_MAP address (pair (pair address nat) mutez) ; + EMPTY_SET address ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DUP 2 ; + CAR ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 6 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 5 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DUP 6 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH mutez 1 ; + MUL ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DUP 3 ; CDR ; ADD } { DROP ; DUP 2 ; CDR } ; + DIG 2 ; + SWAP ; + UPDATE 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 2 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 4 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 2 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } ; + SWAP ; + DIG 2 ; + DROP 2 ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation } ; + PAIR } + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } + { IF_LEFT + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP 2 ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP ; PUSH nat 155 ; FAILWITH } + { DUP ; + CDR ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP 3 ; PUSH nat 155 ; FAILWITH } + { SWAP ; + PUSH mutez 0 ; + UPDATE 2 ; + DUP ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP 6 ; + CAR ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 7 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 7 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } } } + { DUP 2 ; + CAR ; + CDR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 168 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + UNIT ; + LEFT unit ; + LEFT unit ; + IF_LEFT + { IF_LEFT { DROP ; PUSH nat 1 } { DROP ; PUSH nat 0 } } + { DROP ; PUSH nat 2 } ; + DUP 2 ; + CDR ; + CAR ; + IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } ; + NOW ; + DUP 4 ; + CDR ; + CDR ; + DUP 5 ; + CAR ; + CAR ; + DIG 5 ; + CAR ; + CDR ; + PAIR ; + PAIR ; + PAIR 4 ; + DUP 2 ; + CAR ; + CAR ; + CDR ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 5 ; + IF_NONE + { DROP 2 ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DUP ; + CONTRACT %approve (pair (address %spender) (nat %value)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + PAIR ; + TRANSFER_TOKENS } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DUP 2 ; + CONTRACT %add_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DUP 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } + { PUSH nat 108 ; FAILWITH } } ; + DUP 3 ; + CONTRACT %deposit + (pair (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + TRANSFER_TOKENS ; + DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; NONE operation } + { DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DIG 3 ; + CONTRACT %remove_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DIG 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS ; + SOME } + { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; PUSH nat 108 ; FAILWITH } } ; + IF_NONE { NIL operation } { NIL operation ; SWAP ; CONS } ; + SWAP ; + CONS ; + SWAP ; + CONS } ; + PAIR } } } } + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP 4 ; PUSH nat 151 ; FAILWITH } + { UNPAIR ; + CDR ; + DUP 4 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 6 ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + SWAP ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + DIG 3 ; + DUP 3 ; + PAIR 3 ; + DUP 9 ; + SWAP ; + EXEC ; + UNPAIR ; + DIG 3 ; + SWAP ; + PAIR ; + DUP 10 ; + SWAP ; + EXEC ; + DIG 2 ; + PAIR ; + PAIR } ; + DIG 6 ; + DIG 7 ; + DROP 2 ; + UNPAIR ; + CDR ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + DUP 5 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; DIG 3 ; DIG 6 ; DROP 5 ; PUSH nat 154 ; FAILWITH } + { DIG 3 ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + SUB ; + ABS ; + DIG 2 ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + PAIR } ; + UNPAIR ; + DUP 4 ; + CONTRACT unit ; + IF_NONE { PUSH nat 102 ; FAILWITH } { DUP 4 ; UNIT ; TRANSFER_TOKENS } ; + SELF_ADDRESS ; + NIL operation ; + DIG 4 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DROP ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; + CDR ; + DIG 8 ; + NONE (pair (pair address nat) mutez) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 7 ; DROP } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + PUSH mutez 0 ; + DIG 4 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; + PAIR } } } ; + view "get_native_token_of_vault" + unit + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + { CDR ; CDR ; CAR ; CAR ; CAR } ; + view "get_vault_balances" + unit + (pair (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (map string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)))) + { CDR ; DUP ; CAR ; CDR ; CAR ; SWAP ; CDR ; CAR ; CAR ; PAIR } } + diff --git a/batcher/michelson/btctz-vault-storage-ghostnet.tz b/batcher/michelson/btctz-vault-storage-ghostnet.tz new file mode 100644 index 00000000..c8e3e104 --- /dev/null +++ b/batcher/michelson/btctz-vault-storage-ghostnet.tz @@ -0,0 +1,9 @@ +(Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + {} + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + (Pair (Pair (Pair 0 "BTCtz" (Some "KT1ErLEYVsxqHxLgLucXViq5DYrtSyDuSFTe") 8 (Some "FA2 token")) 0) + "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx") + 0 + {} + {}) + diff --git a/batcher/michelson/eurl-vault-ghostnet.tz b/batcher/michelson/eurl-vault-ghostnet.tz new file mode 100644 index 00000000..67557279 --- /dev/null +++ b/batcher/michelson/eurl-vault-ghostnet.tz @@ -0,0 +1,1136 @@ +{ parameter + (or (or (or (or (nat %addLiquidity) (mutez %addReward)) + (or (address %change_admin_address) (address %change_batcher_address))) + (or (or (address %change_marketmaker_address) (address %change_tokenmanager_address)) + (or (unit %claim) + (pair %injectLiquidity + (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)))))) + (unit %removeLiquidity)) ; + storage + (pair (pair (pair (address %administrator) (address %batcher)) + (map %foreign_tokens + string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount))) + (address %marketmaker)) + (pair (pair %native_token + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (address %tokenmanager)) + (nat %total_shares) + (pair %vault_holdings + (set %keys address) + (big_map %values + address + (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ; + code { LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + LAMBDA + (pair (lambda + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (pair (pair int int) + (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat)))) + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + { UNPAIR ; + SWAP ; + UNPAIR 3 ; + DUP 2 ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CDR ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 153 ; FAILWITH } + { DUP ; + DUP 3 ; + CDR ; + INT ; + SUB ; + ABS ; + DUP 3 ; + DIG 2 ; + UPDATE 2 ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + EQ ; + IF { DIG 4 ; DROP 2 ; DIG 2 } + { DIG 3 ; SWAP ; PAIR ; DIG 3 ; SWAP ; EXEC } ; + DUG 2 ; + UPDATE 2 ; + PAIR } } ; + DUP 2 ; + APPLY ; + DIG 2 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 3 ; + CDR ; + CAR ; + CAR ; + DIG 2 ; + UPDATE 2 ; + SELF_ADDRESS ; + DUP 2 ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + DIG 3 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 6 ; + CDR ; + DUP 7 ; + CAR ; + CAR ; + DIG 6 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 4 ; + CDR ; + CAR ; + CAR ; + DUP ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + NOT ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 115 ; FAILWITH } + { DUP 3 ; + CDR ; + DUP 6 ; + CDR ; + CDR ; + CAR ; + ADD ; + DUP 2 ; + DUP 5 ; + CDR ; + DIG 3 ; + CDR ; + ADD ; + UPDATE 2 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 7 ; + MEM ; + IF { CDR ; + DUP 6 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { PUSH mutez 0 ; DIG 4 ; CDR ; DUP 6 ; PAIR ; PAIR } + { DIG 4 ; + CDR ; + DUP 2 ; + CAR ; + CDR ; + ADD ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 1 } ; + DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 7 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP ; + DUP 2 ; + CAR ; + DUP 10 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + SWAP ; + CDR ; + DIG 5 ; + DIG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + DIG 2 ; + CONS } + { DUP 2 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 3 ; + CDR ; + CDR ; + CDR ; + EMPTY_MAP address (pair (pair address nat) mutez) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP ; + EMPTY_BIG_MAP address (pair (pair address nat) mutez) ; + EMPTY_SET address ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DUP 2 ; + CAR ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 6 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 5 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DUP 6 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH mutez 1 ; + MUL ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DUP 3 ; CDR ; ADD } { DROP ; DUP 2 ; CDR } ; + DIG 2 ; + SWAP ; + UPDATE 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 2 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 4 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 2 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } ; + SWAP ; + DIG 2 ; + DROP 2 ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation } ; + PAIR } + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } + { IF_LEFT + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP 2 ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP ; PUSH nat 155 ; FAILWITH } + { DUP ; + CDR ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP 3 ; PUSH nat 155 ; FAILWITH } + { SWAP ; + PUSH mutez 0 ; + UPDATE 2 ; + DUP ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP 6 ; + CAR ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 7 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 7 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } } } + { DUP 2 ; + CAR ; + CDR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 168 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + UNIT ; + LEFT unit ; + LEFT unit ; + IF_LEFT + { IF_LEFT { DROP ; PUSH nat 1 } { DROP ; PUSH nat 0 } } + { DROP ; PUSH nat 2 } ; + DUP 2 ; + CDR ; + CAR ; + IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } ; + NOW ; + DUP 4 ; + CDR ; + CDR ; + DUP 5 ; + CAR ; + CAR ; + DIG 5 ; + CAR ; + CDR ; + PAIR ; + PAIR ; + PAIR 4 ; + DUP 2 ; + CAR ; + CAR ; + CDR ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 5 ; + IF_NONE + { DROP 2 ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DUP ; + CONTRACT %approve (pair (address %spender) (nat %value)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + PAIR ; + TRANSFER_TOKENS } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DUP 2 ; + CONTRACT %add_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DUP 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } + { PUSH nat 108 ; FAILWITH } } ; + DUP 3 ; + CONTRACT %deposit + (pair (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + TRANSFER_TOKENS ; + DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; NONE operation } + { DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DIG 3 ; + CONTRACT %remove_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DIG 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS ; + SOME } + { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; PUSH nat 108 ; FAILWITH } } ; + IF_NONE { NIL operation } { NIL operation ; SWAP ; CONS } ; + SWAP ; + CONS ; + SWAP ; + CONS } ; + PAIR } } } } + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP 4 ; PUSH nat 151 ; FAILWITH } + { UNPAIR ; + CDR ; + DUP 4 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 6 ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + SWAP ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + DIG 3 ; + DUP 3 ; + PAIR 3 ; + DUP 9 ; + SWAP ; + EXEC ; + UNPAIR ; + DIG 3 ; + SWAP ; + PAIR ; + DUP 10 ; + SWAP ; + EXEC ; + DIG 2 ; + PAIR ; + PAIR } ; + DIG 6 ; + DIG 7 ; + DROP 2 ; + UNPAIR ; + CDR ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + DUP 5 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; DIG 3 ; DIG 6 ; DROP 5 ; PUSH nat 154 ; FAILWITH } + { DIG 3 ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + SUB ; + ABS ; + DIG 2 ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + PAIR } ; + UNPAIR ; + DUP 4 ; + CONTRACT unit ; + IF_NONE { PUSH nat 102 ; FAILWITH } { DUP 4 ; UNIT ; TRANSFER_TOKENS } ; + SELF_ADDRESS ; + NIL operation ; + DIG 4 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DROP ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; + CDR ; + DIG 8 ; + NONE (pair (pair address nat) mutez) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 7 ; DROP } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + PUSH mutez 0 ; + DIG 4 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; + PAIR } } } ; + view "get_native_token_of_vault" + unit + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + { CDR ; CDR ; CAR ; CAR ; CAR } ; + view "get_vault_balances" + unit + (pair (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (map string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)))) + { CDR ; DUP ; CAR ; CDR ; CAR ; SWAP ; CDR ; CAR ; CAR ; PAIR } } + diff --git a/batcher/michelson/eurl-vault-storage-ghostnet.tz b/batcher/michelson/eurl-vault-storage-ghostnet.tz new file mode 100644 index 00000000..d95d3442 --- /dev/null +++ b/batcher/michelson/eurl-vault-storage-ghostnet.tz @@ -0,0 +1,9 @@ +(Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + {} + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + (Pair (Pair (Pair 0 "EURL" (Some "KT1RcHjqDWWycYQGrz4KBYoGZSMmMuVpkmuS") 6 (Some "FA2 token")) 0) + "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx") + 0 + {} + {}) + diff --git a/batcher/michelson/marketmaker-ghostnet.tz b/batcher/michelson/marketmaker-ghostnet.tz new file mode 100644 index 00000000..f5bdb77f --- /dev/null +++ b/batcher/michelson/marketmaker-ghostnet.tz @@ -0,0 +1,1029 @@ +{ parameter + (or (or (or (pair %addVault string address) (address %change_admin_address)) + (or (address %change_batcher_address) (address %change_tokenmanager_address))) + (or (string %removeVault) (unit %tick))) ; + storage + (pair (pair (address %administrator) (address %batcher)) + (address %tokenmanager) + (pair %vaults (set %keys string) (big_map %values string address))) ; + code { LAMBDA + (pair int int) + int + { UNPAIR ; + SWAP ; + PUSH int 1 ; + PAIR ; + LEFT int ; + LOOP_LEFT + { UNPAIR ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { SWAP ; DROP ; RIGHT (pair int int) } + { PUSH int 1 ; DIG 2 ; SUB ; DUP 3 ; DIG 2 ; MUL ; PAIR ; LEFT int } } ; + SWAP ; + DROP } ; + SWAP ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DROP ; + IF_LEFT + { IF_LEFT + { UNPAIR ; + DUP 3 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + UNIT ; + VIEW "get_native_token_of_vault" + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) ; + IF_NONE { PUSH nat 164 ; FAILWITH } {} ; + DUP 2 ; + SWAP ; + GET 3 ; + COMPARE ; + EQ ; + NOT ; + IF { DROP 3 ; PUSH nat 163 ; FAILWITH } + { DUP 3 ; + CDR ; + CDR ; + DUP 4 ; + DIG 4 ; + CDR ; + DUP 3 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 5 ; SOME ; DIG 5 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 6 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 5 ; + DIG 5 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + PAIR } } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 1 ; + NIL operation ; + PAIR } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } } + { IF_LEFT + { DIG 2 ; + DROP ; + DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; DUP 2 ; GET ; IF_NONE { NONE address } { SOME } } + { DROP ; NONE address } ; + IF_NONE + { DROP 2 ; PUSH nat 163 ; FAILWITH } + { UNIT ; + VIEW "get_native_token_of_vault" + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) ; + IF_NONE { PUSH nat 164 ; FAILWITH } {} ; + DUP 2 ; + SWAP ; + GET 3 ; + COMPARE ; + EQ ; + NOT ; + IF { DROP 2 ; PUSH nat 163 ; FAILWITH } + { DUP 2 ; + DUP 3 ; + CDR ; + DIG 3 ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP ; CDR ; DIG 4 ; NONE address ; SWAP ; UPDATE ; UPDATE 2 } + { DIG 3 ; DROP } ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + PAIR } } } + { DROP ; + DUP ; + CAR ; + CDR ; + UNIT ; + VIEW "get_current_batches" + (list (pair (nat %batch_number) + (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)) + (pair %pair string string) + (nat %holdings) + (option %market_vault_used address))) ; + IF_NONE { PUSH nat 167 ; FAILWITH } {} ; + DUP 2 ; + CDR ; + CDR ; + DUP 3 ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_tokens" + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 162 ; FAILWITH } {} ; + DUP 4 ; + CDR ; + CAR ; + UNIT ; + VIEW "get_valid_swaps" + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) ; + IF_NONE { PUSH nat 165 ; FAILWITH } {} ; + NIL operation ; + DIG 4 ; + ITER { SWAP ; + DUP 2 ; + GET 7 ; + UNPAIR ; + PUSH nat 0 ; + DUP 5 ; + GET 5 ; + GET 7 ; + COMPARE ; + EQ ; + IF { NONE nat } { DUP 4 ; GET 5 ; GET 7 ; SOME } ; + PUSH nat 0 ; + DUP 6 ; + GET 5 ; + GET 14 ; + COMPARE ; + EQ ; + IF { DIG 4 ; DROP ; NONE nat } { DIG 4 ; GET 5 ; GET 14 ; SOME } ; + IF_NONE + { IF_NONE + { DROP 2 } + { DUP 7 ; + CAR ; + DUP 3 ; + MEM ; + NOT ; + IF { DROP 3 } + { DUP 7 ; + CAR ; + DUP 3 ; + MEM ; + IF { DUP 7 ; CDR ; DUP 3 ; GET ; IF_NONE { NONE address } { SOME } } + { NONE address } ; + IF_NONE { PUSH string "option is None" ; FAILWITH } {} ; + DUP 7 ; + DIG 3 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 138 ; FAILWITH } + { DUP 7 ; + DIG 4 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 138 ; FAILWITH } + { DIG 4 ; + DUP 2 ; + GET 3 ; + DUP 4 ; + GET 3 ; + DUP 8 ; + DUP 3 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } ; + GET ; + IF_NONE + { SWAP ; DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 117 ; FAILWITH } + { DUP ; + GET 3 ; + DUP 2 ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 122 ; FAILWITH } {} ; + UNPAIR ; + DUP 3 ; + CAR ; + DUP 11 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 12 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + PUSH nat 1 ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 4 ; + GET 7 ; + DUP ; + DUP 3 ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + GT ; + IF { DUP 2 ; + CAR ; + CAR ; + GET 7 ; + SUB ; + PUSH int 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + DIG 3 ; + MUL ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + CAR ; + GET 7 ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + SWAP } + { INT ; PUSH int 10 ; PAIR ; DUP 15 ; SWAP ; EXEC ; DIG 3 } ; + INT ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DIG 2 ; + SWAP ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 3 ; + DUP ; + CAR ; + DUP 10 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 11 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + GET 7 ; + SWAP ; + GET 7 ; + SUB ; + DUP ; + ABS ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 14 ; + SWAP ; + EXEC ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; PUSH int 1 ; PUSH int 1 } + { PUSH int 0 ; + DIG 2 ; + COMPARE ; + LT ; + IF { PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + PUSH int 1 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL } + { PUSH int 1 ; SWAP } } ; + PAIR ; + DUP 2 ; + GET 3 ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + UPDATE 3 ; + SWAP ; + CAR ; + CDR ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + IF { DIG 5 ; + INT ; + SWAP ; + GET 3 ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + UNIT ; + RIGHT unit } + { DIG 5 ; + INT ; + SWAP ; + GET 3 ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + UNIT ; + LEFT unit } ; + DIG 5 ; + CONTRACT %injectliquidity + (pair (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 5 ; + DIG 3 ; + PAIR ; + DIG 5 ; + DIG 4 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } ; + CONS } } } } } + { SWAP ; + IF_NONE + { DUP 7 ; + CAR ; + DUP 4 ; + MEM ; + NOT ; + IF { DROP 3 } + { DUP 7 ; + CAR ; + DUP 4 ; + MEM ; + IF { DUP 7 ; CDR ; DUP 4 ; GET ; IF_NONE { NONE address } { SOME } } + { NONE address } ; + IF_NONE { PUSH string "option is None" ; FAILWITH } {} ; + DUP 7 ; + DIG 4 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 138 ; FAILWITH } + { DUP 7 ; + DIG 4 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 138 ; FAILWITH } + { DIG 4 ; + DUP 2 ; + GET 3 ; + DUP 4 ; + GET 3 ; + DUP 8 ; + DUP 3 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } ; + GET ; + IF_NONE + { SWAP ; DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 117 ; FAILWITH } + { DUP ; + GET 3 ; + DUP 2 ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 122 ; FAILWITH } {} ; + UNPAIR ; + DUP 3 ; + CAR ; + DUP 11 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 12 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + PUSH nat 1 ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 4 ; + GET 7 ; + DUP ; + DUP 3 ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + GT ; + IF { DUP 2 ; + CAR ; + CAR ; + GET 7 ; + SUB ; + PUSH int 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + DIG 3 ; + MUL ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + CAR ; + GET 7 ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + SWAP } + { INT ; PUSH int 10 ; PAIR ; DUP 15 ; SWAP ; EXEC ; DIG 3 } ; + INT ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DIG 2 ; + SWAP ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 3 ; + DUP ; + CAR ; + DUP 10 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 11 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + GET 7 ; + SWAP ; + GET 7 ; + SUB ; + DUP ; + ABS ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 14 ; + SWAP ; + EXEC ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; PUSH int 1 ; PUSH int 1 } + { PUSH int 0 ; + DIG 2 ; + COMPARE ; + LT ; + IF { PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + PUSH int 1 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL } + { PUSH int 1 ; SWAP } } ; + PAIR ; + DUP 2 ; + GET 3 ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + UPDATE 3 ; + SWAP ; + CAR ; + CDR ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + IF { DIG 5 ; + INT ; + SWAP ; + GET 3 ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + UNIT ; + RIGHT unit } + { DIG 5 ; + INT ; + SWAP ; + GET 3 ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + UNIT ; + LEFT unit } ; + DIG 5 ; + CONTRACT %injectliquidity + (pair (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 5 ; + DIG 3 ; + PAIR ; + DIG 5 ; + DIG 4 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } ; + CONS } } } } + { DROP 4 } } } ; + SWAP ; + DIG 2 ; + DIG 3 ; + DIG 5 ; + DROP 4 ; + PAIR } } } } + diff --git a/batcher/michelson/marketmaker-storage-ghostnet.tz b/batcher/michelson/marketmaker-storage-ghostnet.tz new file mode 100644 index 00000000..9fd22888 --- /dev/null +++ b/batcher/michelson/marketmaker-storage-ghostnet.tz @@ -0,0 +1,5 @@ +(Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "KT1LhTpwSGcFAUUM3JYjW8XW74UHP82YzERy") + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" + {} + {}) + diff --git a/batcher/michelson/tokenmanager-ghostnet.tz b/batcher/michelson/tokenmanager-ghostnet.tz new file mode 100644 index 00000000..cab9569c --- /dev/null +++ b/batcher/michelson/tokenmanager-ghostnet.tz @@ -0,0 +1,1365 @@ +{ parameter + (or (or (or (pair %add_token_swap_pair + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits)) + (nat %amend_token_and_pair_limit)) + (or (address %change_admin_address) + (pair %change_oracle_source_of_pair + (string %pair_name) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision)))) + (or (or (string %disable_swap_pair_for_deposit) (string %enable_swap_pair_for_deposit)) + (pair %remove_token_swap_pair + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits)))) ; + storage + (pair (pair (address %administrator) (nat %limit_on_tokens_or_pairs)) + (pair %valid_swaps + (set %keys string) + (big_map %values + string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits)))) + (pair %valid_tokens + (set %keys string) + (big_map %values + string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))))) ; + code { UNPAIR ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + PUSH nat 6 ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 134 ; FAILWITH } + { PUSH nat 6 ; + DUP 2 ; + CAR ; + CDR ; + GET 7 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 134 ; FAILWITH } + { PUSH nat 6 ; + DUP 2 ; + GET 7 ; + COMPARE ; + NEQ ; + IF { DROP 2 ; PUSH nat 133 ; FAILWITH } + { DUP 2 ; + CDR ; + CDR ; + DUP 3 ; + CDR ; + CAR ; + DUP 3 ; + CAR ; + DUP ; + CAR ; + CAR ; + DUP 2 ; + CDR ; + DUP 7 ; + CAR ; + CDR ; + DUP ; + PUSH nat 1 ; + DUP 7 ; + CAR ; + SIZE ; + ADD ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 127 ; FAILWITH } + { EMPTY_MAP string (pair nat string (option address) nat (option string)) ; + DUP 7 ; + CAR ; + ITER { SWAP ; + DUP 8 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + EMPTY_MAP string (pair nat string (option address) nat (option string)) ; + DUP 8 ; + CAR ; + ITER { SWAP ; + DUP 9 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + AND ; + IF { PUSH nat 0 } + { EMPTY_MAP string (pair nat string (option address) nat (option string)) ; + DUP 7 ; + CAR ; + ITER { SWAP ; + DUP 8 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + EMPTY_MAP string (pair nat string (option address) nat (option string)) ; + DUP 8 ; + CAR ; + ITER { SWAP ; + DUP 9 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + OR ; + IF { PUSH nat 1 } { PUSH nat 2 } } ; + DUP 7 ; + CAR ; + SIZE ; + ADD ; + COMPARE ; + GT ; + IF { PUSH nat 126 ; FAILWITH } {} } ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + SWAP ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair string string) address string nat bool) } { SOME } } + { DROP ; NONE (pair (pair string string) address string nat bool) } ; + IF_NONE + { DUP 2 ; + GET 3 ; + DUP 5 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 5 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE + { DUP 2 ; + GET 3 ; + DUP 5 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 4 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DUP 6 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 5 ; + CDR ; + DIG 4 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { DIG 2 } { DIG 2 ; DROP ; PUSH nat 115 ; FAILWITH } } ; + DUP 2 ; + GET 3 ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE + { DUP 2 ; + GET 3 ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 3 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 3 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF {} { DROP ; PUSH nat 115 ; FAILWITH } } ; + DUP 3 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + SWAP ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + SWAP ; + DUP 4 ; + GET 8 ; + DUP 5 ; + GET 7 ; + DUP 6 ; + GET 5 ; + DUP 7 ; + GET 3 ; + DIG 7 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 5 ; + DUP 4 ; + CAR ; + DUP 4 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 2 ; SOME ; DIG 4 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DUP 5 ; + CAR ; + DUP 5 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 4 ; + CDR ; + DIG 2 ; + DIG 4 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + PAIR } + { DROP 6 ; PUSH nat 116 ; FAILWITH } ; + UNPAIR ; + DUP 3 ; + DIG 3 ; + CDR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CDR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + PAIR } } } } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CDR ; + CAR ; + SIZE ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 128 ; FAILWITH } + { DUP 2 ; + CDR ; + CAR ; + CAR ; + SIZE ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 129 ; FAILWITH } + { DUP 2 ; DIG 2 ; CAR ; DIG 2 ; UPDATE 2 ; UPDATE 1 ; NIL operation ; PAIR } } } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { SWAP ; + CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair string string) address string nat bool) } { SOME } } + { DROP 2 ; NONE (pair (pair string string) address string nat bool) } ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 3 ; + DUP 2 ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 123 ; FAILWITH } { DROP } ; + DUP 3 ; + DUP 4 ; + CDR ; + DIG 4 ; + CDR ; + CAR ; + DIG 3 ; + DUP 5 ; + GET 3 ; + UPDATE 3 ; + DUP 5 ; + GET 5 ; + UPDATE 5 ; + DUP 5 ; + GET 6 ; + UPDATE 7 ; + DIG 4 ; + CAR ; + DUP 3 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 3 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 3 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } } + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair string string) address string nat bool) } { SOME } } + { DROP ; NONE (pair (pair string string) address string nat bool) } ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP 3 ; + DUP 4 ; + CDR ; + DIG 4 ; + CDR ; + CAR ; + DIG 3 ; + PUSH bool True ; + UPDATE 8 ; + DUP 2 ; + CAR ; + DUP 6 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 2 ; SOME ; DIG 5 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 7 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 2 ; + DIG 5 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 1 ; + UPDATE 2 } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair string string) address string nat bool) } { SOME } } + { DROP ; NONE (pair (pair string string) address string nat bool) } ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP 3 ; + DUP 4 ; + CDR ; + DIG 4 ; + CDR ; + CAR ; + DIG 3 ; + PUSH bool False ; + UPDATE 8 ; + DUP 2 ; + CAR ; + DUP 6 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 2 ; SOME ; DIG 5 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 7 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 2 ; + DIG 5 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 1 ; + UPDATE 2 } } + { DUP 2 ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP ; + GET 8 ; + IF {} { PUSH nat 137 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + DUP 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + SWAP ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; + CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair string string) address string nat bool) } { SOME } } + { DROP ; NONE (pair (pair string string) address string nat bool) } ; + IF_NONE + { DROP 2 ; PUSH nat 117 ; FAILWITH } + { DROP ; + DUP 3 ; + CDR ; + CDR ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DUP ; + CAR ; + DUP 2 ; + CDR ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + DIG 4 ; + CDR ; + DIG 2 ; + NONE (pair (pair string string) address string nat bool) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DROP ; DIG 2 } ; + DUP 2 ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 2 ; + CDR ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + EMPTY_MAP string (pair (pair string string) address string nat bool) ; + DUP 4 ; + CAR ; + ITER { SWAP ; + DUP 5 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + CAR ; + DUP ; + CDR ; + DUP 7 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 7 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + CAR ; + DUP 7 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 7 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 2 ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 3 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR ; + OR } ; + IF { SWAP ; DROP ; DIG 2 } + { DUP 2 ; + GET 3 ; + DUP 5 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 5 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE + { SWAP ; DROP ; DIG 2 } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DUP 7 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { SWAP ; + GET 3 ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + DIG 4 ; + CDR ; + DIG 2 ; + NONE (pair nat string (option address) nat (option string)) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DROP ; DIG 2 } } + { SWAP ; DIG 3 ; DROP 2 ; PUSH nat 115 ; FAILWITH } } } ; + EMPTY_MAP string (pair (pair string string) address string nat bool) ; + DUP 4 ; + CAR ; + ITER { SWAP ; + DUP 5 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + PUSH bool False ; + SWAP ; + ITER { CDR ; + CAR ; + DUP ; + CDR ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 4 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 2 ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 3 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR ; + OR } ; + IF { SWAP ; DROP } + { DUP 2 ; + GET 3 ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; + CDR ; + SWAP ; + GET ; + IF_NONE + { NONE (pair nat string (option address) nat (option string)) } + { SOME } } + { DROP ; NONE (pair nat string (option address) nat (option string)) } ; + IF_NONE + { SWAP ; DROP } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DUP 7 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { SWAP ; + GET 3 ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; + DIG 2 ; + CDR ; + DIG 2 ; + NONE (pair nat string (option address) nat (option string)) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DROP } } + { DROP 2 ; PUSH nat 115 ; FAILWITH } } } ; + SWAP ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DIG 3 ; + CDR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CDR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 2 } ; + NIL operation ; + PAIR } } ; + view "get_valid_swaps" + unit + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) + { CDR ; + CDR ; + CAR ; + EMPTY_MAP string (pair (pair string string) address string nat bool) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP } ; + view "get_valid_tokens" + unit + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + { CDR ; + CDR ; + CDR ; + EMPTY_MAP string (pair nat string (option address) nat (option string)) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP } } + diff --git a/batcher/michelson/tokenmanager-storage-ghostnet.tz b/batcher/michelson/tokenmanager-storage-ghostnet.tz new file mode 100644 index 00000000..785317ed --- /dev/null +++ b/batcher/michelson/tokenmanager-storage-ghostnet.tz @@ -0,0 +1,22 @@ +(Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" 10) + (Pair { "BTCtz/USDT" ; "BTCtz/USDtz" ; "tzBTC/EURL" ; "tzBTC/USDT" ; "tzBTC/USDtz" } + { Elt "BTCtz/USDT" + (Pair (Pair "BTCtz" "USDT") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) ; + Elt "BTCtz/USDtz" + (Pair (Pair "BTCtz" "USDtz") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) ; + Elt "tzBTC/EURL" + (Pair (Pair "tzBTC" "EURL") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-EUR" 6 False) ; + Elt "tzBTC/USDT" + (Pair (Pair "tzBTC" "USDT") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) ; + Elt "tzBTC/USDtz" + (Pair (Pair "tzBTC" "USDtz") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) }) + { "BTCtz" ; "EURL" ; "USDT" ; "USDtz" ; "tzBTC" } + { Elt "BTCtz" + (Pair 0 "BTCtz" (Some "KT1ErLEYVsxqHxLgLucXViq5DYrtSyDuSFTe") 8 (Some "FA2 token")) ; + Elt "EURL" (Pair 0 "EURL" (Some "KT1RcHjqDWWycYQGrz4KBYoGZSMmMuVpkmuS") 6 (Some "FA2 token")) ; + Elt "USDT" (Pair 0 "USDT" (Some "KT1WNrZ7pEbpmYBGPib1e7UVCeC6GA6TkJYR") 6 (Some "FA2 token")) ; + Elt "USDtz" + (Pair 0 "USDtz" (Some "KT1B8tP5Q8Cb7HctLfxt4MVk2cWouHFrnbjW") 6 (Some "FA1.2 token")) ; + Elt "tzBTC" + (Pair 0 "tzBTC" (Some "KT1P8RdJ5MfHMK5phKJ5JsfNfask5v2b2NQS") 8 (Some "FA1.2 token")) }) + diff --git a/batcher/michelson/usdt-vault-ghostnet.tz b/batcher/michelson/usdt-vault-ghostnet.tz new file mode 100644 index 00000000..67557279 --- /dev/null +++ b/batcher/michelson/usdt-vault-ghostnet.tz @@ -0,0 +1,1136 @@ +{ parameter + (or (or (or (or (nat %addLiquidity) (mutez %addReward)) + (or (address %change_admin_address) (address %change_batcher_address))) + (or (or (address %change_marketmaker_address) (address %change_tokenmanager_address)) + (or (unit %claim) + (pair %injectLiquidity + (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)))))) + (unit %removeLiquidity)) ; + storage + (pair (pair (pair (address %administrator) (address %batcher)) + (map %foreign_tokens + string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount))) + (address %marketmaker)) + (pair (pair %native_token + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (address %tokenmanager)) + (nat %total_shares) + (pair %vault_holdings + (set %keys address) + (big_map %values + address + (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ; + code { LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + LAMBDA + (pair (lambda + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (pair (pair int int) + (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat)))) + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + { UNPAIR ; + SWAP ; + UNPAIR 3 ; + DUP 2 ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CDR ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 153 ; FAILWITH } + { DUP ; + DUP 3 ; + CDR ; + INT ; + SUB ; + ABS ; + DUP 3 ; + DIG 2 ; + UPDATE 2 ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + EQ ; + IF { DIG 4 ; DROP 2 ; DIG 2 } + { DIG 3 ; SWAP ; PAIR ; DIG 3 ; SWAP ; EXEC } ; + DUG 2 ; + UPDATE 2 ; + PAIR } } ; + DUP 2 ; + APPLY ; + DIG 2 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 3 ; + CDR ; + CAR ; + CAR ; + DIG 2 ; + UPDATE 2 ; + SELF_ADDRESS ; + DUP 2 ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + DIG 3 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 6 ; + CDR ; + DUP 7 ; + CAR ; + CAR ; + DIG 6 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 4 ; + CDR ; + CAR ; + CAR ; + DUP ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + NOT ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 115 ; FAILWITH } + { DUP 3 ; + CDR ; + DUP 6 ; + CDR ; + CDR ; + CAR ; + ADD ; + DUP 2 ; + DUP 5 ; + CDR ; + DIG 3 ; + CDR ; + ADD ; + UPDATE 2 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 7 ; + MEM ; + IF { CDR ; + DUP 6 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { PUSH mutez 0 ; DIG 4 ; CDR ; DUP 6 ; PAIR ; PAIR } + { DIG 4 ; + CDR ; + DUP 2 ; + CAR ; + CDR ; + ADD ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 1 } ; + DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 7 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP ; + DUP 2 ; + CAR ; + DUP 10 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + SWAP ; + CDR ; + DIG 5 ; + DIG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + DIG 2 ; + CONS } + { DUP 2 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 3 ; + CDR ; + CDR ; + CDR ; + EMPTY_MAP address (pair (pair address nat) mutez) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP ; + EMPTY_BIG_MAP address (pair (pair address nat) mutez) ; + EMPTY_SET address ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DUP 2 ; + CAR ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 6 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 5 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DUP 6 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH mutez 1 ; + MUL ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DUP 3 ; CDR ; ADD } { DROP ; DUP 2 ; CDR } ; + DIG 2 ; + SWAP ; + UPDATE 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 2 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 4 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 2 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } ; + SWAP ; + DIG 2 ; + DROP 2 ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation } ; + PAIR } + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } + { IF_LEFT + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP 2 ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP ; PUSH nat 155 ; FAILWITH } + { DUP ; + CDR ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP 3 ; PUSH nat 155 ; FAILWITH } + { SWAP ; + PUSH mutez 0 ; + UPDATE 2 ; + DUP ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP 6 ; + CAR ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 7 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 7 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } } } + { DUP 2 ; + CAR ; + CDR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 168 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + UNIT ; + LEFT unit ; + LEFT unit ; + IF_LEFT + { IF_LEFT { DROP ; PUSH nat 1 } { DROP ; PUSH nat 0 } } + { DROP ; PUSH nat 2 } ; + DUP 2 ; + CDR ; + CAR ; + IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } ; + NOW ; + DUP 4 ; + CDR ; + CDR ; + DUP 5 ; + CAR ; + CAR ; + DIG 5 ; + CAR ; + CDR ; + PAIR ; + PAIR ; + PAIR 4 ; + DUP 2 ; + CAR ; + CAR ; + CDR ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 5 ; + IF_NONE + { DROP 2 ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DUP ; + CONTRACT %approve (pair (address %spender) (nat %value)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + PAIR ; + TRANSFER_TOKENS } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DUP 2 ; + CONTRACT %add_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DUP 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } + { PUSH nat 108 ; FAILWITH } } ; + DUP 3 ; + CONTRACT %deposit + (pair (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + TRANSFER_TOKENS ; + DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; NONE operation } + { DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DIG 3 ; + CONTRACT %remove_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DIG 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS ; + SOME } + { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; PUSH nat 108 ; FAILWITH } } ; + IF_NONE { NIL operation } { NIL operation ; SWAP ; CONS } ; + SWAP ; + CONS ; + SWAP ; + CONS } ; + PAIR } } } } + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP 4 ; PUSH nat 151 ; FAILWITH } + { UNPAIR ; + CDR ; + DUP 4 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 6 ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + SWAP ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + DIG 3 ; + DUP 3 ; + PAIR 3 ; + DUP 9 ; + SWAP ; + EXEC ; + UNPAIR ; + DIG 3 ; + SWAP ; + PAIR ; + DUP 10 ; + SWAP ; + EXEC ; + DIG 2 ; + PAIR ; + PAIR } ; + DIG 6 ; + DIG 7 ; + DROP 2 ; + UNPAIR ; + CDR ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + DUP 5 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; DIG 3 ; DIG 6 ; DROP 5 ; PUSH nat 154 ; FAILWITH } + { DIG 3 ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + SUB ; + ABS ; + DIG 2 ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + PAIR } ; + UNPAIR ; + DUP 4 ; + CONTRACT unit ; + IF_NONE { PUSH nat 102 ; FAILWITH } { DUP 4 ; UNIT ; TRANSFER_TOKENS } ; + SELF_ADDRESS ; + NIL operation ; + DIG 4 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DROP ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; + CDR ; + DIG 8 ; + NONE (pair (pair address nat) mutez) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 7 ; DROP } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + PUSH mutez 0 ; + DIG 4 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; + PAIR } } } ; + view "get_native_token_of_vault" + unit + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + { CDR ; CDR ; CAR ; CAR ; CAR } ; + view "get_vault_balances" + unit + (pair (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (map string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)))) + { CDR ; DUP ; CAR ; CDR ; CAR ; SWAP ; CDR ; CAR ; CAR ; PAIR } } + diff --git a/batcher/michelson/usdt-vault-storage-ghostnet.tz b/batcher/michelson/usdt-vault-storage-ghostnet.tz new file mode 100644 index 00000000..c887865c --- /dev/null +++ b/batcher/michelson/usdt-vault-storage-ghostnet.tz @@ -0,0 +1,9 @@ +(Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + {} + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + (Pair (Pair (Pair 0 "USDT" (Some "KT1WNrZ7pEbpmYBGPib1e7UVCeC6GA6TkJYR") 6 (Some "FA2 token")) 0) + "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx") + 0 + {} + {}) + diff --git a/batcher/michelson/usdtz-vault-ghostnet.tz b/batcher/michelson/usdtz-vault-ghostnet.tz new file mode 100644 index 00000000..67557279 --- /dev/null +++ b/batcher/michelson/usdtz-vault-ghostnet.tz @@ -0,0 +1,1136 @@ +{ parameter + (or (or (or (or (nat %addLiquidity) (mutez %addReward)) + (or (address %change_admin_address) (address %change_batcher_address))) + (or (or (address %change_marketmaker_address) (address %change_tokenmanager_address)) + (or (unit %claim) + (pair %injectLiquidity + (pair (nat %amount) + (pair %from_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (or %side (unit %buy) (unit %sell)) + (pair %to_token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)))))) + (unit %removeLiquidity)) ; + storage + (pair (pair (pair (address %administrator) (address %batcher)) + (map %foreign_tokens + string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount))) + (address %marketmaker)) + (pair (pair %native_token + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (address %tokenmanager)) + (nat %total_shares) + (pair %vault_holdings + (set %keys address) + (big_map %values + address + (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ; + code { LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + LAMBDA + (pair (lambda + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (pair (pair int int) + (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat)))) + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + { UNPAIR ; + SWAP ; + UNPAIR 3 ; + DUP 2 ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CDR ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 153 ; FAILWITH } + { DUP ; + DUP 3 ; + CDR ; + INT ; + SUB ; + ABS ; + DUP 3 ; + DIG 2 ; + UPDATE 2 ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + EQ ; + IF { DIG 4 ; DROP 2 ; DIG 2 } + { DIG 3 ; SWAP ; PAIR ; DIG 3 ; SWAP ; EXEC } ; + DUG 2 ; + UPDATE 2 ; + PAIR } } ; + DUP 2 ; + APPLY ; + DIG 2 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 3 ; + CDR ; + CAR ; + CAR ; + DIG 2 ; + UPDATE 2 ; + SELF_ADDRESS ; + DUP 2 ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + DIG 3 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 6 ; + CDR ; + DUP 7 ; + CAR ; + CAR ; + DIG 6 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 4 ; + CDR ; + CAR ; + CAR ; + DUP ; + CAR ; + DUP 4 ; + CAR ; + DUP 2 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + NOT ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 4 ; PUSH nat 115 ; FAILWITH } + { DUP 3 ; + CDR ; + DUP 6 ; + CDR ; + CDR ; + CAR ; + ADD ; + DUP 2 ; + DUP 5 ; + CDR ; + DIG 3 ; + CDR ; + ADD ; + UPDATE 2 ; + DUP 6 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 7 ; + MEM ; + IF { CDR ; + DUP 6 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { PUSH mutez 0 ; DIG 4 ; CDR ; DUP 6 ; PAIR ; PAIR } + { DIG 4 ; + CDR ; + DUP 2 ; + CAR ; + CDR ; + ADD ; + DUP 2 ; + DIG 2 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 1 } ; + DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 7 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP ; + DUP 2 ; + CAR ; + DUP 10 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + SWAP ; + CDR ; + DIG 5 ; + DIG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + DIG 2 ; + CONS } + { DUP 2 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 3 ; + CDR ; + CDR ; + CDR ; + EMPTY_MAP address (pair (pair address nat) mutez) ; + DUP 2 ; + CAR ; + ITER { SWAP ; + DUP 3 ; + CDR ; + DUP 3 ; + GET ; + IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; + SWAP ; + DROP ; + EMPTY_BIG_MAP address (pair (pair address nat) mutez) ; + EMPTY_SET address ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DUP 2 ; + CAR ; + CDR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 6 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 5 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DUP 6 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 1 ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH mutez 1 ; + MUL ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DUP 3 ; CDR ; ADD } { DROP ; DUP 2 ; CDR } ; + DIG 2 ; + SWAP ; + UPDATE 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + MEM ; + IF { DUP 3 ; DIG 3 ; CDR ; DIG 2 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 3 ; + DUP 4 ; + CAR ; + DUP 4 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 3 ; + CDR ; + DIG 2 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } } ; + SWAP ; + DIG 2 ; + DROP 2 ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation } ; + PAIR } + { IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CDR ; + DUP ; + CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } + { IF_LEFT + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + SWAP ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP 2 ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP ; PUSH nat 155 ; FAILWITH } + { DUP ; + CDR ; + PUSH mutez 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP 3 ; PUSH nat 155 ; FAILWITH } + { SWAP ; + PUSH mutez 0 ; + UPDATE 2 ; + DUP ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP 6 ; + CAR ; + CAR ; + DUP 2 ; + CAR ; + DUP 2 ; + MEM ; + IF { DUP 2 ; DIG 2 ; CDR ; DIG 7 ; SOME ; DIG 3 ; UPDATE ; UPDATE 2 } + { DUP 2 ; + DUP 3 ; + CAR ; + DUP 3 ; + PUSH bool True ; + SWAP ; + UPDATE ; + UPDATE 1 ; + DIG 2 ; + CDR ; + DIG 7 ; + DIG 3 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } } } + { DUP 2 ; + CAR ; + CDR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 168 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + UNIT ; + LEFT unit ; + LEFT unit ; + IF_LEFT + { IF_LEFT { DROP ; PUSH nat 1 } { DROP ; PUSH nat 0 } } + { DROP ; PUSH nat 2 } ; + DUP 2 ; + CDR ; + CAR ; + IF_LEFT { DROP ; PUSH nat 0 } { DROP ; PUSH nat 1 } ; + NOW ; + DUP 4 ; + CDR ; + CDR ; + DUP 5 ; + CAR ; + CAR ; + DIG 5 ; + CAR ; + CDR ; + PAIR ; + PAIR ; + PAIR 4 ; + DUP 2 ; + CAR ; + CAR ; + CDR ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 5 ; + IF_NONE + { DROP 2 ; PUSH nat 109 ; FAILWITH } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DUP ; + CONTRACT %approve (pair (address %spender) (nat %value)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + PAIR ; + TRANSFER_TOKENS } + { DUP 3 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DUP 2 ; + CONTRACT %add_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DUP 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS } + { PUSH nat 108 ; FAILWITH } } ; + DUP 3 ; + CONTRACT %deposit + (pair (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DUP 6 ; + TRANSFER_TOKENS ; + DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA1.2 token" ; SWAP ; COMPARE ; EQ } ; + IF { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; NONE operation } + { DUP 5 ; + CAR ; + CAR ; + CAR ; + GET 8 ; + IF_NONE + { PUSH bool False } + { PUSH string "FA2 token" ; SWAP ; COMPARE ; EQ } ; + IF { SELF_ADDRESS ; + DIG 3 ; + CONTRACT %remove_operator + (pair (pair (address %operator) (address %owner)) (nat %token_id)) ; + IF_NONE { PUSH nat 157 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 6 ; + CAR ; + CAR ; + CAR ; + CAR ; + DIG 3 ; + DIG 6 ; + PAIR ; + PAIR ; + TRANSFER_TOKENS ; + SOME } + { DIG 2 ; DIG 3 ; DIG 4 ; DROP 3 ; PUSH nat 108 ; FAILWITH } } ; + IF_NONE { NIL operation } { NIL operation ; SWAP ; CONS } ; + SWAP ; + CONS ; + SWAP ; + CONS } ; + PAIR } } } } + { DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 3 ; + MEM ; + IF { CDR ; + DUP 2 ; + GET ; + IF_NONE { NONE (pair (pair address nat) mutez) } { SOME } } + { DROP ; NONE (pair (pair address nat) mutez) } ; + IF_NONE + { DROP 4 ; PUSH nat 151 ; FAILWITH } + { UNPAIR ; + CDR ; + DUP 4 ; + CDR ; + CDR ; + CAR ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 6 ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + SWAP ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + DIG 3 ; + DUP 3 ; + PAIR 3 ; + DUP 9 ; + SWAP ; + EXEC ; + UNPAIR ; + DIG 3 ; + SWAP ; + PAIR ; + DUP 10 ; + SWAP ; + EXEC ; + DIG 2 ; + PAIR ; + PAIR } ; + DIG 6 ; + DIG 7 ; + DROP 2 ; + UNPAIR ; + CDR ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + DUP 5 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; DIG 3 ; DIG 6 ; DROP 5 ; PUSH nat 154 ; FAILWITH } + { DIG 3 ; + DUP 7 ; + CDR ; + CDR ; + CAR ; + SUB ; + ABS ; + DIG 2 ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + PAIR } ; + UNPAIR ; + DUP 4 ; + CONTRACT unit ; + IF_NONE { PUSH nat 102 ; FAILWITH } { DUP 4 ; UNIT ; TRANSFER_TOKENS } ; + SELF_ADDRESS ; + NIL operation ; + DIG 4 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DROP ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CDR ; + DIG 5 ; + CDR ; + CDR ; + CDR ; + DUP ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP ; + CDR ; + DIG 8 ; + NONE (pair (pair address nat) mutez) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 7 ; DROP } ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + PUSH mutez 0 ; + DIG 4 ; + COMPARE ; + GT ; + IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; + PAIR } } } ; + view "get_native_token_of_vault" + unit + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + { CDR ; CDR ; CAR ; CAR ; CAR } ; + view "get_vault_balances" + unit + (pair (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (map string + (pair (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)))) + { CDR ; DUP ; CAR ; CDR ; CAR ; SWAP ; CDR ; CAR ; CAR ; PAIR } } + diff --git a/batcher/michelson/usdtz-vault-storage-ghostnet.tz b/batcher/michelson/usdtz-vault-storage-ghostnet.tz new file mode 100644 index 00000000..9529ad7e --- /dev/null +++ b/batcher/michelson/usdtz-vault-storage-ghostnet.tz @@ -0,0 +1,10 @@ +(Pair (Pair (Pair "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + {} + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + (Pair (Pair (Pair 0 "USDtz" (Some "KT1B8tP5Q8Cb7HctLfxt4MVk2cWouHFrnbjW") 6 (Some "FA1.2 token")) + 0) + "KT1SG9z3pU1cNh8dSranm5C5HXWphWi2pLwx") + 0 + {} + {}) +