diff --git a/batcher/michelson/btctz-vault-ghostnet.tz b/batcher/michelson/btctz-vault-ghostnet.tz new file mode 100644 index 00000000..a55a37cd --- /dev/null +++ b/batcher/michelson/btctz-vault-ghostnet.tz @@ -0,0 +1,1117 @@ +{ 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 { EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + 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 3 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DIG 4 ; + DROP 3 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CDR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DUP 4 ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DIG 4 ; + 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 mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + 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 ; + DUP 7 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DUP 6 ; + 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 } {} ; + 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 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + CAR ; + DUP 5 ; + DIG 5 ; + CDR ; + DUP ; + CDR ; + DUP 5 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 7 ; SOME ; DIG 6 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DIG 5 ; + CDR ; + DIG 7 ; + DIG 6 ; + 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 5 ; 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 ; + DUP 8 ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + DIG 9 ; + 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..8658b0fd --- /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) + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + 0 + {} + {}) + diff --git a/batcher/michelson/eurl-vault-ghostnet.tz b/batcher/michelson/eurl-vault-ghostnet.tz new file mode 100644 index 00000000..a55a37cd --- /dev/null +++ b/batcher/michelson/eurl-vault-ghostnet.tz @@ -0,0 +1,1117 @@ +{ 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 { EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + 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 3 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DIG 4 ; + DROP 3 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CDR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DUP 4 ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DIG 4 ; + 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 mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + 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 ; + DUP 7 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DUP 6 ; + 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 } {} ; + 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 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + CAR ; + DUP 5 ; + DIG 5 ; + CDR ; + DUP ; + CDR ; + DUP 5 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 7 ; SOME ; DIG 6 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DIG 5 ; + CDR ; + DIG 7 ; + DIG 6 ; + 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 5 ; 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 ; + DUP 8 ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + DIG 9 ; + 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..2aef0215 --- /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) + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + 0 + {} + {}) + diff --git a/batcher/michelson/tzbtc-vault-ghostnet.tz b/batcher/michelson/tzbtc-vault-ghostnet.tz index 859e6e0c..a55a37cd 100644 --- a/batcher/michelson/tzbtc-vault-ghostnet.tz +++ b/batcher/michelson/tzbtc-vault-ghostnet.tz @@ -1,23 +1,24 @@ { parameter - (or (or (or (nat %addLiquidity) (address %change_admin_address)) - (or (address %change_batcher_address) (address %change_marketmaker_address))) - (or (or (address %change_tokenmanager_address) (unit %claim)) - (or (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)))) ; + (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 @@ -40,9 +41,11 @@ (nat %amount)) (address %tokenmanager)) (nat %total_shares) - (big_map %vault_holdings - address - (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed)))) ; + (pair %vault_holdings + (set %keys address) + (big_map %values + address + (pair (pair (address %holder) (nat %shares)) (mutez %unclaimed))))) ; code { EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; LAMBDA (pair (pair (pair nat string (option address) nat (option string)) nat) @@ -193,705 +196,898 @@ DROP 3 ; 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 ; + { IF_LEFT + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 3 ; + CDR ; CAR ; - GET 8 ; + CAR ; + DIG 2 ; + UPDATE 2 ; + SELF_ADDRESS ; + DUP 2 ; + CAR ; + GET 5 ; 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 6 ; - GET ; - 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 ; - DIG 4 ; - DIG 7 ; - SWAP ; - SOME ; - SWAP ; - UPDATE ; - 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 ; - 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 ; - 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 2 ; - 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 ; - CDR ; - DIG 3 ; - UPDATE 2 ; - UPDATE 2 ; - UPDATE 1 } ; - NIL operation } ; - PAIR } - { IF_LEFT - { DIG 2 ; - DIG 3 ; - DIG 4 ; - DROP 3 ; - 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 ; - CDR ; - DUP ; - CAR ; - DIG 3 ; - UPDATE 2 ; - UPDATE 1 ; - UPDATE 2 ; - NIL operation ; - PAIR } - { DROP ; - PUSH mutez 1 ; - AMOUNT ; - COMPARE ; - LT ; - IF {} { PUSH nat 118 ; FAILWITH } ; - SENDER ; - DUP 2 ; - CDR ; - CDR ; - CDR ; - SWAP ; - GET ; - IF_NONE - { DROP ; PUSH nat 155 ; FAILWITH } - { DUP ; + { 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 ; - PUSH mutez 0 ; + 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 ; - IF { DROP 3 ; PUSH nat 155 ; FAILWITH } - { SWAP ; - PUSH mutez 0 ; + 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 ; - CAR ; - CONTRACT unit ; + 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 - { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } - { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; - DUP 3 ; - DUP 4 ; + { 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 ; CDR ; - DUP ; CDR ; - DIG 5 ; CDR ; + DUP 7 ; + DIG 7 ; CDR ; + DUP ; CDR ; - DUP 6 ; - SOME ; DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DUP 4 ; CAR ; - CAR ; - UPDATE ; + DUP 9 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DIG 4 ; + CDR ; + DIG 5 ; + DIG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + UPDATE 2 } ; UPDATE 2 ; UPDATE 2 ; UPDATE 2 ; - NIL operation ; - DIG 2 ; - CONS ; - PAIR } } } } - { IF_LEFT - { DIG 2 ; - DIG 3 ; - DIG 4 ; - DROP 3 ; - 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 ; + DUP ; CDR ; - DUP 5 ; - PAIR ; - TRANSFER_TOKENS } - { DUP 3 ; - CAR ; - CAR ; + DUP ; 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 ; + DIG 3 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + DIG 2 ; + CONS } + { DUP 2 ; + CDR ; + CDR ; CAR ; + INT ; + PUSH mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; 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 2 ; - GET ; - IF_NONE - { DROP 5 ; PUSH nat 151 ; FAILWITH } - { UNPAIR ; + INT ; + DUP 3 ; CDR ; - DUP 4 ; CDR ; CDR ; + EMPTY_MAP address (pair (pair address nat) mutez) ; + DUP 2 ; CAR ; - INT ; - PUSH int 1 ; + 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 ; - DUP 2 ; - INT ; - PUSH int 1 ; SWAP ; - PAIR ; + ITER { UNPAIR ; + DUP 2 ; + CAR ; + CDR ; + INT ; + PUSH int 1 ; + DUP 7 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DUP 6 ; + 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 } {} ; + 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 ; + 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 ; - CDR ; - MUL ; DIG 2 ; - CDR ; + 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 ; - MUL ; - PAIR ; - DUP 8 ; - DUP 6 ; - CDR ; + DUP ; CAR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation } ; + PAIR } + { IF_LEFT + { IF_LEFT + { DUP 2 ; CAR ; - DUP 3 ; - PAIR 3 ; - DUP 7 ; - SWAP ; - EXEC ; - UNPAIR ; - SWAP ; - DIG 9 ; + 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 ; - PAIR ; - PAIR ; - DUP 6 ; + 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 ; - 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 ; + 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 ; - DUP 7 ; CDR ; CDR ; + DUP ; 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 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + CAR ; + DUP 5 ; + DIG 5 ; + CDR ; + DUP ; + CDR ; + DUP 5 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 7 ; SOME ; DIG 6 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DIG 5 ; + CDR ; + DIG 7 ; + DIG 6 ; + 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 ; - DUP ; CDR ; + DUP 5 ; + CAR ; + CAR ; DIG 5 ; + CAR ; CDR ; + PAIR ; + PAIR ; + PAIR 4 ; + DUP 2 ; + CAR ; + CAR ; CDR ; - CDR ; - DIG 7 ; - NONE (pair (pair address nat) mutez) ; - SWAP ; - UPDATE ; - UPDATE 2 ; - UPDATE 2 ; - UPDATE 2 ; - PUSH mutez 0 ; - DIG 4 ; - COMPARE ; - GT ; - IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; - PAIR } } } } } ; + 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 5 ; 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 ; + DUP 8 ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + DIG 9 ; + 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) diff --git a/batcher/michelson/tzbtc-vault-storage-ghostnet.tz b/batcher/michelson/tzbtc-vault-storage-ghostnet.tz index 9d526f2c..f57f6c99 100644 --- a/batcher/michelson/tzbtc-vault-storage-ghostnet.tz +++ b/batcher/michelson/tzbtc-vault-storage-ghostnet.tz @@ -5,5 +5,6 @@ 0) "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") 0 + {} {}) diff --git a/batcher/michelson/usdt-vault-ghostnet.tz b/batcher/michelson/usdt-vault-ghostnet.tz new file mode 100644 index 00000000..a55a37cd --- /dev/null +++ b/batcher/michelson/usdt-vault-ghostnet.tz @@ -0,0 +1,1117 @@ +{ 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 { EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + 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 3 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DIG 4 ; + DROP 3 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CDR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DUP 4 ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DIG 4 ; + 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 mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + 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 ; + DUP 7 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DUP 6 ; + 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 } {} ; + 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 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + CAR ; + DUP 5 ; + DIG 5 ; + CDR ; + DUP ; + CDR ; + DUP 5 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 7 ; SOME ; DIG 6 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DIG 5 ; + CDR ; + DIG 7 ; + DIG 6 ; + 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 5 ; 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 ; + DUP 8 ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + DIG 9 ; + 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..36610cab --- /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) + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + 0 + {} + {}) + diff --git a/batcher/michelson/usdtz-vault-ghostnet.tz b/batcher/michelson/usdtz-vault-ghostnet.tz new file mode 100644 index 00000000..a55a37cd --- /dev/null +++ b/batcher/michelson/usdtz-vault-ghostnet.tz @@ -0,0 +1,1117 @@ +{ 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 { EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + 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 3 ; + UNPAIR ; + IF_LEFT + { DIG 2 ; + DIG 3 ; + DIG 4 ; + DROP 3 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP ; + CDR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + DUP ; + CDR ; + DUP ; + CDR ; + DUP 4 ; + CAR ; + DUP 9 ; + MEM ; + IF { DUP 4 ; DIG 4 ; CDR ; DIG 5 ; SOME ; DIG 8 ; UPDATE ; UPDATE 2 } + { DUP 4 ; + DIG 4 ; + 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 mutez 1 ; + DIG 2 ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + INT ; + 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 ; + DUP 7 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DUP 6 ; + 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 } {} ; + 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 ; + 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 ; + CDR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + CAR ; + DUP 5 ; + DIG 5 ; + CDR ; + DUP ; + CDR ; + DUP 5 ; + CAR ; + DUP 5 ; + MEM ; + IF { DUP 5 ; DIG 5 ; CDR ; DIG 7 ; SOME ; DIG 6 ; UPDATE ; UPDATE 2 } + { DUP 5 ; + DIG 5 ; + CDR ; + DIG 7 ; + DIG 6 ; + 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 5 ; 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 ; + DUP 8 ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + DUP 3 ; + PAIR 3 ; + DUP 7 ; + SWAP ; + EXEC ; + UNPAIR ; + SWAP ; + DIG 9 ; + 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..45acf78a --- /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) + "tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL") + 0 + {} + {}) + diff --git a/batcher/storage/btctz_vault_storage_ghostnet.mligo b/batcher/storage/btctz_vault_storage_ghostnet.mligo index 7be799d0..540b4f8c 100644 --- a/batcher/storage/btctz_vault_storage_ghostnet.mligo +++ b/batcher/storage/btctz_vault_storage_ghostnet.mligo @@ -1,4 +1,5 @@ #import "../vault.mligo" "Vault" +#import "../types.mligo" "Types" let f(_:unit) : Vault.Vault.storage = { administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); @@ -16,6 +17,6 @@ let f(_:unit) : Vault.Vault.storage = { amount = 0n; }; foreign_tokens = (Map.empty:(string, Vault.token_amount) map ); - vault_holdings = (Big_map.empty: (address, Vault.vault_holding) big_map); + vault_holdings = Types.VaultHoldings.empty ; } diff --git a/batcher/storage/eurl_vault_storage_ghostnet.mligo b/batcher/storage/eurl_vault_storage_ghostnet.mligo index 9cb219ae..e055177a 100644 --- a/batcher/storage/eurl_vault_storage_ghostnet.mligo +++ b/batcher/storage/eurl_vault_storage_ghostnet.mligo @@ -1,4 +1,5 @@ #import "../vault.mligo" "Vault" +#import "../types.mligo" "Types" let f(_:unit) : Vault.Vault.storage = { administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); @@ -16,6 +17,6 @@ let f(_:unit) : Vault.Vault.storage = { amount = 0n; }; foreign_tokens = (Map.empty:(string, Vault.token_amount) map ); - vault_holdings = (Big_map.empty: (address, Vault.vault_holding) big_map); + vault_holdings = Types.VaultHoldings.empty ; } diff --git a/batcher/storage/tzbtc_vault_storage_ghostnet.mligo b/batcher/storage/tzbtc_vault_storage_ghostnet.mligo index c7116424..0669b8e2 100644 --- a/batcher/storage/tzbtc_vault_storage_ghostnet.mligo +++ b/batcher/storage/tzbtc_vault_storage_ghostnet.mligo @@ -1,4 +1,5 @@ #import "../vault.mligo" "Vault" +#import "../types.mligo" "Types" let f(_:unit) : Vault.Vault.storage = { administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); @@ -16,6 +17,6 @@ let f(_:unit) : Vault.Vault.storage = { amount = 0n; }; foreign_tokens = (Map.empty:(string, Vault.token_amount) map ); - vault_holdings = (Big_map.empty: (address, Vault.vault_holding) big_map); + vault_holdings = Types.VaultHoldings.empty ; } diff --git a/batcher/storage/usdt_vault_storage_ghostnet.mligo b/batcher/storage/usdt_vault_storage_ghostnet.mligo index 01360a33..53064cbc 100644 --- a/batcher/storage/usdt_vault_storage_ghostnet.mligo +++ b/batcher/storage/usdt_vault_storage_ghostnet.mligo @@ -1,4 +1,5 @@ #import "../vault.mligo" "Vault" +#import "../types.mligo" "Types" let f(_:unit) : Vault.Vault.storage = { administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); @@ -16,6 +17,6 @@ let f(_:unit) : Vault.Vault.storage = { amount = 0n; }; foreign_tokens = (Map.empty:(string, Vault.token_amount) map ); - vault_holdings = (Big_map.empty: (address, Vault.vault_holding) big_map); + vault_holdings = Types.VaultHoldings.empty ; } diff --git a/batcher/storage/usdtz_vault_storage_ghostnet.mligo b/batcher/storage/usdtz_vault_storage_ghostnet.mligo index 9a094c88..625e4739 100644 --- a/batcher/storage/usdtz_vault_storage_ghostnet.mligo +++ b/batcher/storage/usdtz_vault_storage_ghostnet.mligo @@ -1,4 +1,5 @@ #import "../vault.mligo" "Vault" +#import "../types.mligo" "Types" let f(_:unit) : Vault.Vault.storage = { administrator = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); batcher = ("tz1ca4batAsNxMYab3mUK5H4QRjY8drV4ViL" : address); @@ -16,6 +17,6 @@ let f(_:unit) : Vault.Vault.storage = { amount = 0n; }; foreign_tokens = (Map.empty:(string, Vault.token_amount) map ); - vault_holdings = (Big_map.empty: (address, Vault.vault_holding) big_map); + vault_holdings = Types.VaultHoldings.empty ; } diff --git a/batcher/types.mligo b/batcher/types.mligo index 92b1951f..b1e4a3e2 100644 --- a/batcher/types.mligo +++ b/batcher/types.mligo @@ -417,8 +417,104 @@ type vault_holding = { unclaimed: tez; } -type vault_holdings = (address, vault_holding) big_map +module VaultHoldings = struct + + type key = address + type value = vault_holding + +type t = { + keys: key set; + values: (key, value) big_map +} + +type t_map = (key,value) map + +[@inline] +let empty:t = { + keys = Set.empty; + values = Big_map.empty; +} + +[@inline] +let size (object:t) : nat = Set.size object.keys + + +[@inline] +let mem (key:key) (object:t): bool = Set.mem key object.keys + +[@inline] +let find_opt (key:key) (object:t): value option = + if Set.mem key object.keys then + match Big_map.find_opt key object.values with + | None -> (None:value option) + | Some v -> (Some v) + else + (None: value option) + +[@inline] +let find_or_fail (key:key) (object:t): value = + match find_opt key object with + | None -> failwith token_name_not_in_list_of_valid_tokens + | Some v -> v + +[@inline] +let upsert (key:key) (value:value) (object:t): t = + if Set.mem key object.keys then + let values = Big_map.update key (Some value) object.values in + {object with values = values;} + else + let values = Big_map.add key value object.values in + {object with values = values;} + +[@inline] +let remove (key:key) (object:t): t = + if Set.mem key object.keys then + let values = Big_map.remove key object.values in + {object with values = values;} + else + object + +[@inline] +let get_and_remove + (key:key) + (object:t): (value option * t) = + if Set.mem key object.keys then + let v_opt = Big_map.find_opt key object.values in + let values = Big_map.remove key object.values in + v_opt, {object with values = values;} + else + None, object + +[@inline] +let to_map + (object:t) : (key,value) map = + let collect_from_bm ((acc, k) : ((key,value) map) * key) : (key,value) map = + match Big_map.find_opt k object.values with + | None -> acc + | Some v -> Map.add k v acc + in + Set.fold collect_from_bm object.keys (Map.empty: (key, value) map) + + +[@inline] +let fold + (type a) + (folder: (a * (key * value)) -> a) + (object:t) + (seed: a): a = + let mp = to_map object in + Map.fold folder mp seed + + +[@inline] +let mem_map + (to_find:value) + (m: (key, value) map) : bool = + let find (found, (_k,v): (bool * (key * value))) : bool = if found then found else to_find = v in + Map.fold find m false + +end module Vaults = struct diff --git a/batcher/vault.mligo b/batcher/vault.mligo index b5d72bbf..989e3e75 100644 --- a/batcher/vault.mligo +++ b/batcher/vault.mligo @@ -14,7 +14,7 @@ type storage = { batcher : address; marketmaker : address; tokenmanager : address; - vault_holdings: vault_holdings; + vault_holdings: VaultHoldings.t; } type result = operation list * storage @@ -73,7 +73,7 @@ let add_or_update_liquidity if not are_equivalent_tokens token_amount.token nt.token then failwith token_already_exists_but_details_are_different else let shares = storage.total_shares + token_amount.amount in let native_token = { nt with amount = nt.amount + token_amount.amount; } in - let new_holding = match Big_map.find_opt holder storage.vault_holdings with + let new_holding = match VaultHoldings.find_opt holder storage.vault_holdings with | None -> { holder = holder; shares = token_amount.amount; @@ -82,7 +82,7 @@ let add_or_update_liquidity | Some ph -> let nshares = ph.shares + token_amount.amount in { ph with shares = nshares;} in - let vhs = Big_map.add holder new_holding storage.vault_holdings in + let vhs = VaultHoldings.upsert holder new_holding storage.vault_holdings in { storage with total_shares = shares ; vault_holdings = vhs; @@ -123,7 +123,7 @@ let collect_tokens_for_redemption let remove_liquidity_from_market_maker (holder: address) (storage: storage): ( operation list * storage) = - match Big_map.find_opt holder storage.vault_holdings with + match VaultHoldings.find_opt holder storage.vault_holdings with | None -> failwith no_holding_in_market_maker_for_holder | Some holding -> let unclaimed_tez = holding.unclaimed in let shares = holding.shares in @@ -133,7 +133,7 @@ let remove_liquidity_from_market_maker let tez_op = Treasury_Utils.transfer_fee holder unclaimed_tez in let treasury_vault = get_vault () in let tok_ops = Treasury_Utils.transfer_holdings treasury_vault holder tam in - let vault_holdings = Big_map.remove holder storage.vault_holdings in + let vault_holdings = VaultHoldings.remove holder storage.vault_holdings in let ops: operation list =if unclaimed_tez > 0mutez then tez_op :: tok_ops else tok_ops in let storage = { storage with vault_holdings = vault_holdings; } in (ops, storage) @@ -145,14 +145,14 @@ let claim_from_holding if unclaimed_tez = 0mutez then failwith no_holdings_to_claim else let holding = { holding with unclaimed = 0tez; } in let tez_op = Treasury_Utils.transfer_fee holding.holder unclaimed_tez in - let vault_holdings = Big_map.update holding.holder (Some holding) storage.vault_holdings in + let vault_holdings = VaultHoldings.upsert holding.holder holding storage.vault_holdings in let storage = {storage with vault_holdings = vault_holdings;} in ([tez_op], storage) let claim_rewards (holder:address) (storage:storage) : (operation list * storage) = - match Big_map.find_opt holder storage.vault_holdings with + match VaultHoldings.find_opt holder storage.vault_holdings with | None -> failwith no_holdings_to_claim | Some h -> claim_from_holding h storage @@ -235,6 +235,27 @@ let inject_liquidity let ops = execute_deposit o storage.batcher in ops, storage +[@inline] +let add_reward + (reward: tez) + (storage: storage) : result = + let rat_total_shares = Rational.new (int storage.total_shares) in + let int_tez_reward: int = int (reward / 1mutez) in + let rat_tez_reward = Rational.new int_tez_reward in + let add_rewards = fun (holdings,(addr,holding):VaultHoldings.t * (VaultHoldings.key * VaultHoldings.value)) -> + let rat_shares = Rational.new (int holding.shares) in + let perc_share = Rational.div rat_shares rat_total_shares in + let rew_to_user = Rational.mul perc_share rat_tez_reward in + let rew_to_user_in_tez = 1mutez * (get_rounded_number_lower_bound rew_to_user) in + let updated_rewards =if rew_to_user_in_tez > 0mutez then holding.unclaimed + rew_to_user_in_tez else holding.unclaimed in + let new_holding = { holding with unclaimed = updated_rewards; } in + VaultHoldings.upsert addr new_holding holdings + in + let vault_holdings = VaultHoldings.fold add_rewards storage.vault_holdings VaultHoldings.empty in + let storage = { storage with vault_holdings=vault_holdings; } in + no_op storage + + [@inline] let change_marketmaker_address (new_marketmaker_address: address) @@ -267,6 +288,7 @@ type entrypoint = | AddLiquidity of nat | RemoveLiquidity | Claim + | AddReward of tez | InjectLiquidity of liquidity_injection_request | Change_admin_address of address | Change_batcher_address of address @@ -280,6 +302,8 @@ let main | AddLiquidity a -> Vault.add_liquidity a storage | RemoveLiquidity -> Vault.remove_liquidity storage | Claim -> Vault.claim storage + (* Batcher endpoints *) + | AddReward r -> Vault.add_reward r storage (* MarketMaker endpoints *) | InjectLiquidity lir -> Vault.inject_liquidity lir storage (* Admin endpoints *)