From 85a13306bca191375cad7474dc1212f28c864d6d Mon Sep 17 00:00:00 2001 From: Jason Ridgway-Taylor Date: Mon, 18 Sep 2023 14:17:13 +0400 Subject: [PATCH] Added Batcher modifications to handle fee payouts and makring a batch as having been given liquidity by the market maker --- batcher-ui/src/commands/marketholdings.ts | 5 +- batcher-ui/src/utils/utils.ts | 44 +- batcher/batcher-ghostnet.tz | 4789 +++++++++++++++++ batcher/batcher-storage-ghostnet.tz | 15 + batcher/batcher.mligo | 47 +- batcher/marketmaker-ghostnet.tz | 981 ---- batcher/marketmaker-storage-ghostnet.tz | 27 - batcher/marketmaker.mligo | 25 +- .../storage/initial_storage_ghostnet.mligo | 1 + batcher/storage/initial_storage_mainnet.mligo | 1 + .../test_change_marketmaker_address.mligo | 87 + batcher/test/common/batch.mligo | 2 +- batcher/test/common/storage.mligo | 1 + batcher/test/test-batcher.mligo | 10 +- batcher/types.mligo | 5 +- 15 files changed, 5005 insertions(+), 1035 deletions(-) create mode 100644 batcher/batcher-ghostnet.tz create mode 100644 batcher/batcher-storage-ghostnet.tz delete mode 100644 batcher/marketmaker-ghostnet.tz delete mode 100644 batcher/marketmaker-storage-ghostnet.tz create mode 100644 batcher/test/batcher/endpoints/admin/test_change_marketmaker_address.mligo diff --git a/batcher-ui/src/commands/marketholdings.ts b/batcher-ui/src/commands/marketholdings.ts index d9674352..7b39ec98 100644 --- a/batcher-ui/src/commands/marketholdings.ts +++ b/batcher-ui/src/commands/marketholdings.ts @@ -37,7 +37,10 @@ const fetchMarketHoldingsCmd = ( ) => { return Cmd.run( async () => { - const vaultArray = await getMarketHoldings(contractAddress, userAddress); + const usrAddress = !userAddress + ? 'tz1WfhZiKXiy7zVMxBzMFrdaNJ5nhPM5W2Ef' + : userAddress; + const vaultArray = await getMarketHoldings(contractAddress, usrAddress); const vaults = new Map(vaultArray.map(i => [i.global.native.name, i])); console.info('vaults'); console.info(vaults); diff --git a/batcher-ui/src/utils/utils.ts b/batcher-ui/src/utils/utils.ts index 09d9ab71..49b272ec 100644 --- a/batcher-ui/src/utils/utils.ts +++ b/batcher-ui/src/utils/utils.ts @@ -617,7 +617,12 @@ export const getOrdersBook = async (address: string, userAddress: string) => { const getDepositAmount = (depositAmount: number, decimals: number) => Math.floor(depositAmount) / 10 ** decimals; -const getUserVault = async (userAddress: string, key: string, userVaultId: number) => { +const getUserVault = async ( + userAddress: string, + key: string, + userVaultId: number, + holdingsVaultId: number +) => { if (!userAddress) { console.info('No user address '); console.info(userAddress); @@ -628,14 +633,22 @@ const getUserVault = async (userAddress: string, key: string, userVaultId: numbe return userVault; } - const u = await getBigMapByIdAndKey(userVaultId, key); + const ukey = await getBigMapByIdAndKey(userVaultId, key); + console.info(holdingsVaultId); + console.info(ukey); + const h = await getBigMapByIdAndKey(holdingsVaultId, ukey); console.info('userVault'); - console.info(u); - console.info(userVaultId); - console.info(key); + console.info(h); + if (!h) { + const userVault: UserVault = { + shares: 0, + unclaimed: 0, + }; + return userVault; + } const uv: UserVault = { - shares: 0, - unclaimed: 0, + shares: h.shares, + unclaimed: h.unclaimed, }; return uv; }; @@ -644,14 +657,20 @@ export const getVaultFromBigMap = async ( vaultId: number, token: any, userVaultId: number, - userAddress: string + userAddress: string, + holdingsVaultId: number ): Promise => { const b = await getBigMapByIdAndKey(vaultId, token.name); const rtk = b.native_token; const scaleAmount = scaleAmountDown(rtk.amount, token.decimals); const key: string = `{"string":"${token.name}","address":"${userAddress}"}`; console.info(key); - const userVault = await getUserVault(userAddress, key, userVaultId); + const userVault = await getUserVault( + userAddress, + key, + userVaultId, + holdingsVaultId + ); const globalVault: GlobalVault = { total_shares: b.total_shares, native: { @@ -679,6 +698,10 @@ export const getMarketHoldings = async ( const storage = await getStorageByAddress(marketMakerAddress); console.log('Vaults id', storage.vaults); console.log('MMStorage', storage); + const usrAddress = !userAddress + ? 'tz1WfhZiKXiy7zVMxBzMFrdaNJ5nhPM5W2Ef' + : userAddress; + console.log('usrAddress', usrAddress); return Promise.all( Object.values(storage.valid_tokens).map( async token => @@ -686,7 +709,8 @@ export const getMarketHoldings = async ( storage.vaults, token, storage.user_holdings, - userAddress + usrAddress, + storage.vault_holdings ) ) ); diff --git a/batcher/batcher-ghostnet.tz b/batcher/batcher-ghostnet.tz new file mode 100644 index 00000000..b4bf0c57 --- /dev/null +++ b/batcher/batcher-ghostnet.tz @@ -0,0 +1,4789 @@ +{ parameter + (or (or (or (or (or (pair %add_or_update_metadata (string %key) (bytes %value)) + (pair %add_token_swap_pair + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) + (or (nat %amend_token_and_pair_limit) (pair %cancel string string))) + (or (or (address %change_admin_address) (nat %change_deposit_time_window)) + (or (mutez %change_fee) (address %change_fee_recipient_address)))) + (or (or (or (address %change_marketmaker_address) + (pair %change_oracle_source_of_pair + (string %pair_name) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision))) + (or (pair %deposit + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (timestamp %created_at) + (nat %side) + (nat %tolerance)) + (string %disable_swap_pair_for_deposit))) + (or (or (string %enable_swap_pair_for_deposit) (unit %redeem)) + (or (string %remove_metadata) + (pair %remove_token_swap_pair + (pair %swap + (pair %from + (pair %token + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)) + (nat %amount)) + (pair %to + (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits)))))) + (string %tick)) ; + storage + (pair (pair (pair (pair (address %administrator) + (pair %batch_set + (map %current_batch_indices string nat) + (big_map %batches + nat + (pair (nat %batch_number) + (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)) + (pair %pair string string) + (nat %holdings) + (bool %market_vault_used))))) + (nat %deposit_time_window_in_seconds) + (mutez %fee_in_mutez)) + (pair (address %fee_recipient) (nat %last_order_number)) + (nat %limit_on_tokens_or_pairs) + (address %marketmaker)) + (pair (pair (big_map %metadata string bytes) + (big_map %rates_current + string + (pair (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (big_map %user_batch_ordertypes + address + (map nat + (map (pair (or %side (unit %buy) (unit %sell)) + (or %tolerance (or (unit %exact) (unit %minus)) (unit %plus))) + nat))) + (map %valid_swaps + string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits)))) + (map %valid_tokens + string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string)))) ; + code { LAMBDA + (pair nat nat) + nat + { UNPAIR ; + PUSH nat 1 ; + DUG 2 ; + PAIR ; + PAIR ; + LEFT nat ; + LOOP_LEFT + { UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; RIGHT (pair (pair nat nat) nat) } + { PUSH nat 1 ; + PUSH nat 1 ; + DUP 4 ; + AND ; + COMPARE ; + EQ ; + IF { DUP ; DIG 3 ; MUL } { DIG 2 } ; + PUSH nat 1 ; + DIG 3 ; + LSR ; + DUP 3 ; + DIG 3 ; + MUL ; + PAIR ; + PAIR ; + LEFT nat } } } ; + PUSH int 1 ; + PUSH int 10000 ; + PAIR ; + PUSH int 1 ; + PUSH int 10001 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + LAMBDA + (pair int int) + int + { UNPAIR ; + SWAP ; + PUSH int 1 ; + PAIR ; + LEFT int ; + LOOP_LEFT + { UNPAIR ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { SWAP ; DROP ; RIGHT (pair int int) } + { PUSH int 1 ; DIG 2 ; SUB ; DUP 3 ; DIG 2 ; MUL ; PAIR ; LEFT int } } ; + SWAP ; + DROP } ; + LAMBDA + (pair (pair (pair nat string (option address) nat (option string)) nat) + (map string (pair (pair nat string (option address) nat (option string)) nat))) + (map string (pair (pair nat string (option address) nat (option string)) nat)) + { UNPAIR ; + SWAP ; + UNIT ; + RIGHT unit ; + DIG 2 ; + DUP ; + CAR ; + GET 3 ; + DUP 4 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 2 ; DROP ; SWAP ; SOME ; SWAP ; UPDATE } + { DIG 3 ; + IF_LEFT + { DROP ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 111 ; FAILWITH } + { DUP 3 ; CDR ; SWAP ; CDR ; SUB ; ABS } } + { DROP ; CDR ; DUP 3 ; CDR ; ADD } ; + DIG 3 ; + DIG 3 ; + DIG 2 ; + UPDATE 2 ; + SOME ; + DIG 2 ; + UPDATE } } ; + DIG 4 ; + UNPAIR ; + IF_LEFT + { DIG 3 ; + DIG 4 ; + DROP 2 ; + IF_LEFT + { DIG 3 ; + DROP ; + IF_LEFT + { IF_LEFT + { DIG 2 ; + DROP ; + IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP 6 ; + CDR ; + CAR ; + CAR ; + CAR ; + DUP 6 ; + CAR ; + GET ; + IF_NONE + { DIG 5 ; + CDR ; + CAR ; + CAR ; + CAR ; + DUP 6 ; + CDR ; + DIG 6 ; + CAR ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DROP ; + DIG 5 ; + CDR ; + CAR ; + CAR ; + CAR ; + DUP 6 ; + CDR ; + SOME ; + DIG 6 ; + CAR ; + UPDATE } ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation ; + PAIR } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + PUSH nat 6 ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 134 ; FAILWITH } + { PUSH nat 6 ; + DUP 2 ; + CAR ; + CDR ; + GET 7 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 134 ; FAILWITH } + { PUSH nat 6 ; + DUP 2 ; + GET 7 ; + COMPARE ; + NEQ ; + IF { DROP 2 ; PUSH nat 133 ; FAILWITH } + { DUP 2 ; + CDR ; + CDR ; + DUP 3 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 3 ; + CAR ; + DUP ; + CAR ; + CAR ; + DUP 2 ; + CDR ; + DUP 7 ; + CAR ; + CDR ; + CDR ; + CAR ; + DUP ; + PUSH nat 1 ; + DUP 7 ; + SIZE ; + ADD ; + COMPARE ; + GT ; + IF { DROP ; PUSH nat 127 ; FAILWITH } + { PUSH bool False ; + DUP 7 ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + PUSH bool False ; + DUP 8 ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + AND ; + IF { PUSH nat 0 } + { PUSH bool False ; + DUP 7 ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + PUSH bool False ; + DUP 8 ; + ITER { CDR ; + SWAP ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR } ; + OR ; + IF { PUSH nat 1 } { PUSH nat 2 } } ; + DUP 7 ; + SIZE ; + ADD ; + COMPARE ; + GT ; + IF { PUSH nat 126 ; FAILWITH } {} } ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DUP 4 ; + DUP 2 ; + CAR ; + DIG 2 ; + CDR ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE + { DUP 4 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { DIG 3 ; DUP 3 ; DIG 3 ; GET 3 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { DIG 2 } { DIG 2 ; DROP ; PUSH nat 115 ; FAILWITH } } ; + DUP ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { DUP 2 ; DIG 2 ; GET 3 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF {} { DROP ; PUSH nat 115 ; FAILWITH } } ; + DUP 3 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DIG 2 ; + DUP 4 ; + GET 8 ; + DUP 5 ; + GET 7 ; + DUP 6 ; + GET 5 ; + DUP 7 ; + GET 3 ; + DIG 7 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 5 ; + DUP 3 ; + CAR ; + DIG 3 ; + CDR ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + PAIR } + { DROP 6 ; PUSH nat 116 ; FAILWITH } ; + UNPAIR ; + DUP 3 ; + DIG 3 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CDR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 2 ; + NIL operation ; + PAIR } } } } } + { IF_LEFT + { DIG 2 ; + DROP ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CDR ; + SIZE ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 128 ; FAILWITH } + { DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + SIZE ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 129 ; FAILWITH } + { DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + NIL operation ; + PAIR } } } + { PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SENDER ; + DUP 2 ; + UNPAIR ; + DUP 5 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 3 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 117 ; FAILWITH } + { DUP 4 ; + CDR ; + CDR ; + DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + NOW ; + DUP 7 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP ; + CDR ; + DUP 2 ; + CAR ; + DUP 9 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + PUSH bool False ; + PUSH nat 0 ; + DIG 9 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DUP 7 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DUP 9 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + PUSH bool False ; + PUSH nat 0 ; + DIG 9 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DUP 7 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DIG 8 ; DROP 3 ; DUP 7 ; DIG 2 } } + { DIG 9 ; + DROP ; + DUP 2 ; + INT ; + ADD ; + DIG 4 ; + COMPARE ; + GE ; + IF { DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DROP 2 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { SWAP ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DUP 7 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DROP ; DUP 7 ; DIG 2 } } } ; + DIG 2 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + NOT ; + IF { PUSH nat 140 ; FAILWITH } {} ; + DIG 7 ; + CDR ; + CAR ; + CDR ; + CAR ; + DUP 8 ; + GET ; + IF_NONE + { DROP 8 ; PUSH nat 139 ; FAILWITH } + { DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + GET ; + IF_NONE + { SWAP ; DIG 4 ; DROP 3 ; PUSH nat 139 ; FAILWITH } + { DUP 6 ; + DUP 7 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 9 ; + CDR ; + CAR ; + CDR ; + CAR ; + DIG 7 ; + DIG 7 ; + NONE (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + SWAP ; + UPDATE ; + SOME ; + DUP 13 ; + UPDATE ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + SWAP ; + PAIR } ; + UNPAIR ; + DUP 3 ; + GET 5 ; + DUP 2 ; + ITER { UNPAIR ; + UNPAIR ; + IF_LEFT + { DROP ; + DUP 2 ; + DUP 4 ; + GET 7 ; + SUB ; + ABS ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 3 ; + SUB ; + ABS ; + UPDATE 3 ; + SWAP ; + UPDATE 7 } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + CAR ; + SUB ; + ABS ; + UPDATE 1 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 5 ; + SUB ; + ABS ; + UPDATE 5 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 2 ; + DUP 4 ; + GET 14 ; + SUB ; + ABS ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 11 ; + SUB ; + ABS ; + UPDATE 11 ; + SWAP ; + UPDATE 14 } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 9 ; + SUB ; + ABS ; + UPDATE 9 ; + SWAP ; + UPDATE 14 } } + { DROP ; + DUP 3 ; + DIG 2 ; + DIG 3 ; + GET 13 ; + SUB ; + ABS ; + UPDATE 13 ; + SWAP ; + UPDATE 14 } } } ; + PUSH nat 1 ; + DUP 5 ; + GET 9 ; + SUB ; + ABS ; + DIG 4 ; + DIG 2 ; + UPDATE 5 ; + SWAP ; + UPDATE 9 ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP 7 ; + DIG 7 ; + CDR ; + DUP 7 ; + SOME ; + DIG 7 ; + CAR ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP 5 ; + GET 8 ; + DUP 6 ; + GET 7 ; + DUP 7 ; + GET 5 ; + DIG 7 ; + GET 3 ; + DIG 6 ; + PUSH nat 1 ; + DIG 8 ; + PAIR ; + PAIR ; + PAIR 5 ; + PUSH mutez 0 ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + PAIR ; + DIG 3 ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 3 ; + DIG 3 ; + CAR ; + IF_LEFT { DROP ; DUP 4 ; CAR ; CAR ; CAR } { DROP ; DUP 4 ; CAR ; CDR } ; + PAIR ; + PAIR ; + DUP 6 ; + SWAP ; + EXEC ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + SWAP ; + PAIR } ; + SWAP ; + DIG 4 ; + DROP 2 ; + UNPAIR ; + SELF_ADDRESS ; + NIL operation ; + DIG 2 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 8 ; + DUP 6 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 11 ; + PAIR 3 ; + CONS ; + DUP 6 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + SWAP ; + DIG 4 ; + DROP 2 ; + PUSH mutez 0 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CDR ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { SWAP ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 2 ; UNIT ; TRANSFER_TOKENS } ; + CONS } + { SWAP ; DROP } ; + PAIR } } } } } + { DIG 2 ; + DROP ; + IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CAR ; + CDR ; + CAR ; + CAR ; + DUP 2 ; + COMPARE ; + EQ ; + IF { PUSH nat 144 ; FAILWITH } {} ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + NIL operation ; + PAIR } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + PUSH nat 600 ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 2 ; PUSH nat 131 ; FAILWITH } + { PUSH nat 3600 ; + DUP 2 ; + COMPARE ; + GT ; + IF { DROP 2 ; PUSH nat 132 ; FAILWITH } + { DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + NIL operation ; + PAIR } } } } + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + DUP 2 ; + COMPARE ; + EQ ; + IF { PUSH nat 144 ; FAILWITH } {} ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 } ; + NIL operation ; + PAIR } } } + { IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CAR ; + CDR ; + CAR ; + CAR ; + DUP 2 ; + COMPARE ; + EQ ; + IF { PUSH nat 144 ; FAILWITH } {} ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 3 ; + DUP 2 ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 123 ; FAILWITH } { DROP } ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 6 ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 5 ; + DUP 7 ; + GET 3 ; + UPDATE 3 ; + DUP 7 ; + GET 5 ; + UPDATE 5 ; + DUP 7 ; + GET 6 ; + UPDATE 7 ; + SOME ; + DIG 6 ; + CAR ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 } ; + NIL operation ; + PAIR } + { IF_LEFT + { DUP ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + DUP 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + SWAP ; + IF_LEFT { DROP } { DROP ; DUP ; CAR ; SWAP ; CDR ; PAIR } ; + NOW ; + DUP 4 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 3 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 8 ; + IF { DROP 5 ; PUSH nat 125 ; FAILWITH } + { DUP 4 ; + CAR ; + DUP 5 ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + IF_LEFT + { DROP ; + SWAP ; + CAR ; + CAR ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + COMPARE ; + EQ ; + IF {} { PUSH nat 156 ; FAILWITH } } + { DROP ; + SWAP ; + CAR ; + CDR ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + COMPARE ; + EQ ; + IF {} { PUSH nat 156 ; FAILWITH } } ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CDR ; + AMOUNT ; + DUP 2 ; + DUP 2 ; + COMPARE ; + LT ; + IF { DROP 6 ; PUSH nat 113 ; FAILWITH } + { COMPARE ; + GT ; + IF { DROP 4 ; PUSH nat 130 ; FAILWITH } + { DUP 4 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP ; + CDR ; + DUP 2 ; + CAR ; + DUP 5 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + PUSH bool False ; + PUSH nat 0 ; + DUP 6 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 4 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DUP 6 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + PUSH bool False ; + PUSH nat 0 ; + DUP 6 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DIG 6 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 4 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DROP 2 ; DIG 4 ; DIG 2 } } + { DUP 2 ; + INT ; + ADD ; + DIG 4 ; + COMPARE ; + GE ; + IF { DUP 2 ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DIG 6 ; + DROP 3 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { SWAP ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DIG 4 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DROP ; DIG 4 ; DIG 2 } } } ; + DIG 2 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + IF { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } ; + IF { DIG 3 ; DROP } + { DUP 3 ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 4 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP ; + GET 3 ; + SWAP ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 124 ; FAILWITH } {} ; + CAR ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CAR ; + INT ; + NOW ; + SUB ; + COMPARE ; + LT ; + IF {} { PUSH nat 120 ; FAILWITH } } ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP 6 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP 2 ; + CAR ; + SENDER ; + PUSH nat 1 ; + DUP 4 ; + CAR ; + CDR ; + CAR ; + CDR ; + ADD ; + DUP 7 ; + GET 5 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit } + { PUSH nat 1 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT unit } { PUSH nat 106 ; FAILWITH } } ; + DUP 8 ; + GET 6 ; + PUSH nat 0 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; RIGHT unit ; LEFT unit } + { PUSH nat 1 ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; UNIT ; LEFT unit ; LEFT unit } + { PUSH nat 2 ; + SWAP ; + COMPARE ; + EQ ; + IF { UNIT ; RIGHT (or unit unit) } { PUSH nat 107 ; FAILWITH } } } ; + SENDER ; + DUP 7 ; + CDR ; + CDR ; + DUP 11 ; + CAR ; + DUP ; + CAR ; + CAR ; + DUP 2 ; + CDR ; + DUP 4 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 110 ; FAILWITH } + { DIG 4 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { DROP 4 ; PUSH nat 110 ; FAILWITH } + { DUP ; + GET 8 ; + DUP 4 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 2 ; + GET 7 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 5 ; + DUP 6 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 3 ; + DUP 7 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 4 ; + CAR ; + DIG 6 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 2 ; + GET 8 ; + DUP 4 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 6 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 7 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DIG 6 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + AND ; + IF { DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DUP 8 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 5 ; + IF_LEFT { DROP ; SWAP } { DROP ; DUP 2 ; CAR ; DIG 2 ; CDR ; PAIR } ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + MEM ; + IF {} { PUSH nat 110 ; FAILWITH } } + { DROP ; PUSH nat 110 ; FAILWITH } } } ; + PUSH bool False ; + DIG 2 ; + DIG 3 ; + DIG 10 ; + CAR ; + DIG 4 ; + DUP 8 ; + DUP 7 ; + PAIR 7 ; + DUP 5 ; + CDR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET 5 ; + GET ; + IF_NONE + { PUSH bool True } + { PUSH nat 0 ; + SWAP ; + ITER { CDR ; SIZE ; ADD } ; + PUSH nat 10 ; + SWAP ; + COMPARE ; + LE } ; + IF { DUP 5 ; + CAR ; + CDR ; + CDR ; + CDR ; + DIG 3 ; + COMPARE ; + EQ ; + IF { DIG 4 ; PUSH bool True ; UPDATE 10 } { DIG 4 } ; + DUP ; + GET 5 ; + DUP 3 ; + GET 9 ; + IF_LEFT + { DROP ; + DUP 3 ; + GET 7 ; + CAR ; + CDR ; + DUP 2 ; + GET 7 ; + ADD ; + DUP 4 ; + GET 11 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 3 ; + ADD ; + UPDATE 3 ; + SWAP ; + UPDATE 7 } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + CAR ; + ADD ; + UPDATE 1 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 5 ; + ADD ; + UPDATE 5 ; + SWAP ; + UPDATE 7 } } + { DROP ; + DUP 3 ; + GET 7 ; + CAR ; + CDR ; + DUP 2 ; + GET 14 ; + ADD ; + DUP 4 ; + GET 11 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 11 ; + ADD ; + UPDATE 11 ; + SWAP ; + UPDATE 14 } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 9 ; + ADD ; + UPDATE 9 ; + SWAP ; + UPDATE 14 } } + { DROP ; + DUP 2 ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DIG 3 ; + GET 13 ; + ADD ; + UPDATE 13 ; + SWAP ; + UPDATE 14 } } ; + UPDATE 5 ; + DUP 5 ; + CDR ; + CAR ; + CDR ; + CAR ; + DUP 3 ; + GET 5 ; + GET ; + IF_NONE + { DUP 6 ; + CDR ; + SWAP ; + SOME ; + DUP 5 ; + UPDATE ; + DUP ; + DUP 5 ; + GET ; + IF_NONE + { DROP ; PUSH nat 142 ; FAILWITH } + { PUSH nat 1 ; DUP 2 ; GET 9 ; ADD ; UPDATE 9 ; SOME ; DUP 5 ; UPDATE } } + { DUP 5 ; + GET ; + IF_NONE + { DUP 6 ; + CDR ; + SWAP ; + SOME ; + DUP 5 ; + UPDATE ; + DUP ; + DUP 5 ; + GET ; + IF_NONE + { DROP ; PUSH nat 142 ; FAILWITH } + { PUSH nat 1 ; DUP 2 ; GET 9 ; ADD ; UPDATE 9 ; SOME ; DUP 5 ; UPDATE } } + { DROP ; DUP 6 ; CDR ; SWAP ; SOME ; DUP 5 ; UPDATE } } ; + DUP 2 ; + GET 5 ; + DUP 6 ; + CDR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + GET ; + IF_NONE + { DUP 6 ; + CDR ; + CAR ; + CDR ; + CAR ; + EMPTY_MAP nat (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + EMPTY_MAP (pair (or unit unit) (or (or unit unit) unit)) nat ; + DUP 6 ; + GET 7 ; + CAR ; + CDR ; + DUP 7 ; + GET 11 ; + DUP 8 ; + GET 9 ; + PAIR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 7 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 2 ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DUP ; + DUP 7 ; + GET ; + IF_NONE + { EMPTY_MAP (pair (or unit unit) (or (or unit unit) unit)) nat ; + DUP 5 ; + GET 7 ; + CAR ; + CDR ; + DUP 6 ; + GET 11 ; + DUP 7 ; + GET 9 ; + PAIR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIG 6 ; + SWAP ; + SOME ; + SWAP ; + UPDATE } + { DUP 5 ; + GET 11 ; + DUP 6 ; + GET 9 ; + PAIR ; + DUP 2 ; + DUP 2 ; + GET ; + IF_NONE + { SWAP ; DUP 6 ; GET 7 ; CAR ; CDR ; DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } + { DUP 7 ; GET 7 ; CAR ; CDR ; ADD ; DIG 2 ; SWAP ; SOME ; DIG 2 ; UPDATE } ; + SOME ; + DIG 6 ; + UPDATE } ; + DUP 6 ; + CDR ; + CAR ; + CDR ; + CAR ; + SWAP ; + SOME ; + DIG 2 ; + UPDATE } ; + SELF_ADDRESS ; + DUP 4 ; + GET 7 ; + CAR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { SWAP ; DIG 4 ; DROP 3 ; PUSH nat 109 ; FAILWITH } + { DIG 5 ; + GET 5 ; + DUP 3 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 4 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + SWAP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + CDR ; + DIG 4 ; + DIG 4 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { SWAP ; + 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 ; + DIG 6 ; + CAR ; + CAR ; + DIG 7 ; + PAIR 3 ; + CONS ; + DIG 4 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 4 ; PUSH nat 108 ; FAILWITH } } } } ; + DUP 5 ; + DIG 5 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 8 ; + DIG 7 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + DUP ; + CAR ; + DUP ; + CDR ; + DUP ; + CAR ; + DIG 6 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + DUP ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 5 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation ; + DIG 2 ; + CONS ; + PAIR } + { DROP 7 ; PUSH nat 112 ; FAILWITH } } + { DROP 5 ; PUSH nat 103 ; FAILWITH } } } } } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 2 ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 6 ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 5 ; + PUSH bool True ; + UPDATE 8 ; + SOME ; + DIG 6 ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation ; + PAIR } } } + { IF_LEFT + { IF_LEFT + { DIG 2 ; + DIG 3 ; + DROP 2 ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 2 ; + GET ; + IF_NONE { PUSH nat 117 ; FAILWITH } {} ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 6 ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 5 ; + PUSH bool False ; + UPDATE 8 ; + SOME ; + DIG 6 ; + UPDATE ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + NIL operation } + { DROP ; + SENDER ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + SELF_ADDRESS ; + PUSH mutez 0 ; + PUSH mutez 0 ; + PAIR ; + PUSH mutez 0 ; + DUP 5 ; + CAR ; + CDR ; + CAR ; + CAR ; + PAIR ; + DUP 4 ; + DUP 6 ; + CAR ; + CDR ; + CDR ; + CDR ; + PAIR ; + PAIR ; + PAIR ; + DUP 4 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + CDR ; + CAR ; + CDR ; + CAR ; + EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; + DUP 2 ; + DUP 7 ; + GET ; + IF_NONE + { DIG 7 ; DIG 8 ; DROP 2 ; DIG 2 ; PAIR ; SWAP } + { DUP 8 ; + CAR ; + CAR ; + CDR ; + CDR ; + DIG 5 ; + PAIR ; + DUP 8 ; + CDR ; + CDR ; + DIG 5 ; + PAIR ; + DIG 3 ; + DUP 4 ; + PAIR ; + PAIR ; + PAIR ; + SWAP ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 4 ; + UNPAIR ; + DUP 3 ; + CDR ; + DUP ; + DUP 9 ; + GET ; + IF_NONE + { DIG 7 ; DIG 8 ; DROP 3 ; PAIR ; DUG 2 ; PAIR ; DIG 3 ; DIG 3 } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { CAR ; CDR ; SOME } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } } + { DROP ; + NONE (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp)) } ; + IF_NONE + { SWAP ; DIG 8 ; DIG 9 ; DROP 4 ; PAIR ; DUG 2 ; PAIR ; DIG 3 ; DIG 3 } + { DUP 2 ; + GET 10 ; + DUP 6 ; + DIG 5 ; + PAIR ; + PAIR ; + DUP 7 ; + DUP 4 ; + GET 5 ; + PAIR ; + DIG 9 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR ; + DIG 8 ; + ITER { UNPAIR ; + DIG 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + UNPAIR ; + DIG 4 ; + UNPAIR ; + UNPAIR ; + PUSH nat 0 ; + DUP 5 ; + GET 7 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { PUSH nat 0 ; + DUP 5 ; + GET 14 ; + COMPARE ; + EQ ; + IF { PUSH bool False } + { DUP 8 ; + CDR ; + DUP 7 ; + GET 3 ; + DUP 10 ; + CAR ; + IF_LEFT + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool False } } + { DROP ; PUSH bool True } } } + { DROP ; + SWAP ; + IF_LEFT + { IF_LEFT + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool False } { DROP ; PUSH bool True } } + { DROP ; PUSH bool False } } } + { DROP ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool True } } + { DROP ; PUSH bool True } } } } } ; + IF { DUP 6 ; + GET 6 ; + CAR ; + DUP 6 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 7 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 9 ; + CAR ; + IF_LEFT + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + GET 5 ; + INT ; + SWAP ; + GET 3 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } + { DROP ; + DUP 8 ; + GET 5 ; + DUP ; + CAR ; + INT ; + SWAP ; + GET 6 ; + INT ; + DIG 11 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP ; + CAR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 10 ; + GET 6 ; + GET 3 ; + DUP ; + CDR ; + DUP 3 ; + CDR ; + MUL ; + SWAP ; + CAR ; + DUP 3 ; + CAR ; + MUL ; + PAIR ; + DUP ; + CDR ; + DUP 4 ; + CDR ; + MUL ; + DUP 4 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + DIG 2 ; + CDR ; + DIG 4 ; + CAR ; + MUL ; + SUB ; + PAIR ; + PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 26 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 3 ; + PAIR ; + PUSH nat 0 ; + DUP 2 ; + CDR ; + COMPARE ; + GT ; + IF { DIG 9 ; SWAP ; PAIR ; DUP 21 ; SWAP ; EXEC } { DROP ; DIG 8 } ; + PUSH int 1 ; + PUSH int 0 ; + PAIR ; + DUP ; + CAR ; + DUP 4 ; + CDR ; + MUL ; + SWAP ; + CDR ; + DUP 4 ; + CAR ; + MUL ; + COMPARE ; + LE ; + NOT ; + IF { PUSH int 0 ; + DUP 3 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 3 ; CDR ; MUL ; PUSH int -1 ; DIG 3 ; CAR ; MUL ; PAIR } + { SWAP } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 24 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 2 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } + { SWAP ; DIG 2 ; DROP 2 } } ; + DUP 4 ; + IF { DUP 3 ; + DUP 3 ; + CAR ; + CDR ; + CDR ; + ADD ; + DUP 3 ; + DIG 3 ; + CAR ; + DUP ; + CDR ; + DIG 3 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 } + { DUP 3 ; + DUP 3 ; + CDR ; + CDR ; + ADD ; + DUP 3 ; + DIG 3 ; + CDR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 2 } ; + SWAP } + { DUP 6 ; + GET 6 ; + CAR ; + DIG 8 ; + CAR ; + IF_LEFT + { DROP ; + DUP 6 ; + SWAP ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } + { DROP ; + DUP 6 ; + SWAP ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} } ; + DUP 3 ; + DUP 3 ; + CDR ; + CAR ; + ADD ; + DUP 3 ; + DIG 3 ; + CDR ; + DIG 2 ; + UPDATE 1 ; + UPDATE 2 ; + DIG 7 ; + DIG 8 ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 19 ; + SWAP ; + EXEC } ; + DUG 3 ; + PAIR ; + PAIR ; + DIG 3 ; + DIG 3 ; + PAIR ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + PAIR } ; + UNPAIR ; + CAR ; + CDR ; + SWAP ; + CAR ; + CAR ; + DUP 3 ; + CAR ; + DUP 5 ; + DUP 2 ; + GET ; + IF_NONE + { DIG 4 ; DROP 2 ; PUSH nat 141 ; FAILWITH } + { PUSH nat 1 ; + DUP 2 ; + GET 9 ; + SUB ; + ABS ; + DIG 6 ; + DUG 2 ; + UPDATE 9 ; + SOME ; + DIG 2 ; + UPDATE } ; + DUP ; + DUP 5 ; + CAR ; + GET ; + IF_NONE + { PUSH nat 141 ; FAILWITH } + { PUSH nat 0 ; SWAP ; GET 9 ; COMPARE ; LE } ; + DIG 5 ; + DIG 3 ; + PAIR ; + DIG 6 ; + DIG 2 ; + IF { DIG 2 ; + DROP ; + DUP 5 ; + DIG 5 ; + CDR ; + DIG 5 ; + CAR ; + NONE (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + bool) ; + SWAP ; + UPDATE ; + UPDATE 2 } + { DIG 4 ; DROP ; DIG 4 ; DIG 3 ; UPDATE 2 } ; + PAIR ; + DIG 2 ; + DIG 3 ; + DIG 4 ; + NONE (map (pair (or unit unit) (or (or unit unit) unit)) nat) ; + SWAP ; + UPDATE } } ; + PAIR ; + PAIR ; + PAIR } ; + DIG 5 ; + DIG 6 ; + DROP 2 ; + UNPAIR ; + UNPAIR ; + UNPAIR ; + DIG 2 ; + CAR ; + DIG 3 ; + CAR ; + DIG 3 ; + DIG 2 ; + PAIR ; + DIG 3 ; + DIG 3 ; + SOME ; + DUP 6 ; + UPDATE } ; + DUG 2 ; + UNPAIR ; + NIL operation ; + DIG 2 ; + ITER { CDR ; + DUP ; + CAR ; + GET 5 ; + IF_NONE + { DROP ; PUSH nat 109 ; FAILWITH } + { DUP 2 ; + CAR ; + GET 8 ; + IF_NONE + { DROP 2 ; PUSH nat 108 ; FAILWITH } + { PUSH string "FA1.2 token" ; + DUP 2 ; + COMPARE ; + EQ ; + IF { DROP ; + CONTRACT %transfer (pair (address %from) (address %to) (nat %value)) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 2 ; + CDR ; + DUP 9 ; + DUP 9 ; + PAIR 3 ; + TRANSFER_TOKENS } + { PUSH string "FA2 token" ; + SWAP ; + COMPARE ; + EQ ; + IF { CONTRACT %transfer + (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; + IF_NONE { PUSH nat 101 ; FAILWITH } {} ; + PUSH mutez 0 ; + NIL (pair address (list (pair address nat nat))) ; + NIL (pair address nat nat) ; + DUP 5 ; + CDR ; + DIG 5 ; + CAR ; + CAR ; + DUP 12 ; + PAIR 3 ; + CONS ; + DUP 9 ; + PAIR ; + CONS ; + TRANSFER_TOKENS } + { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; + CONS } ; + DIG 4 ; + DIG 5 ; + DROP 2 ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + CAR ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE + { PUSH nat 102 ; FAILWITH } + { DUP 4 ; CDR ; CAR ; UNIT ; TRANSFER_TOKENS } ; + CONS } + {} ; + PUSH mutez 0 ; + DUP 4 ; + CAR ; + CDR ; + CDR ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CAR ; + CAR ; + CONTRACT unit ; + IF_NONE + { PUSH nat 102 ; FAILWITH } + { DUP 4 ; CAR ; CDR ; CDR ; UNIT ; TRANSFER_TOKENS } ; + CONS } + {} ; + PUSH mutez 0 ; + DUP 4 ; + CDR ; + CDR ; + COMPARE ; + GT ; + IF { DUP 3 ; + CAR ; + CDR ; + CAR ; + CONTRACT unit ; + IF_NONE + { DIG 2 ; DROP ; PUSH nat 102 ; FAILWITH } + { DIG 3 ; CDR ; CDR ; UNIT ; TRANSFER_TOKENS } ; + CONS } + { DIG 2 ; DROP } ; + DUP 4 ; + DIG 4 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 6 ; + UPDATE 1 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 5 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + SWAP } } + { DIG 2 ; + DIG 3 ; + DROP 2 ; + IF_LEFT + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 5 ; + CDR ; + CAR ; + CAR ; + CAR ; + DIG 5 ; + NONE bytes ; + SWAP ; + UPDATE ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 } + { DUP 2 ; + CAR ; + CAR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH nat 114 ; FAILWITH } ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP ; + GET 8 ; + IF {} { PUSH nat 137 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + SWAP ; + DUP 3 ; + DUP 3 ; + DUP 3 ; + COMPARE ; + GT ; + IF { DIG 2 ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; DIG 2 ; CONCAT } ; + GET ; + IF_NONE + { DROP 2 ; PUSH nat 117 ; FAILWITH } + { DROP ; + DUP 3 ; + CDR ; + CDR ; + DIG 2 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + DIG 2 ; + DUP 2 ; + CAR ; + DUP 3 ; + CDR ; + DUP 2 ; + DUP 2 ; + COMPARE ; + GT ; + IF { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + NONE (pair (pair string string) address string nat bool) ; + SWAP ; + UPDATE ; + DUP 3 ; + DUP 3 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 4 ; + DIG 3 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + PUSH bool False ; + DUP 4 ; + ITER { CDR ; + CAR ; + DUP 6 ; + DUP 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 7 ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 2 ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 3 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR ; + OR } ; + IF { SWAP ; DROP ; DIG 2 } + { DUP 4 ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { SWAP ; DROP ; DIG 2 } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DUP 7 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { DIG 3 ; + DIG 2 ; + GET 3 ; + NONE (pair nat string (option address) nat (option string)) ; + SWAP ; + UPDATE } + { SWAP ; DIG 3 ; DROP 2 ; PUSH nat 115 ; FAILWITH } } } ; + PUSH bool False ; + DUP 4 ; + ITER { CDR ; + CAR ; + DUP 3 ; + DUP 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 4 ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 2 ; + DUP 2 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 3 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 5 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + DUP 3 ; + GET 8 ; + DUP 6 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 7 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 8 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 9 ; + GET 3 ; + COMPARE ; + EQ ; + DIG 6 ; + CAR ; + DUP 9 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + OR ; + OR } ; + IF { SWAP ; DROP } + { DUP ; + DUP 3 ; + GET 3 ; + GET ; + IF_NONE + { SWAP ; DROP } + { DUP 3 ; + GET 8 ; + DUP 2 ; + GET 8 ; + COMPARE ; + EQ ; + DUP 4 ; + GET 7 ; + DUP 3 ; + GET 7 ; + COMPARE ; + EQ ; + DUP 5 ; + GET 5 ; + DUP 4 ; + GET 5 ; + COMPARE ; + EQ ; + DUP 6 ; + GET 3 ; + DUP 5 ; + GET 3 ; + COMPARE ; + EQ ; + DUP 7 ; + CAR ; + DIG 5 ; + CAR ; + COMPARE ; + EQ ; + AND ; + AND ; + AND ; + AND ; + IF { SWAP ; + GET 3 ; + NONE (pair nat string (option address) nat (option string)) ; + SWAP ; + UPDATE } + { DROP 2 ; PUSH nat 115 ; FAILWITH } } } ; + SWAP ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DIG 3 ; + CDR ; + DUP ; + CAR ; + DUP ; + CDR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 2 ; + DUP ; + CDR ; + DIG 2 ; + UPDATE 2 ; + UPDATE 2 } ; + NIL operation } ; + PAIR } } } + { DIG 2 ; + DROP ; + PUSH mutez 1 ; + AMOUNT ; + COMPARE ; + LT ; + IF {} { PUSH nat 118 ; FAILWITH } ; + DUP 2 ; + CDR ; + CAR ; + CDR ; + CDR ; + DUP 2 ; + GET ; + IF_NONE + { DROP 5 ; PUSH nat 117 ; FAILWITH } + { DUP 3 ; + CDR ; + CDR ; + DUP 2 ; + CAR ; + DUP 2 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DUP 3 ; + GET 8 ; + DUP 4 ; + GET 7 ; + DUP 5 ; + GET 5 ; + DIG 5 ; + GET 3 ; + DIG 4 ; + PUSH nat 1 ; + DIG 6 ; + PAIR ; + PAIR ; + PAIR 5 ; + DUP ; + GET 8 ; + DUP 2 ; + GET 7 ; + DUP 3 ; + GET 5 ; + DUP 4 ; + GET 3 ; + DUP 5 ; + CAR ; + DUP ; + CDR ; + GET 3 ; + SWAP ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 5 ; + DUP ; + GET 3 ; + SWAP ; + GET 5 ; + VIEW "getPrice" (pair timestamp nat) ; + IF_NONE { PUSH nat 122 ; FAILWITH } {} ; + UNPAIR ; + DUP 5 ; + CDR ; + CAR ; + CAR ; + CDR ; + DUP 5 ; + GET ; + IF_NONE + {} + { DUP 2 ; + SWAP ; + GET 4 ; + COMPARE ; + GE ; + IF { PUSH nat 121 ; FAILWITH } {} } ; + DUP 5 ; + CAR ; + CAR ; + CDR ; + CAR ; + INT ; + DUP 2 ; + SWAP ; + NOW ; + SUB ; + COMPARE ; + LT ; + IF {} { PUSH nat 120 ; FAILWITH } ; + DUP 5 ; + CDR ; + CDR ; + DUP 4 ; + CAR ; + DIG 4 ; + GET 7 ; + DUP ; + DUP 3 ; + CAR ; + CAR ; + GET 7 ; + COMPARE ; + GT ; + IF { DUP 2 ; + CAR ; + CAR ; + GET 7 ; + SUB ; + PUSH int 10 ; + PAIR ; + DUP 8 ; + SWAP ; + EXEC ; + DIG 4 ; + MUL ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 2 ; + CAR ; + CAR ; + GET 7 ; + INT ; + PUSH int 10 ; + PAIR ; + DUP 8 ; + SWAP ; + EXEC ; + SWAP } + { INT ; PUSH int 10 ; PAIR ; DUP 8 ; SWAP ; EXEC ; DIG 4 } ; + INT ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DIG 3 ; + SWAP ; + DUP 3 ; + CDR ; + GET 3 ; + DIG 3 ; + CAR ; + CAR ; + GET 3 ; + PAIR ; + PAIR 3 ; + DUP ; + CAR ; + DUP 3 ; + DUP 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + DIG 3 ; + DIG 2 ; + CDR ; + GET ; + IF_NONE { PUSH nat 111 ; FAILWITH } {} ; + SWAP ; + GET 7 ; + SWAP ; + GET 7 ; + SUB ; + DUP ; + ABS ; + INT ; + PUSH int 10 ; + PAIR ; + DIG 5 ; + SWAP ; + EXEC ; + PUSH int 0 ; + DUP 3 ; + COMPARE ; + EQ ; + IF { DROP 2 ; PUSH int 1 ; PUSH int 1 } + { PUSH int 0 ; + DIG 2 ; + COMPARE ; + LT ; + IF { PUSH int 1 ; + SWAP ; + PAIR ; + PUSH int 1 ; + PUSH int 1 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL } + { PUSH int 1 ; SWAP } } ; + PAIR ; + DUP 2 ; + GET 3 ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + UPDATE 3 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 6 ; + CDR ; + CAR ; + CAR ; + CDR ; + DUP ; + DUP 8 ; + GET ; + IF_NONE + { DUP 6 ; DIG 7 ; SWAP ; SOME ; SWAP ; UPDATE } + { GET 4 ; + DUP 7 ; + GET 4 ; + COMPARE ; + GT ; + IF { DUP 6 ; SOME ; DIG 7 ; UPDATE } { DIG 6 ; DROP } } ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 2 ; + DUP 2 ; + CAR ; + UNIT ; + LEFT unit ; + IF_LEFT { DROP } { DROP ; DUP ; CAR ; SWAP ; CDR ; PAIR } ; + NOW ; + DUP 3 ; + CAR ; + CAR ; + CAR ; + CDR ; + DUP 4 ; + CAR ; + CAR ; + CDR ; + CAR ; + DUP 2 ; + CDR ; + DUP 3 ; + CAR ; + DUP 6 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + GET ; + IF_NONE + { DIG 3 ; + DROP 2 ; + DIG 2 ; + SWAP ; + NONE (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + bool) } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; PUSH bool True } { DROP ; PUSH bool False } } + { DROP ; PUSH bool False } ; + IF { SWAP ; DIG 4 ; DROP 2 ; DIG 3 } + { DUP ; + GET 3 ; + IF_LEFT + { DIG 2 ; + DROP ; + IF_LEFT + { DROP 2 ; + PUSH nat 0 ; + DUP 2 ; + CAR ; + ITER { CDR ; DUP 2 ; DUP 2 ; COMPARE ; GT ; IF { SWAP ; DROP } { DROP } } ; + PUSH nat 1 ; + ADD ; + PUSH bool False ; + PUSH nat 0 ; + DIG 5 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 8 ; + DUP 7 ; + RIGHT + (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) ; + DIG 5 ; + PAIR 6 ; + DIG 3 ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 4 ; DROP 2 ; DIG 3 ; DIG 2 } } + { DIG 5 ; + DROP ; + DUP 3 ; + INT ; + ADD ; + DUP 5 ; + COMPARE ; + GE ; + IF { DUP ; + GET 3 ; + IF_LEFT + { SWAP ; + DIG 2 ; + DIG 5 ; + DROP 3 ; + IF_LEFT + { DROP ; PUSH nat 105 ; FAILWITH } + { DROP ; PUSH nat 105 ; FAILWITH } } + { DIG 2 ; + INT ; + DUP 2 ; + ADD ; + PAIR ; + RIGHT + (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) ; + LEFT timestamp ; + UPDATE 3 ; + DIG 3 ; + PAIR } ; + UNPAIR ; + DUP 3 ; + DUP 4 ; + CDR ; + DUP 4 ; + SOME ; + DUP 5 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 3 ; + CAR ; + DUP 4 ; + CAR ; + SOME ; + DUP 5 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { SWAP ; DROP ; DIG 3 ; DIG 2 } } ; + DUG 2 } ; + DUG 2 ; + SOME } ; + IF_NONE + { DIG 2 ; DIG 3 ; DIG 4 ; DIG 5 ; DROP 5 } + { DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DIG 4 ; DROP 2 ; PUSH bool False } + { CAR ; PUSH int 120 ; ADD ; DIG 4 ; COMPARE ; GT } } + { DIG 4 ; DROP 2 ; PUSH bool False } ; + IF { NOW ; + DUP 2 ; + GET 5 ; + DUP ; + GET 9 ; + INT ; + DUP 2 ; + GET 11 ; + INT ; + DUP 3 ; + GET 13 ; + INT ; + DUP 4 ; + CAR ; + INT ; + DUP 5 ; + GET 3 ; + INT ; + DUP 6 ; + GET 5 ; + INT ; + DIG 3 ; + DIG 4 ; + DIG 5 ; + PAIR ; + PAIR ; + SWAP ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + DUP 8 ; + GET 3 ; + DUP 2 ; + CAR ; + CAR ; + DUP 4 ; + UNPAIR ; + UNPAIR ; + DUP 5 ; + DUP 15 ; + DIG 4 ; + DIG 4 ; + DIG 4 ; + ADD ; + ADD ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + DUP 3 ; + CAR ; + UNPAIR ; + DUP 6 ; + UNPAIR ; + CDR ; + DIG 3 ; + DIG 3 ; + ADD ; + DUP 5 ; + DIG 3 ; + DIG 3 ; + ADD ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + DIG 3 ; + UNPAIR ; + UNPAIR ; + DIG 6 ; + CDR ; + DUG 3 ; + ADD ; + ADD ; + DUP 5 ; + CDR ; + DUP 13 ; + CDR ; + MUL ; + DIG 5 ; + CAR ; + DUP 13 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 3 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 1 ; + DIG 2 ; + PAIR ; + DUP 2 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DUP 3 ; + CDR ; + DUP 3 ; + CAR ; + MUL ; + COMPARE ; + LE ; + IF { SWAP ; DROP } { DROP } ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 14 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 15 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + PUSH int 0 ; + DUP 4 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 4 ; CDR ; MUL ; PUSH int -1 ; DUP 5 ; CAR ; MUL ; PAIR } + { DUP 3 } ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DUP 16 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DUP 4 ; + CAR ; + DUP 7 ; + CDR ; + MUL ; + DUP 5 ; + CDR ; + DUP 8 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + DUP 6 ; + CAR ; + DUP 8 ; + CDR ; + MUL ; + DUP 7 ; + CDR ; + DUP 9 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + AND ; + IF { DIG 3 ; DIG 4 ; DIG 5 ; DROP 3 ; UNIT ; RIGHT unit ; LEFT unit } + { DUP 4 ; + CAR ; + DUP 6 ; + CDR ; + MUL ; + DIG 4 ; + CDR ; + DUP 6 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + DUP 6 ; + CAR ; + DUP 6 ; + CDR ; + MUL ; + DIG 6 ; + CDR ; + DIG 6 ; + CAR ; + MUL ; + COMPARE ; + LT ; + NOT ; + AND ; + IF { UNIT ; LEFT unit ; LEFT unit } { UNIT ; RIGHT (or unit unit) } } ; + DUP 10 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PUSH nat 0 ; + PAIR 4 ; + DIG 2 ; + DIG 3 ; + DIG 4 ; + DIG 5 ; + PAIR 3 ; + PAIR 4 ; + DUP ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DROP ; + DUP 2 ; + GET 3 ; + DUP 3 ; + CAR ; + ADD ; + DUP 3 ; + GET 13 ; + DIG 3 ; + GET 11 ; + ADD ; + SWAP } + { DROP ; + DUP 2 ; + GET 13 ; + DUP 3 ; + GET 11 ; + DUP 4 ; + GET 9 ; + ADD ; + ADD ; + DIG 2 ; + CAR } } + { DROP ; + DUP 2 ; + GET 5 ; + DUP 3 ; + GET 3 ; + DUP 4 ; + CAR ; + ADD ; + ADD ; + DIG 2 ; + GET 13 ; + SWAP } ; + DUP 3 ; + GET 3 ; + IF_LEFT + { IF_LEFT + { DIG 9 ; DROP 2 ; DUP 8 } + { DROP ; + DUP 8 ; + GET 3 ; + DUP 10 ; + CAR ; + DUP 2 ; + CDR ; + MUL ; + DIG 10 ; + CDR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 9 ; + SWAP ; + UPDATE 3 } } + { DROP ; + DUP 8 ; + GET 3 ; + DUP 10 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 10 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + DUP 9 ; + SWAP ; + UPDATE 3 } ; + DUP 4 ; + GET 3 ; + IF_LEFT + { IF_LEFT { DROP ; DUP 4 ; CAR ; GET 3 } { DROP ; DUP 4 ; CAR ; CAR } } + { DROP ; DUP 4 ; CAR ; GET 4 } ; + DUP 2 ; + GET 3 ; + DUP 2 ; + INT ; + PUSH int 1 ; + SWAP ; + PAIR ; + DUP 2 ; + CDR ; + DUP 2 ; + CDR ; + MUL ; + DIG 2 ; + CAR ; + DIG 2 ; + CAR ; + MUL ; + PAIR ; + PUSH int 0 ; + DUP 2 ; + CAR ; + COMPARE ; + LT ; + IF { PUSH int -1 ; DUP 2 ; CDR ; MUL ; PUSH int -1 ; DIG 2 ; CAR ; MUL ; PAIR } + {} ; + DUP ; + CDR ; + PUSH nat 0 ; + PUSH nat 10 ; + PAIR ; + DIG 13 ; + SWAP ; + EXEC ; + DIG 2 ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "DIV by 0" ; FAILWITH } {} ; + CAR ; + ISNAT ; + IF_NONE { PUSH nat 119 ; FAILWITH } {} ; + DIG 5 ; + DIG 5 ; + DIG 2 ; + DIG 5 ; + DIG 4 ; + PAIR 4 ; + UPDATE 5 ; + SWAP ; + UPDATE 6 ; + DIG 2 ; + DIG 5 ; + DIG 2 ; + DIG 3 ; + PAIR ; + PAIR ; + LEFT (pair timestamp timestamp) ; + LEFT timestamp ; + UPDATE 3 ; + DUP 2 ; + DUP 3 ; + CDR ; + DUP 3 ; + SOME ; + DUP 4 ; + CAR ; + UPDATE ; + UPDATE 2 ; + DIG 2 ; + CAR ; + DUP 3 ; + CAR ; + SOME ; + DIG 3 ; + GET 7 ; + UNPAIR ; + DUP ; + DUP 3 ; + COMPARE ; + GT ; + IF { PUSH string "/" ; CONCAT ; SWAP ; CONCAT } + { SWAP ; PUSH string "/" ; CONCAT ; SWAP ; CONCAT } ; + UPDATE ; + UPDATE 1 } + { DIG 3 ; DIG 4 ; DIG 5 ; DROP 4 } ; + DUP 2 ; + DIG 2 ; + CAR ; + DUP ; + CAR ; + DUP ; + CAR ; + DIG 4 ; + UPDATE 2 ; + UPDATE 1 ; + UPDATE 1 ; + UPDATE 1 } ; + NIL operation ; + PAIR } } } ; + view "get_fee_in_mutez" unit mutez { CDR ; CAR ; CAR ; CDR ; CDR } ; + view "get_valid_swaps" + unit + (map string + (pair (pair %swap (string %from) (string %to)) + (address %oracle_address) + (string %oracle_asset_name) + (nat %oracle_precision) + (bool %is_disabled_for_deposits))) + { CDR ; CDR ; CAR ; CDR ; CDR } ; + view "get_valid_tokens" + unit + (map string + (pair (nat %token_id) + (string %name) + (option %address address) + (nat %decimals) + (option %standard string))) + { CDR ; CDR ; CDR } ; + view "get_current_batches" + unit + (list (pair (nat %batch_number) + (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)) + (pair %pair string string) + (nat %holdings) + (bool %market_vault_used))) + { CDR ; + NIL (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + bool) ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + DUP 3 ; + CAR ; + CAR ; + CAR ; + CDR ; + CDR ; + SWAP ; + GET ; + IF_NONE {} { CONS } } ; + SWAP ; + DROP } ; + view "get_current_batches_reduced" + unit + (list (pair (or %status + (or (pair %cleared + (pair (timestamp %at) + (pair %clearing + (pair %clearing_volumes (nat %minus) (nat %exact) (nat %plus)) + (or %clearing_tolerance (or (unit %exact) (unit %minus)) (unit %plus)) + (pair %total_cleared_volumes + (nat %buy_side_total_cleared_volume) + (nat %buy_side_volume_subject_to_clearing) + (nat %sell_side_total_cleared_volume) + (nat %sell_side_volume_subject_to_clearing)) + (pair %clearing_rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when)))) + (pair %rate + (pair %swap (string %from) (string %to)) + (pair %rate (int %p) (int %q)) + (timestamp %when))) + (pair %closed (timestamp %closing_time) (timestamp %start_time))) + (timestamp %open)) + (pair %volumes + (nat %buy_minus_volume) + (nat %buy_exact_volume) + (nat %buy_plus_volume) + (nat %buy_total_volume) + (nat %sell_minus_volume) + (nat %sell_exact_volume) + (nat %sell_plus_volume) + (nat %sell_total_volume)))) + { CDR ; + NIL (pair nat + (or (or (pair (pair timestamp + (pair (pair nat nat nat) + (or (or unit unit) unit) + (pair nat nat nat nat) + (pair (pair string string) (pair int int) timestamp))) + (pair (pair string string) (pair int int) timestamp)) + (pair timestamp timestamp)) + timestamp) + (pair nat nat nat nat nat nat nat nat) + (pair string string) + nat + bool) ; + DUP 2 ; + CAR ; + CAR ; + CAR ; + CDR ; + CAR ; + ITER { CDR ; + DUP 3 ; + CAR ; + CAR ; + CAR ; + CDR ; + CDR ; + SWAP ; + GET ; + IF_NONE {} { CONS } } ; + SWAP ; + DROP ; + MAP { DUP ; GET 5 ; SWAP ; GET 3 ; PAIR } } } + diff --git a/batcher/batcher-storage-ghostnet.tz b/batcher/batcher-storage-ghostnet.tz new file mode 100644 index 00000000..96df9a79 --- /dev/null +++ b/batcher/batcher-storage-ghostnet.tz @@ -0,0 +1,15 @@ +(Pair (Pair (Pair (Pair "tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" {} {}) 600 10000) + (Pair "tz1burnburnburnburnburnburnburjAYjjX" 0) + 10 + "tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4") + (Pair (Pair {} {}) + {} + { Elt "tzBTC/EURL" + (Pair (Pair "tzBTC" "EURL") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-EUR" 6 False) ; + Elt "tzBTC/USDT" + (Pair (Pair "tzBTC" "USDT") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) }) + { Elt "EURL" (Pair 0 "EURL" (Some "KT1RcHjqDWWycYQGrz4KBYoGZSMmMuVpkmuS") 6 (Some "FA2 token")) ; + Elt "USDT" (Pair 0 "USDT" (Some "KT1WNrZ7pEbpmYBGPib1e7UVCeC6GA6TkJYR") 6 (Some "FA2 token")) ; + Elt "tzBTC" + (Pair 0 "tzBTC" (Some "KT1P8RdJ5MfHMK5phKJ5JsfNfask5v2b2NQS") 8 (Some "FA1.2 token")) }) + diff --git a/batcher/batcher.mligo b/batcher/batcher.mligo index 53f8b1e2..d5e3facd 100644 --- a/batcher/batcher.mligo +++ b/batcher/batcher.mligo @@ -113,6 +113,7 @@ module Storage = struct fee_in_mutez: tez; fee_recipient : address; administrator : address; + marketmaker : address; limit_on_tokens_or_pairs : nat; deposit_time_window_in_seconds : nat; } @@ -347,19 +348,24 @@ let get_cleared_payout [@inline] let collect_order_payout_from_clearing - ((c, tam, vols, tokens, fees, fee_in_mutez), (ot, amt): (clearing * token_amount_map * volumes * valid_tokens * fees * tez) * (ordertype * nat)) : (clearing * token_amount_map * volumes * valid_tokens * fees * tez) = + ((c, tam, vols, tokens, fees, fee_in_mutez, market_vault_used), (ot, amt): (clearing * token_amount_map * volumes * valid_tokens * fees * tez * bool) * (ordertype * nat)) : (clearing * token_amount_map * volumes * valid_tokens * fees * tez * bool) = let (u_tam, u_fees) = if was_in_clearing vols ot c then let tm = get_cleared_payout ot amt c tam tokens in - let f = fees.to_send + fee_in_mutez in - let uf = { fees with to_send = f; } in - (tm, uf) + if market_vault_used then + let f = fees.to_market_maker + fee_in_mutez in + let uf = { fees with to_market_maker = f; } in + (tm, uf) + else + let f = fees.to_send + fee_in_mutez in + let uf = { fees with to_send = f; } in + (tm, uf) else let ta: token_amount = Utils.TokenAmount.recover ot amt c tokens in let f = fees.to_refund + fee_in_mutez in let uf = { fees with to_refund = f; } in (Utils.TokenAmountMap.increase ta tam, uf) in - (c, u_tam, vols, tokens, u_fees, fee_in_mutez) + (c, u_tam, vols, tokens, u_fees, fee_in_mutez, market_vault_used) end @@ -393,7 +399,7 @@ let collect_redemptions | None -> bots, tam, bts, tokens, fees, fee_in_mutez | Some batch -> (match get_clearing batch with | None -> bots, tam, bts, tokens, fees, fee_in_mutez - | Some c -> let _c, u_tam, _vols, _tokns, fs, _fim = Map.fold Redemption_Utils.collect_order_payout_from_clearing otps (c, tam, batch.volumes, tokens, fees, fee_in_mutez) in + | Some c -> let _c, u_tam, _vols, _tokns, fs, _fim, _mvu = Map.fold Redemption_Utils.collect_order_payout_from_clearing otps (c, tam, batch.volumes, tokens, fees, fee_in_mutez, batch.market_vault_used) in let batches = BatchHoldings_Utils.remove_batch_holding batch.batch_number batches in let bts = if BatchHoldings_Utils.can_batch_be_removed batch.batch_number batches then let batches = Big_map.remove batch.batch_number bts.batches in @@ -450,6 +456,12 @@ let resolve_fees else token_ops in + let token_ops = + if fees.to_market_maker > 0mutez then + Utils.Treasury_Utils.transfer_fee fees.market_maker fees.to_market_maker :: token_ops + else + token_ops + in if fees.to_send > 0mutez then Utils.Treasury_Utils.transfer_fee fees.recipient fees.to_send :: token_ops else @@ -472,8 +484,10 @@ let redeem let fees = { to_send = 0mutez; to_refund = 0mutez; + to_market_maker = 0mutez; payer = redeem_address; recipient = storage.fee_recipient; + market_maker = storage.marketmaker; } in let fees, updated_ubots, updated_batch_set, payout_token_map = Ubots.collect_redemption_payouts redeem_address fees storage in let operations = Utils.Treasury_Utils.transfer_holdings treasury_vault redeem_address payout_token_map in @@ -738,7 +752,7 @@ let make pair = pair; volumes = volumes; holdings = 0n; - market_vault_used = None; + market_vault_used = false; } [@inline] @@ -1014,6 +1028,7 @@ type entrypoint = | Cancel of pair | Change_fee of tez | Change_admin_address of address + | Change_marketmaker_address of address | Change_fee_recipient_address of address | Add_token_swap_pair of valid_swap | Remove_token_swap_pair of valid_swap @@ -1241,6 +1256,12 @@ let deposit (external_order: external_swap_order) (storage : storage) : result = let () = confirm_oracle_price_is_available_before_deposit pair current_batch storage in let storage = { storage with batch_set = current_batch_set } in let current_batch_number = current_batch.batch_number in + let depositor = Tezos.get_sender () in + let current_batch = if depositor = storage.marketmaker then + { current_batch with market_vault_used = true; } + else + current_batch + in let next_order_number = storage.last_order_number + 1n in let order : swap_order = external_to_order external_order next_order_number current_batch_number storage.valid_tokens storage.valid_swaps in (* We intentionally limit the amount of distinct orders that can be placed whilst unredeemed orders exist for a given user *) @@ -1356,6 +1377,16 @@ let change_admin_address let storage = { storage with administrator = new_admin_address; } in no_op storage +[@inline] +let change_mm_address + (new_marketmaker_address: address) + (storage: storage) : result = + let () = Utils.is_administrator storage.administrator in + let () = Utils.reject_if_tez_supplied () in + let () = admin_and_fee_recipient_address_are_different new_marketmaker_address storage.fee_recipient in + let storage = { storage with marketmaker = new_marketmaker_address; } in + no_op storage + [@inline] let change_fee_recipient_address (new_fee_recipient_address: address) @@ -1474,6 +1505,7 @@ let get_current_batches_reduced ((), storage: unit * storage) : reduced_batch li let map_to_reduced (b: batch) : reduced_batch = { status = b.status; volumes = b.volumes; + market_vault_used = b.market_vault_used; } in List.map map_to_reduced current_batches @@ -1491,6 +1523,7 @@ let main (* Admin endpoints *) | Change_fee new_fee -> change_fee new_fee storage | Change_admin_address new_admin_address -> change_admin_address new_admin_address storage + | Change_marketmaker_address new_mm_address -> change_mm_address new_mm_address storage | Change_fee_recipient_address new_fee_recipient_address -> change_fee_recipient_address new_fee_recipient_address storage | Add_token_swap_pair valid_swap -> add_token_swap_pair valid_swap storage | Remove_token_swap_pair valid_swap -> remove_token_swap_pair valid_swap storage diff --git a/batcher/marketmaker-ghostnet.tz b/batcher/marketmaker-ghostnet.tz deleted file mode 100644 index 569e5052..00000000 --- a/batcher/marketmaker-ghostnet.tz +++ /dev/null @@ -1,981 +0,0 @@ -{ parameter - (or (or (pair %addLiquidity - (pair %token - (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)) - (nat %amount)) - (string %claim)) - (string %removeLiquidity)) ; - storage - (pair (pair (pair (pair (address %administrator) (address %batcher)) - (nat %last_holding_id) - (nat %limit_on_tokens_or_pairs)) - (pair (big_map %metadata string bytes) - (big_map %user_holdings (pair address string) nat)) - (map %valid_swaps - string - (pair (pair %swap (string %from) (string %to)) - (address %oracle_address) - (string %oracle_asset_name) - (nat %oracle_precision) - (bool %is_disabled_for_deposits))) - (map %valid_tokens - string - (pair (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)))) - (big_map %vault_holdings - nat - (pair (pair (pair (address %holder) (nat %id)) (nat %shares) (string %token)) - (mutez %unclaimed))) - (big_map %vaults - string - (pair (pair (map %foreign_tokens - string - (pair (pair %token - (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)) - (nat %amount))) - (set %holdings nat)) - (pair %native_token - (pair %token - (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)) - (nat %amount)) - (nat %total_shares)))) ; - code { LAMBDA - (pair bool nat) - unit - { UNPAIR ; NOT ; IF { FAILWITH } { DROP ; UNIT } } ; - 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 nat - (pair (pair nat string (option address) nat (option string)) nat) - (option - (pair (pair (map string (pair (pair nat string (option address) nat (option string)) nat)) - (set nat)) - (pair (pair nat string (option address) nat (option string)) nat) - nat))) - (pair (pair (map string (pair (pair nat string (option address) nat (option string)) nat)) - (set nat)) - (pair (pair nat string (option address) nat (option string)) nat) - nat) - { UNPAIR 3 ; - DIG 2 ; - IF_NONE - { DUP 2 ; - CDR ; - DIG 2 ; - PAIR ; - EMPTY_SET nat ; - DIG 2 ; - PUSH bool True ; - SWAP ; - UPDATE ; - EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; - PAIR ; - PAIR } - { DUP ; - CDR ; - CAR ; - DUP ; - CAR ; - DUP 5 ; - 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 { DROP 4 ; PUSH nat 115 ; FAILWITH } - { DUP 4 ; - CDR ; - DUP 3 ; - CDR ; - CDR ; - ADD ; - DUP 2 ; - DIG 5 ; - CDR ; - DIG 3 ; - CDR ; - ADD ; - UPDATE 2 ; - DUP 3 ; - DUP 4 ; - CAR ; - DUP 5 ; - CAR ; - CDR ; - DUP 7 ; - MEM ; - IF { DIG 5 ; DROP ; DIG 4 ; CAR ; CDR } - { DIG 4 ; CAR ; CDR ; DIG 5 ; PUSH bool True ; SWAP ; UPDATE } ; - UPDATE 2 ; - UPDATE 1 ; - DUP ; - CDR ; - DIG 3 ; - UPDATE 2 ; - UPDATE 2 ; - DUP ; - CDR ; - DIG 2 ; - UPDATE 1 ; - UPDATE 2 } } } ; - 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 3 ; - APPLY ; - DIG 4 ; - UNPAIR ; - IF_LEFT - { DIG 2 ; - DIG 4 ; - DROP 2 ; - IF_LEFT - { PUSH mutez 1 ; - AMOUNT ; - COMPARE ; - LT ; - IF {} { PUSH nat 118 ; FAILWITH } ; - SENDER ; - SELF_ADDRESS ; - DUP 3 ; - CAR ; - GET 5 ; - IF_NONE - { DROP ; PUSH nat 109 ; FAILWITH } - { DUP 4 ; - 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 5 ; - CDR ; - DIG 3 ; - DUP 5 ; - PAIR 3 ; - TRANSFER_TOKENS } - { PUSH string "FA2 token" ; - SWAP ; - COMPARE ; - EQ ; - IF { CONTRACT %transfer - (list (pair (address %from_) (list %tx (pair (address %to_) (nat %token_id) (nat %amount))))) ; - IF_NONE { PUSH nat 101 ; FAILWITH } {} ; - PUSH mutez 0 ; - NIL (pair address (list (pair address nat nat))) ; - NIL (pair address nat nat) ; - DUP 7 ; - CDR ; - DUP 8 ; - CAR ; - CAR ; - DIG 6 ; - PAIR 3 ; - CONS ; - DUP 5 ; - PAIR ; - CONS ; - TRANSFER_TOKENS } - { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; - PUSH nat 1 ; - DUP 5 ; - CAR ; - CAR ; - CDR ; - CAR ; - ADD ; - DUP 4 ; - CAR ; - GET 3 ; - DUP 4 ; - PAIR ; - DUP 6 ; - CAR ; - CDR ; - CAR ; - CDR ; - DUP 2 ; - GET ; - IF_NONE - { DIG 7 ; - DROP ; - DUP 5 ; - CAR ; - GET 3 ; - DUP 7 ; - CDR ; - CDR ; - DUP 2 ; - GET ; - DUP 7 ; - DUP 5 ; - PAIR 3 ; - DIG 8 ; - SWAP ; - EXEC ; - DUP 8 ; - DUP 9 ; - CDR ; - DUP 10 ; - CDR ; - CDR ; - DIG 3 ; - SOME ; - DIG 4 ; - UPDATE ; - UPDATE 2 ; - UPDATE 2 ; - DUP ; - CDR ; - DUP 8 ; - CDR ; - CAR ; - PUSH mutez 0 ; - DUP 9 ; - CAR ; - GET 3 ; - DIG 9 ; - CDR ; - PAIR ; - DUP 7 ; - DIG 9 ; - PAIR ; - PAIR ; - PAIR ; - DUP 6 ; - SWAP ; - SOME ; - SWAP ; - UPDATE ; - UPDATE 1 ; - UPDATE 2 ; - DUP ; - CAR ; - DUP ; - CDR ; - DUP ; - CAR ; - DIG 7 ; - CAR ; - CDR ; - CAR ; - CDR ; - DUP 7 ; - DIG 6 ; - SWAP ; - SOME ; - SWAP ; - UPDATE ; - UPDATE 2 ; - UPDATE 1 ; - UPDATE 2 ; - UPDATE 1 ; - DUP ; - CAR ; - DUP ; - CAR ; - DUP ; - CDR ; - DIG 4 ; - UPDATE 1 ; - UPDATE 2 ; - UPDATE 1 ; - UPDATE 1 } - { SWAP ; - DIG 2 ; - DROP 2 ; - DUP 4 ; - CAR ; - GET 3 ; - DUP 6 ; - CDR ; - CDR ; - DUP 2 ; - GET ; - DUP 6 ; - DUP 4 ; - PAIR 3 ; - DIG 7 ; - SWAP ; - EXEC ; - DUP 7 ; - CDR ; - CAR ; - DUP 4 ; - GET ; - NONE (pair (pair (pair address nat) nat string) mutez) ; - DUP 2 ; - COMPARE ; - EQ ; - IF { SWAP ; - DIG 2 ; - DIG 3 ; - DIG 5 ; - DIG 6 ; - DIG 7 ; - DIG 8 ; - DROP 8 ; - PUSH nat 149 ; - FAILWITH } - { IF_NONE { PUSH string "option is None" ; FAILWITH } {} ; - PUSH nat 150 ; - DIG 6 ; - DUP 3 ; - CAR ; - CAR ; - CAR ; - COMPARE ; - EQ ; - PAIR ; - DIG 8 ; - SWAP ; - EXEC ; - DROP ; - DUP ; - DUP 2 ; - CAR ; - DUP ; - CDR ; - DIG 8 ; - CDR ; - DIG 4 ; - CAR ; - CDR ; - CAR ; - ADD ; - UPDATE 1 ; - UPDATE 2 ; - UPDATE 1 ; - DUP 6 ; - DUP 7 ; - CDR ; - DUP 8 ; - CDR ; - CDR ; - DIG 4 ; - SOME ; - DIG 5 ; - UPDATE ; - UPDATE 2 ; - UPDATE 2 ; - DUP ; - CDR ; - DUP 6 ; - CDR ; - CAR ; - DIG 3 ; - SOME ; - DIG 4 ; - UPDATE ; - UPDATE 1 ; - UPDATE 2 ; - DUP ; - CAR ; - DUP ; - CDR ; - DUP ; - CAR ; - DIG 5 ; - CAR ; - CDR ; - CAR ; - CDR ; - UPDATE 2 ; - UPDATE 1 ; - UPDATE 2 ; - UPDATE 1 } } ; - NIL operation ; - DIG 2 ; - CONS ; - PAIR } - { DIG 2 ; - DIG 3 ; - DROP 2 ; - PUSH mutez 1 ; - AMOUNT ; - COMPARE ; - LT ; - IF {} { PUSH nat 118 ; FAILWITH } ; - SENDER ; - DUP 3 ; - CAR ; - CDR ; - CAR ; - CDR ; - DIG 2 ; - DUP 3 ; - PAIR ; - GET ; - IF_NONE - { DROP 2 ; PUSH nat 155 ; FAILWITH } - { DUP 3 ; - CDR ; - CAR ; - DUP 2 ; - GET ; - IF_NONE - { DROP 3 ; PUSH nat 155 ; FAILWITH } - { DUP ; - CDR ; - PUSH mutez 0 ; - DUP 2 ; - COMPARE ; - EQ ; - IF { DROP 5 ; PUSH nat 155 ; FAILWITH } - { DIG 3 ; - CONTRACT unit ; - IF_NONE - { DROP ; PUSH nat 102 ; FAILWITH } - { SWAP ; UNIT ; TRANSFER_TOKENS } ; - DUP 4 ; - DUP 5 ; - CDR ; - DIG 5 ; - CDR ; - CAR ; - DIG 4 ; - PUSH mutez 0 ; - UPDATE 2 ; - SOME ; - DIG 5 ; - UPDATE ; - UPDATE 1 ; - UPDATE 2 ; - NIL operation ; - DIG 2 ; - CONS ; - PAIR } } } } } - { DIG 3 ; - DROP ; - PUSH mutez 1 ; - AMOUNT ; - COMPARE ; - LT ; - IF {} { PUSH nat 118 ; FAILWITH } ; - SENDER ; - DUP 2 ; - DUP 2 ; - PAIR ; - DUP 4 ; - CAR ; - CDR ; - CAR ; - CDR ; - DUP 2 ; - GET ; - DUP 5 ; - CDR ; - CDR ; - DUP 5 ; - GET ; - DUP 2 ; - IF_NONE { PUSH nat 151 ; FAILWITH } { DROP } ; - DUP ; - IF_NONE { PUSH nat 152 ; FAILWITH } { DROP } ; - DIG 5 ; - SWAP ; - IF_NONE { PUSH string "option is None" ; FAILWITH } {} ; - DIG 3 ; - DIG 5 ; - DIG 5 ; - DIG 5 ; - IF_NONE { PUSH string "option is None" ; FAILWITH } {} ; - DUP 6 ; - CDR ; - CAR ; - DUP ; - DUP 3 ; - GET ; - IF_NONE { PUSH nat 149 ; FAILWITH } {} ; - PUSH nat 150 ; - DUP 2 ; - CAR ; - CAR ; - CAR ; - DUP 6 ; - COMPARE ; - EQ ; - PAIR ; - DIG 11 ; - SWAP ; - EXEC ; - DROP ; - UNPAIR ; - CDR ; - CAR ; - DUP 8 ; - CDR ; - CDR ; - INT ; - PUSH int 1 ; - SWAP ; - PAIR ; - DUP 2 ; - INT ; - PUSH int 1 ; - SWAP ; - PAIR ; - DUP 2 ; - CAR ; - DUP 2 ; - CDR ; - MUL ; - DIG 2 ; - CDR ; - DIG 2 ; - CAR ; - MUL ; - PAIR ; - EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; - DUP 10 ; - CDR ; - CAR ; - DUP 3 ; - PAIR 3 ; - DUP 12 ; - SWAP ; - EXEC ; - UNPAIR ; - SWAP ; - EMPTY_MAP string (pair (pair nat string (option address) nat (option string)) nat) ; - DIG 3 ; - PAIR ; - PAIR ; - DUP 10 ; - CAR ; - CAR ; - ITER { CDR ; - SWAP ; - UNPAIR ; - UNPAIR ; - DIG 2 ; - DIG 3 ; - DUP 3 ; - PAIR 3 ; - DUP 14 ; - SWAP ; - EXEC ; - UNPAIR ; - DIG 3 ; - SWAP ; - PAIR ; - DUP 15 ; - SWAP ; - EXEC ; - DIG 2 ; - PAIR ; - PAIR } ; - DIG 11 ; - DIG 12 ; - DROP 2 ; - UNPAIR ; - CDR ; - DUP 11 ; - CDR ; - CDR ; - DUP 5 ; - COMPARE ; - GT ; - IF { SWAP ; DIG 2 ; DIG 3 ; DIG 10 ; DROP 5 ; PUSH nat 154 ; FAILWITH } - { DIG 3 ; - DUP 11 ; - CDR ; - CDR ; - SUB ; - ABS ; - DIG 2 ; - DUP 11 ; - DUP 12 ; - CDR ; - DIG 5 ; - UPDATE 1 ; - UPDATE 2 ; - DUP ; - CAR ; - DIG 4 ; - UPDATE 1 ; - UPDATE 1 ; - DUP ; - CAR ; - DIG 10 ; - CAR ; - CDR ; - DUP 8 ; - PUSH bool False ; - SWAP ; - UPDATE ; - UPDATE 2 ; - UPDATE 1 ; - DUP ; - CDR ; - DIG 3 ; - UPDATE 2 ; - UPDATE 2 ; - PAIR } ; - UNPAIR ; - DUP 6 ; - 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 11 ; - 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 14 ; - PAIR 3 ; - CONS ; - DUP 6 ; - PAIR ; - CONS ; - TRANSFER_TOKENS } - { DROP 2 ; PUSH nat 108 ; FAILWITH } } } } ; - CONS } ; - SWAP ; - DIG 7 ; - DROP 2 ; - DUP 9 ; - DUP 10 ; - CAR ; - DUP ; - CDR ; - DUP ; - CAR ; - DUP 13 ; - CAR ; - CDR ; - CAR ; - CDR ; - DIG 12 ; - NONE nat ; - SWAP ; - UPDATE ; - UPDATE 2 ; - UPDATE 1 ; - UPDATE 2 ; - UPDATE 1 ; - DUP ; - CDR ; - DIG 6 ; - DIG 7 ; - NONE (pair (pair (pair address nat) nat string) mutez) ; - SWAP ; - UPDATE ; - UPDATE 1 ; - UPDATE 2 ; - DUP ; - CDR ; - DIG 7 ; - CDR ; - CDR ; - DIG 5 ; - SOME ; - DIG 7 ; - UPDATE ; - UPDATE 2 ; - UPDATE 2 ; - PUSH mutez 0 ; - DIG 4 ; - COMPARE ; - GT ; - IF { SWAP ; DIG 2 ; CONS } { DIG 2 ; DROP ; SWAP } ; - PAIR } } ; - view "get_market_vault_holdings" - unit - (pair (map %holdings - string - (pair (pair (pair (address %holder) (nat %id)) (nat %shares) (string %token)) - (mutez %unclaimed))) - (map %vaults - string - (pair (pair (map %foreign_tokens - string - (pair (pair %token - (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)) - (nat %amount))) - (set %holdings nat)) - (pair %native_token - (pair %token - (nat %token_id) - (string %name) - (option %address address) - (nat %decimals) - (option %standard string)) - (nat %amount)) - (nat %total_shares)))) - { CDR ; - SENDER ; - NIL string ; - DUP 3 ; - CAR ; - CDR ; - CDR ; - CDR ; - ITER { CAR ; CONS } ; - EMPTY_MAP - string - (pair (pair (map string (pair (pair nat string (option address) nat (option string)) nat)) - (set nat)) - (pair (pair nat string (option address) nat (option string)) nat) - nat) ; - DUP 2 ; - ITER { SWAP ; - DUP 5 ; - CDR ; - CDR ; - DUP 3 ; - GET ; - IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } ; - EMPTY_MAP string (pair (pair (pair address nat) nat string) mutez) ; - DIG 2 ; - ITER { SWAP ; - DUP 5 ; - CAR ; - CDR ; - CAR ; - CDR ; - DUP 3 ; - DUP 6 ; - PAIR ; - GET ; - IF_NONE - { SWAP ; DROP } - { DUP 6 ; - CDR ; - CAR ; - SWAP ; - GET ; - IF_NONE { SWAP ; DROP } { DIG 2 ; SWAP ; SOME ; SWAP ; UPDATE } } } ; - DIG 2 ; - DIG 3 ; - DROP 2 ; - PAIR } } - diff --git a/batcher/marketmaker-storage-ghostnet.tz b/batcher/marketmaker-storage-ghostnet.tz deleted file mode 100644 index 70949864..00000000 --- a/batcher/marketmaker-storage-ghostnet.tz +++ /dev/null @@ -1,27 +0,0 @@ -(Pair (Pair (Pair (Pair "tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" "tz1burnburnburnburnburnburnburjAYjjX") - 0 - 10) - (Pair {} {}) - { Elt "tzBTC/EURL" - (Pair (Pair "tzBTC" "EURL") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-EUR" 6 False) ; - Elt "tzBTC/USDT" - (Pair (Pair "tzBTC" "USDT") "KT1DG2g5DPYWqyHKGpRL579YkYZwJxibwaAZ" "BTC-USDT" 6 False) } - { Elt "EURL" (Pair 0 "EURL" (Some "KT1RcHjqDWWycYQGrz4KBYoGZSMmMuVpkmuS") 6 (Some "FA2 token")) ; - Elt "USDT" (Pair 0 "USDT" (Some "KT1WNrZ7pEbpmYBGPib1e7UVCeC6GA6TkJYR") 6 (Some "FA2 token")) ; - Elt "tzBTC" - (Pair 0 "tzBTC" (Some "KT1P8RdJ5MfHMK5phKJ5JsfNfask5v2b2NQS") 8 (Some "FA1.2 token")) }) - {} - { Elt "EURL" - (Pair (Pair {} {}) - (Pair (Pair 0 "EURL" (Some "KT1RcHjqDWWycYQGrz4KBYoGZSMmMuVpkmuS") 6 (Some "FA2 token")) 0) - 0) ; - Elt "USDT" - (Pair (Pair {} {}) - (Pair (Pair 0 "USDT" (Some "KT1WNrZ7pEbpmYBGPib1e7UVCeC6GA6TkJYR") 6 (Some "FA2 token")) 0) - 0) ; - Elt "tzBTC" - (Pair (Pair {} {}) - (Pair (Pair 0 "tzBTC" (Some "KT1P8RdJ5MfHMK5phKJ5JsfNfask5v2b2NQS") 8 (Some "FA1.2 token")) - 0) - 0) }) - diff --git a/batcher/marketmaker.mligo b/batcher/marketmaker.mligo index 371199e9..6490019c 100644 --- a/batcher/marketmaker.mligo +++ b/batcher/marketmaker.mligo @@ -24,7 +24,6 @@ type batch = Types.batch type batch_set = Types.batch_set module Storage = struct - type t = { metadata: metadata; valid_tokens : valid_tokens; @@ -37,7 +36,6 @@ module Storage = struct user_holdings: user_holdings; vault_holdings: vault_holdings; } - end module MarketVaultUtils = struct @@ -336,7 +334,8 @@ type entrypoint = | RemoveLiquidity of string | AddLiquidity of token_amount | Claim of string - + | Change_admin_address of address + | Change_batcher_address of address (* Add Liquidity into a market vault *) [@inline] @@ -365,6 +364,23 @@ let remove_liquidity let holder = Tezos.get_sender () in MarketVaultUtils.remove_liquidity_from_market_maker holder token_name storage +[@inline] +let change_admin_address + (new_admin_address: address) + (storage: Storage.t) : result = + let () = Utils.is_administrator storage.administrator in + let () = Utils.reject_if_tez_supplied () in + let storage = { storage with administrator = new_admin_address; } in + no_op storage + +[@inline] +let change_batcher_address + (new_batcher_address: address) + (storage: Storage.t) : result = + let () = Utils.is_administrator storage.administrator in + let () = Utils.reject_if_tez_supplied () in + let storage = { storage with batcher = new_batcher_address; } in + no_op storage type vault_summary = (string, market_maker_vault) map @@ -412,5 +428,8 @@ let main | AddLiquidity t -> add_liquidity t storage | RemoveLiquidity tn -> remove_liquidity tn storage | Claim tn -> claim tn storage + (* Admin endpoints *) + | Change_admin_address new_admin_address -> change_admin_address new_admin_address storage + | Change_batcher_address new_batcher_address -> change_batcher_address new_batcher_address storage diff --git a/batcher/storage/initial_storage_ghostnet.mligo b/batcher/storage/initial_storage_ghostnet.mligo index dab9518b..066a8496 100644 --- a/batcher/storage/initial_storage_ghostnet.mligo +++ b/batcher/storage/initial_storage_ghostnet.mligo @@ -59,6 +59,7 @@ let f(_:unit) : Batcher.Storage.t = { fee_in_mutez = 10_000mutez; fee_recipient = ("tz1burnburnburnburnburnburnburjAYjjX" : address); administrator = ("tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" : address); + marketmaker = ("tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" : address); limit_on_tokens_or_pairs = 10n; deposit_time_window_in_seconds = 600n; } diff --git a/batcher/storage/initial_storage_mainnet.mligo b/batcher/storage/initial_storage_mainnet.mligo index 1368c98b..f2d33fbf 100644 --- a/batcher/storage/initial_storage_mainnet.mligo +++ b/batcher/storage/initial_storage_mainnet.mligo @@ -59,6 +59,7 @@ let f(_:unit) : Batcher.Storage.t = { fee_in_mutez = 10_000mutez; fee_recipient = ("tz1burnburnburnburnburnburnburjAYjjX" : address); administrator = ("tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" : address); + marketmaker = ("tz1aSL2gjFnfh96Xf1Zp4T36LxbzKuzyvVJ4" : address); limit_on_tokens_or_pairs = 10n; deposit_time_window_in_seconds = 600n; } diff --git a/batcher/test/batcher/endpoints/admin/test_change_marketmaker_address.mligo b/batcher/test/batcher/endpoints/admin/test_change_marketmaker_address.mligo new file mode 100644 index 00000000..31fb4507 --- /dev/null +++ b/batcher/test/batcher/endpoints/admin/test_change_marketmaker_address.mligo @@ -0,0 +1,87 @@ + +#import "ligo-breathalyzer/lib/lib.mligo" "Breath" +#import "./../../../common/helpers.mligo" "Helpers" +#import "../../../../batcher.mligo" "Batcher" +#import "../../../../errors.mligo" "Errors" + + +let change_marketmaker_address_should_succeed_if_user_is_admin = + Breath.Model.case + "test change marketmaker address" + "should be successful if user is admin" + (fun (level: Breath.Logger.level) -> + let context = Helpers.test_context level in + let batcher = context.contracts.batcher in + let old_storage = Breath.Contract.storage_of batcher in + let new_address = context.btc_trader.address in + let act_change_marketmaker_address = Breath.Context.act_as context.admin (fun (_u:unit) -> (Breath.Contract.transfer_to batcher (Change_marketmaker_address new_address) 0tez)) in + let new_storage = Breath.Contract.storage_of batcher in + + Breath.Result.reduce [ + Breath.Assert.is_equal "old address" context.admin.address old_storage.marketmaker + ; act_change_marketmaker_address + ; Breath.Assert.is_equal "new address" new_address new_storage.marketmaker + ]) + +let change_marketmaker_address_should_fail_if_user_is_not_admin = + Breath.Model.case + "test change marketmaker address" + "should fail if user is not admin" + (fun (level: Breath.Logger.level) -> + let context = Helpers.test_context level in + let batcher = context.contracts.batcher in + let old_storage = Breath.Contract.storage_of batcher in + let new_address = context.usdt_trader.address in + let act_change_marketmaker_address = Breath.Context.act_as context.non_admin (fun (_u:unit) -> (Breath.Contract.transfer_to batcher (Change_marketmaker_address new_address) 0tez)) in + let new_storage = Breath.Contract.storage_of batcher in + + Breath.Result.reduce [ + Breath.Assert.is_equal "old address" context.admin.address old_storage.marketmaker + ; Breath.Expect.fail_with_value Errors.sender_not_administrator act_change_marketmaker_address + ; Breath.Assert.is_equal "address unchanged" context.admin.address new_storage.marketmaker + ]) + +let change_marketmaker_address_should_fail_if_tez_is_sent = + Breath.Model.case + "test change marketmaker address" + "should fail if tez is sent" + (fun (level: Breath.Logger.level) -> + let context = Helpers.test_context level in + let batcher = context.contracts.batcher in + let old_storage = Breath.Contract.storage_of batcher in + let new_address = context.usdt_trader.address in + let act_change_marketmaker_address = Breath.Context.act_as context.admin (fun (_u:unit) -> (Breath.Contract.transfer_to batcher (Change_marketmaker_address new_address) 5tez)) in + let new_storage = Breath.Contract.storage_of batcher in + + Breath.Result.reduce [ + Breath.Assert.is_equal "old address" context.admin.address old_storage.marketmaker + ; Breath.Expect.fail_with_value Errors.endpoint_does_not_accept_tez act_change_marketmaker_address + ; Breath.Assert.is_equal "address unchanged" context.admin.address new_storage.marketmaker + ]) + +let change_marketmaker_address_should_fail_if_new_address_is_the_same_as_fee_recipient = + Breath.Model.case + "test change marketmaker address" + "should fail if new address is the same as fee recipient" + (fun (level: Breath.Logger.level) -> + let context = Helpers.test_context level in + let batcher = context.contracts.batcher in + let old_storage = Breath.Contract.storage_of batcher in + let new_address = context.fee_recipient in + let act_change_marketmaker_address = Breath.Context.act_as context.admin (fun (_u:unit) -> (Breath.Contract.transfer_to batcher (Change_marketmaker_address new_address) 0tez)) in + let new_storage = Breath.Contract.storage_of batcher in + + Breath.Result.reduce [ + Breath.Assert.is_equal "old address" context.admin.address old_storage.marketmaker + ; Breath.Expect.fail_with_value Errors.admin_and_fee_recipient_address_cannot_be_the_same act_change_marketmaker_address + ; Breath.Assert.is_equal "address unchanged" context.admin.address new_storage.marketmaker + ]) + +let test_suite = + Breath.Model.suite "Suite for Change MarketMaker Address (Admin)" [ + change_marketmaker_address_should_succeed_if_user_is_admin + ; change_marketmaker_address_should_fail_if_user_is_not_admin + ; change_marketmaker_address_should_fail_if_tez_is_sent + ; change_marketmaker_address_should_fail_if_new_address_is_the_same_as_fee_recipient + ] + diff --git a/batcher/test/common/batch.mligo b/batcher/test/common/batch.mligo index f7c3c079..b7408671 100644 --- a/batcher/test/common/batch.mligo +++ b/batcher/test/common/batch.mligo @@ -226,7 +226,7 @@ let prepare_batch_with_status volumes = empty_volumes; pair = pair; holdings = 0n; - market_vault_used = (None: Batcher.side option); + market_vault_used = false; } in let test_cases = if pressure = Buy then buy_pressure_cases diff --git a/batcher/test/common/storage.mligo b/batcher/test/common/storage.mligo index 2a724e58..98fbacf4 100644 --- a/batcher/test/common/storage.mligo +++ b/batcher/test/common/storage.mligo @@ -111,6 +111,7 @@ let initial_storage_with_admin_and_fee_recipient fee_in_mutez = 10_000mutez; fee_recipient = fee_recipient; administrator = admin; + marketmaker = admin; limit_on_tokens_or_pairs = 10n; deposit_time_window_in_seconds = 600n; } diff --git a/batcher/test/test-batcher.mligo b/batcher/test/test-batcher.mligo index 6c01066f..c6aeab03 100644 --- a/batcher/test/test-batcher.mligo +++ b/batcher/test/test-batcher.mligo @@ -6,6 +6,7 @@ #import "./batcher/economics/test_clearing.mligo" "Economics_Clearing" #import "./batcher/endpoints/admin/test_change_fee.mligo" "Admin_Change_Fee" #import "./batcher/endpoints/admin/test_change_admin_address.mligo" "Admin_Change_Admin_Address" +#import "./batcher/endpoints/admin/test_change_marketmaker_address.mligo" "Admin_Change_MarketMaker_Address" #import "./batcher/endpoints/admin/test_change_fee_recipient_address.mligo" "Admin_Change_Fee_Recipient_Address" #import "./batcher/endpoints/admin/test_change_deposit_time_window.mligo" "Admin_Change_Deposit_Time_Window" #import "./batcher/endpoints/admin/test_enable_disable_swap_pair_for_deposit.mligo" "Admin_Enable_Disable_Swap_Pair" @@ -43,9 +44,10 @@ let () = Breath.Model.run_suites Void [ test_suite - ; Admin_Change_Fee.test_suite - ; Admin_Change_Admin_Address.test_suite - ; Admin_Change_Fee_Recipient_Address.test_suite + (*; Admin_Change_Fee.test_suite + ; Admin_Change_Admin_Address.test_suite *) + ; Admin_Change_MarketMaker_Address.test_suite + (* ; Admin_Change_Fee_Recipient_Address.test_suite ; Admin_Change_Deposit_Time_Window.test_suite ; Admin_Enable_Disable_Swap_Pair.test_suite ; Admin_Amend_Token_pair_Limit.test_suite @@ -55,7 +57,7 @@ let () = ; Maintenance_Tick.test_suite ; Economics_Clearing.test_suite ; User_Deposits.test_suite - ; User_Cancellations.test_suite + ; User_Cancellations.test_suite *) // ; User_Redemptions.test_suite ] diff --git a/batcher/types.mligo b/batcher/types.mligo index bc36a14c..eaf9480c 100644 --- a/batcher/types.mligo +++ b/batcher/types.mligo @@ -173,12 +173,13 @@ type batch = [@layout:comb] { volumes : volumes; pair : pair; holdings : nat; - market_vault_used : side option; + market_vault_used : bool; } type reduced_batch = [@layout:comb] { status: batch_status; volumes: volumes; + market_vault_used : bool; } type batch_indices = (string, nat) map @@ -219,8 +220,10 @@ type rates_current = (string, exchange_rate) big_map type fees = { to_send: tez; to_refund: tez; + to_market_maker: tez; payer: address; recipient: address; + market_maker: address; } type market_maker_vault = {