From 3de1457e9d48c8d210cc62aec616a94abf684fae Mon Sep 17 00:00:00 2001 From: Marcin Pastudzki Date: Thu, 2 Sep 2021 12:51:54 +0200 Subject: [PATCH 1/9] Migration: patch legacy scripts during protocol migration. Some scripts are using now forbidden commands and hence must be run in legacy mode. This is to patch them so that they no longer need that. --- src/proto_alpha/lib_protocol/TEZOS_PROTOCOL | 1 + src/proto_alpha/lib_protocol/dune.inc | 5 + src/proto_alpha/lib_protocol/init_storage.ml | 143 +++++++++++++++++- .../legacy_script_patches_for_J.ml | 119 +++++++++++++++ 4 files changed, 267 insertions(+), 1 deletion(-) create mode 100644 src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml diff --git a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL index f5a58f6a4bbc..3c1bc61756b0 100644 --- a/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL +++ b/src/proto_alpha/lib_protocol/TEZOS_PROTOCOL @@ -105,6 +105,7 @@ "Liquidity_baking_lqt", "Liquidity_baking_migration", + "Legacy_script_patches_for_J", "Init_storage", "Sapling_validator", diff --git a/src/proto_alpha/lib_protocol/dune.inc b/src/proto_alpha/lib_protocol/dune.inc index 7de5b2073b19..70f387323406 100644 --- a/src/proto_alpha/lib_protocol/dune.inc +++ b/src/proto_alpha/lib_protocol/dune.inc @@ -125,6 +125,7 @@ module CamlinternalFormatBasics = struct include CamlinternalFormatBasics end liquidity_baking_cpmm.ml liquidity_baking_lqt.ml liquidity_baking_migration.mli liquidity_baking_migration.ml + legacy_script_patches_for_J.ml init_storage.mli init_storage.ml sapling_validator.ml global_constants_costs.mli global_constants_costs.ml @@ -292,6 +293,7 @@ module CamlinternalFormatBasics = struct include CamlinternalFormatBasics end liquidity_baking_cpmm.ml liquidity_baking_lqt.ml liquidity_baking_migration.mli liquidity_baking_migration.ml + legacy_script_patches_for_J.ml init_storage.mli init_storage.ml sapling_validator.ml global_constants_costs.mli global_constants_costs.ml @@ -459,6 +461,7 @@ module CamlinternalFormatBasics = struct include CamlinternalFormatBasics end liquidity_baking_cpmm.ml liquidity_baking_lqt.ml liquidity_baking_migration.mli liquidity_baking_migration.ml + legacy_script_patches_for_J.ml init_storage.mli init_storage.ml sapling_validator.ml global_constants_costs.mli global_constants_costs.ml @@ -648,6 +651,7 @@ include Tezos_raw_protocol_alpha.Main Liquidity_baking_cpmm Liquidity_baking_lqt Liquidity_baking_migration + Legacy_script_patches_for_J Init_storage Sapling_validator Global_constants_costs @@ -856,6 +860,7 @@ include Tezos_raw_protocol_alpha.Main liquidity_baking_cpmm.ml liquidity_baking_lqt.ml liquidity_baking_migration.mli liquidity_baking_migration.ml + legacy_script_patches_for_J.ml init_storage.mli init_storage.ml sapling_validator.ml global_constants_costs.mli global_constants_costs.ml diff --git a/src/proto_alpha/lib_protocol/init_storage.ml b/src/proto_alpha/lib_protocol/init_storage.ml index 21f39fadcaeb..bafdda78973e 100644 --- a/src/proto_alpha/lib_protocol/init_storage.ml +++ b/src/proto_alpha/lib_protocol/init_storage.ml @@ -25,6 +25,144 @@ (* *) (*****************************************************************************) +module Patch_legacy_contracts_for_J = struct + open Legacy_script_patches_for_J + + let contract_patches = + [ + ( "KT1MzfYSbq18fYr4f44aQRoZBQN72BAtiz5j", + exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc ); + ( "KT1Kfbk3B6NYPCPohPBDU3Hxf5Xeyy9PdkNp", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1JW6PwhfaEJu6U3ENsxUeja48AdtqSoekd", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1VsSxSXUkgw6zkBGgUuDXXuJs9ToPqkrCg", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1TcAHw5gpejyemwRtdNyFKGBLc4qwA5gtw", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1FN5fcNNcgieGjzxbVEPWUpJGwZEpzNGA8", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1Um7ieBEytZtumecLqGeL56iY6BuWoBgio", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1QuofAgnsWffHzLA7D78rxytJruGHDe7XG", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1CSKPf2jeLpMmrgKquN2bCjBTkAcAdRVDy", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1D5NmtDtgCwPxYNb2ZK2But6dhNLs1T1bV", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1VvXEpeBpreAVpfp4V8ZujqWu2gVykwXBJ", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1TzamC1SCj68ia2E4q2GWZeT24yRHvUZay", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1LZFMGrdnPjRLsCZ1aEDUAF5myA5Eo4rQe", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1PDAELuX7CypUHinUgFgGFskKs7ytwh5Vw", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT19xDbLsvQKnp9xqfDNPWJbKJJmV93dHDUa", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1Cz7TyVFvHxXpxLS57RFePrhTGisUpPhvD", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1LQ99RfGcmFe98PiBcGXuyjBkWzAcoXXhW", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1Gow8VzXZx3Akn5kvjACqnjnyYBxQpzSKr", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1DnfT4hfikoMY3uiPE9mQV4y3Xweramb2k", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1FuFDZGdw86p6krdBUKoZfEMkcUmezqX5o", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1SLWhfqPtQq7f4zLomh8BNgDeprF9B6d2M", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1THsDNgHtN56ew9VVCAUWnqPC81pqAxCEp", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1CM1g1o9RKDdtDKgcBWE59X2KgTc2TcYtC", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1W148mcjmfvr9J2RvWcGHxsAFApq9mcfgT", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1HvwFnXteMbphi7mfPDhCWkZSDvXEz8iyv", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1RUT25eGgo9KKWXfLhj1xYjghAY1iZ2don", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1EWLAQGPMF2uhtVRPaCH2vtFVN36Njdr6z", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1WPEis2WhAc2FciM2tZVn8qe6pCBe9HkDp", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1Msatnmdy24sQt6knzpALs4tvHfSPPduA2", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1A56dh8ivKNvLiLVkjYPyudmnY2Ti5Sba3", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1KRyTaxCAM3YRquifEe29BDbUKNhJ6hdtx", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1FL3C6t9Lyfskyb6rQrCRQTnf7M9t587VM", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1Q1kfbvzteafLvnGz92DGvkdypXfTGfEA3", + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw ); + ( "KT1CjfCztmRpsyUee1nLa9Wcpfr7vgwqRZmk", + expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ ); + ( "KT1MHDHRLugz3A4qP6KqZDpa7FFmZfcJauV4", + expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU ); + ( "KT1BvVxWM6cjFuJNet4R9m64VDCN2iMvjuGE", + expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD ); + ( "KT1PyX9b8WmShQjqNgDQsvxqj9UYdmHLr3xg", + exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3 ); + ( "KT1XTXBsEauzcv3uPvVXW92mVqrx99UGsb9T", + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe ); + ( "KT1Puc9St8wdNoGtLiD2WXaHbWU7styaxYhD", + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe ); + ( "KT19c8n5mWrqpxMcR3J687yssHxotj88nGhZ", + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe ); + ( "KT1DrJV8vhkdLEj76h1H9Q4irZDqAkMPo1Qf", + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe ); + ( "KT1D68BvUm9N1fcq6uaZnyZvmBkBvj9biyPu", + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe ); + ( "KT1CT7S2b9hXNRxRrEcany9sak1qe4aaFAZJ", + exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg ); + ] + + let patch_script (address, {legacy_script_hash; patched_code}) ctxt = + Contract_repr.of_b58check address >>?= fun contract -> + Storage.Contract.Code.find ctxt contract >>=? fun (ctxt, code_opt) -> + Logging.log Notice "Patching %s... " address ; + match code_opt with + | Some old_code -> + let old_bin = Data_encoding.force_bytes old_code in + let old_hash = Script_expr_hash.hash_bytes [old_bin] in + if Script_expr_hash.equal old_hash legacy_script_hash then ( + let new_code = Script_repr.lazy_expr patched_code in + Logging.log Notice "Contract %s successfully patched" address ; + Storage.Contract.Code.update ctxt contract new_code + >>=? fun (ctxt, size_diff) -> + let size_diff = Z.of_int size_diff in + Storage.Contract.Used_storage_space.get ctxt contract + >>=? fun prev_size -> + let new_size = Z.add prev_size size_diff in + Storage.Contract.Used_storage_space.update ctxt contract new_size + >>=? fun ctxt -> + if Z.(gt size_diff zero) then + Storage.Contract.Paid_storage_space.get ctxt contract + >>=? fun prev_paid_size -> + let paid_size = Z.add prev_paid_size size_diff in + Storage.Contract.Paid_storage_space.update ctxt contract paid_size + else return ctxt) + else ( + Logging.log + Error + "Patching %s was skipped because its script does not have the \ + expected hash (expected: %a, found: %a)" + address + Script_expr_hash.pp + legacy_script_hash + Script_expr_hash.pp + old_hash ; + return ctxt) + | None -> + Logging.log + Error + "Patching %s was skipped because no script was found for it in the \ + context." + address ; + return ctxt +end + (* To add invoices, you can use a helper function like this one: @@ -122,7 +260,10 @@ let prepare_first_block ctxt ~typecheck ~level ~timestamp = >>=? fun (ctxt, balance_updates) -> Receipt_repr.group_balance_updates balance_updates >>?= fun balance_updates -> Storage.Pending_migration.Balance_updates.add ctxt balance_updates - >>= fun ctxt -> return ctxt + >>= fun ctxt -> + Patch_legacy_contracts_for_J.( + List.fold_right_es patch_script contract_patches ctxt) + >>=? fun ctxt -> return ctxt let prepare ctxt ~level ~predecessor_timestamp ~timestamp = Raw_context.prepare ~level ~predecessor_timestamp ~timestamp ctxt diff --git a/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml b/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml new file mode 100644 index 000000000000..f3ee4d8ed5a7 --- /dev/null +++ b/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml @@ -0,0 +1,119 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +type patched_script = { + legacy_script_hash : Script_expr_hash.t; + patched_code : Michelson_v1_primitives.prim Micheline.canonical; +} + +let bin_expr_exn hex = + match + Option.bind + (Hex.to_bytes @@ `Hex hex) + (fun bytes -> + Data_encoding.Binary.of_bytes_opt Script_repr.expr_encoding bytes) + with + | Some expr -> expr + | None -> raise (Failure "Decoding script failed.") + +let exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc"; + patched_code = + bin_expr_exn + "02000001d305000764085e036c055f036d0000000325646f046c000000082564656661756c7405010765035d036e050202000001a303210316072e02000000930743036a00000313020000001e020000000403190325072c020000000002000000090200000004034f0327020000000b051f02000000020321034c03170316031e0354034802000000490319033c072c020000002a034807430368010000001b4f6e6c7920746865206f776e65722063616e206f7065726174652e03420327020000000f034f0326051f0200000002031703420200000100051f0200000006031703210317034202000000c203170321053d036d0200000014051f020000000b051f02000000020321034c034c0200000017051f0200000010051f0200000009051f02000000020320055507640563036e076407650563036e0563036a0764036a076407650563036e0563036a036e020000002e072f020000002207430368010000001742616420636f6e747261637420696e2073746f72616765032702000000000313034803460533076407650563036e0563036a0764036a076407650563036e0563036a036e034d031b0342034c0316034c0200000012020000000d03210316051f02000000020317051f0200000004034c03420342"; + } + +let exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw"; + patched_code = + bin_expr_exn + "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"; + } + +let expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ"; + patched_code = + bin_expr_exn + "02000001d405000764085e036c055f036d0000000325646f046c000000082564656661756c7405010765035d036e050202000001a403210316072e02000000930743036a00000313020000001e020000000403190325072c020000000002000000090200000004034f0327020000000b051f02000000020321034c03170316031e0354034802000000490319033c072c020000002a034807430368010000001b4f6e6c7920746865206f776e65722063616e206f7065726174652e03420327020000000f034f0326051f0200000002031703420200000101051f0200000006031703210317034202000000c303170321053d036d0200000014051f020000000b051f02000000020321034c034c0200000017051f0200000010051f0200000009051f02000000020320055507640563036e076407650563036e0563036a0764036a076407650563036e0563036a036e020000002f072f020000002307430368010000001842616420636f6e747261637420696e2073746f7261676521032702000000000313053e036a03480346034205330764036a076407650563036e0563036a036e05440563036e034d031b0342034c0316034c0200000012020000000d03210316051f02000000020317051f0200000004034c03420342"; + } + +let expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU"; + patched_code = + bin_expr_exn + "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"; + } + +let expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD"; + patched_code = + bin_expr_exn + "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"; + } + +let exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3 = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3"; + patched_code = + bin_expr_exn + "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"; + } + +let expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe"; + patched_code = + bin_expr_exn + "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"; + } + +let exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg = + { + legacy_script_hash = + Script_expr_hash.of_b58check_exn + "exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg"; + patched_code = + bin_expr_exn + "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"; + } -- GitLab From 2e96957c37b2c038de8c3860ad09748a59cf2f58 Mon Sep 17 00:00:00 2001 From: Marcin Pastudzki Date: Tue, 12 Oct 2021 15:57:04 +0200 Subject: [PATCH 2/9] Tezt: Add more client commands to the library. --- tezt/lib_tezos/client.ml | 62 +++++++++++++++++++++++++++++++++-- tezt/lib_tezos/client.mli | 27 +++++++++++++++ tezt/lib_tezos/tez.ml | 4 +++ tezt/lib_tezos/tez.mli | 6 ++++ tezt/tests/mockup.ml | 7 +--- tezt/tests/protocol_limits.ml | 5 +-- 6 files changed, 99 insertions(+), 12 deletions(-) diff --git a/tezt/lib_tezos/client.ml b/tezt/lib_tezos/client.ml index fe26bd68f327..2c219a54614c 100644 --- a/tezt/lib_tezos/client.ml +++ b/tezt/lib_tezos/client.ml @@ -629,7 +629,7 @@ let spawn_transfer ?hooks ?endpoint ?(wait = "none") ?burn_cap ?fee ?gas_limit @ if force then ["--force"] else []) let transfer ?hooks ?endpoint ?wait ?burn_cap ?fee ?gas_limit ?storage_limit - ?counter ?arg ?force ~amount ~giver ~receiver client = + ?counter ?arg ?force ?expect_failure ~amount ~giver ~receiver client = spawn_transfer ?endpoint ?hooks @@ -645,7 +645,7 @@ let transfer ?hooks ?endpoint ?wait ?burn_cap ?fee ?gas_limit ?storage_limit ~giver ~receiver client - |> Process.check + |> Process.check ?expect_failure let spawn_multiple_transfers ?endpoint ?(wait = "none") ?burn_cap ?fee_cap ?gas_limit ?storage_limit ?counter ?arg ~giver ~json_batch client = @@ -692,6 +692,15 @@ let multiple_transfers ?endpoint ?wait ?burn_cap ?fee_cap ?gas_limit client |> Process.check +let spawn_get_delegate ?endpoint ~src client = + spawn_command ?endpoint client ["get"; "delegate"; "for"; src] + +let get_delegate ?endpoint ~src client = + let* output = + spawn_get_delegate ?endpoint ~src client |> Process.check_and_read_stdout + in + Lwt.return (output =~* rex "(tz[a-zA-Z0-9]+) \\(.*\\)") + let spawn_set_delegate ?endpoint ?(wait = "none") ~src ~delegate client = spawn_command ?endpoint @@ -1563,3 +1572,52 @@ let init_with_protocol ?path ?admin_path ?name ?color ?base_dir ?event_level in let* _ = Node.wait_for_level node 1 in return (node, client) + +let register_key owner client = + spawn_command + client + ["--wait"; "none"; "register"; "key"; owner; "as"; "delegate"] + |> Process.check + +let contract_storage ?unparsing_mode address client = + let unparsing_mode_to_string = function + | `Optimized -> "Optimized" + | `Optimized_legacy -> "Optimized_legacy" + | `Readable -> "Readable" + in + spawn_command + client + (["get"; "contract"; "storage"; "for"; address] + @ Option.fold + ~none:[] + ~some:(fun u -> ["--unparsing-mode"; unparsing_mode_to_string u]) + unparsing_mode) + |> Process.check_and_read_stdout + +let sign_bytes ~signer ~data client = + let* output = + spawn_command client ["sign"; "bytes"; data; "for"; signer] + |> Process.check_and_read_stdout + in + match output =~* rex "Signature: ([a-zA-Z0-9]+)" with + | Some signature -> Lwt.return signature + | None -> Test.fail "Couldn't sign message '%s' for %s." data signer + +let convert_script ~script ~src_format ~dst_format client = + let fmt_to_string = function + | `Michelson -> "michelson" + | `Binary -> "binary" + | `Json -> "json" + in + spawn_command + client + [ + "convert"; + "script"; + script; + "from"; + fmt_to_string src_format; + "to"; + fmt_to_string dst_format; + ] + |> Process.check_and_read_stdout diff --git a/tezt/lib_tezos/client.mli b/tezt/lib_tezos/client.mli index 30da42e6f6e4..e56160f75ec1 100644 --- a/tezt/lib_tezos/client.mli +++ b/tezt/lib_tezos/client.mli @@ -443,6 +443,7 @@ val transfer : ?counter:int -> ?arg:string -> ?force:bool -> + ?expect_failure:bool -> amount:Tez.t -> giver:string -> receiver:string -> @@ -497,6 +498,10 @@ val spawn_multiple_transfers : t -> Process.t +(** Run tezos-client get delegate for . Returns [Some address] if delegate + is set or [None] otherwise. *) +val get_delegate : ?endpoint:endpoint -> src:string -> t -> string option Lwt.t + (** Run [tezos-client set delegate for to ]. *) val set_delegate : ?endpoint:endpoint -> @@ -1128,3 +1133,25 @@ val spawn_command : t -> string list -> Process.t + +(** Register public key for given account with given client. *) +val register_key : string -> t -> unit Lwt.t + +(** Get contract storage for a contract. Returns a Micheline expression + representing the storage as a string. *) +val contract_storage : + ?unparsing_mode:[`Optimized | `Optimized_legacy | `Readable] -> + string -> + t -> + string Lwt.t + +(** Sign a string of bytes with secret key of the given account. *) +val sign_bytes : signer:string -> data:string -> t -> string Lwt.t + +(** Use tezos-client to convert a script between given forms. *) +val convert_script : + script:string -> + src_format:[`Michelson | `Json | `Binary] -> + dst_format:[`Michelson | `Json | `Binary] -> + t -> + string Lwt.t diff --git a/tezt/lib_tezos/tez.ml b/tezt/lib_tezos/tez.ml index aa9ac628f223..4d22e76b99fb 100644 --- a/tezt/lib_tezos/tez.ml +++ b/tezt/lib_tezos/tez.ml @@ -33,6 +33,8 @@ let zero = 0L let one = of_int 1 +let mutez_int64 t = t + let to_string amount = let mult_int = 1_000_000L in let rec left amount = @@ -62,6 +64,8 @@ let to_mutez amount = Int64.to_int amount let ( + ) = Int64.add +let ( - ) = Int64.sub + let parse_floating tez_string = let re = rex "(\\d+)\\.?(\\d*)" in let fail () = Test.fail "Invalid tez value: '%s'." tez_string in diff --git a/tezt/lib_tezos/tez.mli b/tezt/lib_tezos/tez.mli index 4b1d98d34711..56f0b05450a2 100644 --- a/tezt/lib_tezos/tez.mli +++ b/tezt/lib_tezos/tez.mli @@ -47,6 +47,9 @@ val one : t (** Convert [t] to a string. *) val to_string : t -> string +(** Convert [t] to a mutez integer. *) +val mutez_int64 : t -> int64 + (** Convert [t] to a float of tez. *) val to_float : t -> float @@ -56,6 +59,9 @@ val to_mutez : t -> int (** Addition. This doesn't perform any bounds checks. *) val ( + ) : t -> t -> t +(** Subtraction. This doesn't perform any bound checks. *) +val ( - ) : t -> t -> t + (** Parsing. Parse a floating point number of tez. Any string of digits followed by an optional point and another string diff --git a/tezt/tests/mockup.ml b/tezt/tests/mockup.ml index baf19dd5339b..2c0324dff468 100644 --- a/tezt/tests/mockup.ml +++ b/tezt/tests/mockup.ml @@ -66,12 +66,7 @@ let transfer_data = let test_balances_after_transfer giver amount receiver = let (giver_balance_before, giver_balance_after) = giver in let (receiver_balance_before, receiver_balance_after) = receiver in - if - not - Tez.( - to_mutez giver_balance_after - < to_mutez giver_balance_before - to_mutez amount) - then + if not Tez.(giver_balance_after < giver_balance_before - amount) then Test.fail "Invalid balance of giver after transfer: %s (before it was %s)" (Tez.to_string giver_balance_after) diff --git a/tezt/tests/protocol_limits.ml b/tezt/tests/protocol_limits.ml index f0ef48ad798c..bbaf4553cef4 100644 --- a/tezt/tests/protocol_limits.ml +++ b/tezt/tests/protocol_limits.ml @@ -58,10 +58,7 @@ let test_gas_storage_limits = let* giver_balance = Client.get_balance_for ~account:giver client in let* receiver_balance = Client.get_balance_for ~account:receiver client in let expected_receiver_balance = Tez.(initial_receiver_balance + amount) in - let expected_giver_balance = - Tez.( - of_mutez_int @@ (to_mutez initial_giver_balance - to_mutez (fee + amount))) - in + let expected_giver_balance = Tez.(initial_giver_balance - (fee + amount)) in let* () = if receiver_balance <> expected_receiver_balance then Test.fail -- GitLab From de9835c104e73c28195ff75fa7e7b9d1f656995b Mon Sep 17 00:00:00 2001 From: Marcin Pastudzki Date: Tue, 12 Oct 2021 15:57:59 +0200 Subject: [PATCH 3/9] Tezt: Add a vesting contract tezt. --- .../alpha_parameters.json | 26 + tezt/vesting_contract_test/contract.tz | 240 +++ .../vesting_contract_test/contract_storage.ml | 129 ++ tezt/vesting_contract_test/dune | 9 + tezt/vesting_contract_test/empty.tz | 3 + tezt/vesting_contract_test/main.ml | 60 + tezt/vesting_contract_test/state.ml | 114 ++ tezt/vesting_contract_test/test_michelson.ml | 111 ++ tezt/vesting_contract_test/vesting_test.ml | 1299 +++++++++++++++++ 9 files changed, 1991 insertions(+) create mode 100644 tezt/vesting_contract_test/alpha_parameters.json create mode 100644 tezt/vesting_contract_test/contract.tz create mode 100644 tezt/vesting_contract_test/contract_storage.ml create mode 100644 tezt/vesting_contract_test/dune create mode 100644 tezt/vesting_contract_test/empty.tz create mode 100644 tezt/vesting_contract_test/main.ml create mode 100644 tezt/vesting_contract_test/state.ml create mode 100644 tezt/vesting_contract_test/test_michelson.ml create mode 100644 tezt/vesting_contract_test/vesting_test.ml diff --git a/tezt/vesting_contract_test/alpha_parameters.json b/tezt/vesting_contract_test/alpha_parameters.json new file mode 100644 index 000000000000..760a61862cad --- /dev/null +++ b/tezt/vesting_contract_test/alpha_parameters.json @@ -0,0 +1,26 @@ +{ "bootstrap_accounts": + [ [ "edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav", + "4000000000000" ], + [ "edpktzNbDAUjUk697W7gYg2CRuBQjyPxbEg8dLccYYwKSKvkPvjtV9", + "4000000000000" ], + [ "edpkuTXkJDGcFd5nh6VvMz8phXxU3Bi7h6hqgywNFi1vZTfQNnS1RV", + "4000000000000" ], + [ "edpkuFrRoDSEbJYgxRtLx2ps82UdaYc1WwfS9sE11yhauZt5DgCHbU", + "4000000000000" ], + [ "edpkv8EUUH68jmo3f7Um5PezmfGrRF24gnfLpH3sVNwJnV5bVCxL2n", + "4000000000000" ] ], "preserved_cycles": 2, "blocks_per_cycle": 8, + "blocks_per_commitment": 4, "blocks_per_roll_snapshot": 4, + "blocks_per_voting_period": 64, "time_between_blocks": [ "0" ], + "endorsers_per_block": 256, "hard_gas_limit_per_operation": "1040000", + "hard_gas_limit_per_block": "5200000", "proof_of_work_threshold": "-1", + "tokens_per_roll": "8000000000", "seed_nonce_revelation_tip": "125000", + "origination_size": 257, "block_security_deposit": "640000000", + "endorsement_security_deposit": "2500000", + "baking_reward_per_endorsement": [ "78125", "11719" ], + "endorsement_reward": [ "78125", "52083" ], "cost_per_byte": "250", + "hard_storage_limit_per_operation": "60000", "quorum_min": 2000, + "quorum_max": 7000, "min_proposal_quorum": 500, "initial_endorsers": 1, + "delay_per_missing_endorsement": "1", "minimal_block_delay": "0", + "liquidity_baking_subsidy": "2500000", + "liquidity_baking_sunset_level": 4096, + "liquidity_baking_escape_ema_threshold": 1000000 } diff --git a/tezt/vesting_contract_test/contract.tz b/tezt/vesting_contract_test/contract.tz new file mode 100644 index 000000000000..8c27f16995a3 --- /dev/null +++ b/tezt/vesting_contract_test/contract.tz @@ -0,0 +1,240 @@ +{ parameter + (or (pair %Action + (or %action_input + (or (pair %Transfer (contract %dest unit) (mutez %transfer_amount)) + (option %Set_pour (pair (contract %pour_dest unit) (key %pour_authorizer)))) + (or (pair %Set_keys + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold)) + (option %Set_delegate key_hash))) + (list %signatures (list (option signature)))) + (option (pair (signature %pour_auth) (mutez %pour_amount)))) ; + storage + (pair (pair (nat %replay_counter) + (pair %key_info + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold))) + (pair (pair %vesting + (pair %vesting_quantities (mutez %vested_balance) (mutez %vesting_increment)) + (pair %vesting_schedule (timestamp %next_payout) (int %payout_interval))) + (option (pair (address %pour_dest) (key %pour_authorizer))))) ; + code { DUP ; + CAR ; + IF_LEFT + { DIP { CDR ; DUP ; NIL @operations operation ; SWAP } ; + SWAP ; + CAR ; + DUP ; + CDR %key_info @% ; + DIP { CAR %replay_counter @% ; + DIP { DUP ; CDR %signatures @% } ; + SWAP ; + DIP { DIP { CAR %action_input @% ; DUP } ; + SELF ; + ADDRESS ; + PAIR ; + SWAP ; + PAIR ; + PACK @packed } } ; + SWAP ; + DIP { DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @% ; INT @overall_counter ; SWAP } } ; + ITER { DIP { IF_CONS + { DIP { SWAP } ; + DUP ; + CAR @%% ; + DIP { CDR @%% ; INT @group_counter ; SWAP } } + { { UNIT ; FAILWITH } } } ; + ITER { DIP { IF_CONS {} { { UNIT ; FAILWITH } } } ; + IF_NONE + { DROP } + { SWAP ; + DIP { DIP { SWAP ; DIP { DIP { PUSH int -1 ; ADD @group_counter } } ; DUP } } ; + CHECK_SIGNATURE @sig_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + SWAP } } ; + { DIP { DIP { PUSH int 0 ; + { COMPARE ; GE @group_threshold_met } ; + IF { DIP { PUSH int -1 ; ADD @overall_counter } } {} } } } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + SWAP } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + DROP ; + PUSH int 0 ; + { COMPARE ; GE @overall_threshold_met } ; + { IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DIP { DUP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + PUSH nat 1 ; + ADD @replay_counter ; + DIP { CDR %key_info @% } ; + PAIR %@ %@ ; + DIP { CDR } ; + PAIR } } } ; + IF_LEFT + { IF_LEFT + { DUP ; + DIP { CDR %transfer_amount @% ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; + CDR ; + DUP ; + CAR ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + SWAP ; + SUB_MUTEZ @vested_balance ; + IF_NONE { UNIT ; FAILWITH } { RENAME @vested_balance } ; + DIP { CDR %vesting_increment @% } ; + PAIR @vesting_quantities %@ %@ ; + DIP { DUP ; CAR ; CDR %vesting_schedule @% ; DIP { CDR %pour_info @% } } ; + PAIR @vesting %@ %@ ; + PAIR %@ %@ ; + SWAP ; + CAR ; + PAIR } } ; + DUP ; + CDR %transfer_amount @% ; + DIP { CAR %dest @% } ; + UNIT ; + TRANSFER_TOKENS @transfer_op ; + CONS @operations } + { SWAP ; + DIP { { IF_NONE + { NONE (pair address key) } + { { DUP ; CDR @%% ; DIP { CAR ; { ADDRESS } } ; SWAP ; PAIR % %@ } ; + SOME } } ; + SWAP ; + DUP ; + CAR ; + DIP { CDR ; CAR %vesting @% ; PAIR %vesting %pour_info } ; + PAIR @storage } } } + { IF_LEFT + { DUP ; + DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @new_threshold ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH @counter nat 0 } ; + ITER { DUP ; + CAR %signatories @%% ; + DIP { CDR %group_threshold @%% ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } } ; + SIZE @num_keys ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH nat 1 ; + ADD @counter } ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; CAR ; CAR %replay_counter } ; + SWAP ; + PAIR %@ %key_info ; + DIP { CDR } ; + PAIR @storage } } + { SET_DELEGATE @set_delegate_op ; CONS } } ; + PAIR } + { IF_NONE + { CDR ; + DUP ; + CDR ; + DUP ; + DIP { CDR %pour_info @% } ; + CAR %vesting @% ; + DUP ; + CDR %vesting_schedule @% ; + DUP ; + CAR %next_payout @% ; + DUP ; + NOW ; + { COMPARE ; GT } ; + { IF {} { { UNIT ; FAILWITH } } } ; + DIP { CDR %payout_interval @% ; DUP } ; + ADD @new_next_payout ; + PAIR %next_payout %@ @new_vesting_schedule ; + SWAP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DIP { CDR %vesting_increment @% ; DUP } ; + ADD @new_balance ; + PAIR %vested_balance %@ ; + PAIR %vesting_quantities %vesting_schedule ; + PAIR %vesting %@ ; + SWAP ; + CAR ; + PAIR @storage ; + NIL operation } + { DIP { CDR ; + DUP ; + CDR ; + DUP ; + CAR %vesting @% ; + DUP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { CDR %pour_amount @%% ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + SUB_MUTEZ @new_cur_balance ; + IF_NONE { UNIT ; FAILWITH } {} ; + DIP { CDR %vesting_increment @% } ; + PAIR %vested_balance %@ @vesting_quantities ; + DIP { CDR %vesting_schedule @% } ; + PAIR %@ %@ @vesting ; + DIP { CDR %pour_info @% ; DUP ; IF_NONE { { UNIT ; FAILWITH } } {} } ; + SWAP ; + DIP { PAIR %@ %@ ; + SWAP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + DUP ; + PUSH nat 1 ; + ADD @replay_counter ; + SWAP ; + SELF ; + ADDRESS ; + PAIR ; + DIP { DIP { CDR %key_info @% } ; PAIR %@ %@ ; PAIR @storage } } } ; + DUP ; + DIP { SWAP ; + DUP ; + CAR %pour_dest @% ; + CONTRACT unit ; + { IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} } ; + DIP { DUP ; + CDR %pour_authorizer @% ; + DIP { CAR %pour_dest @% ; + SWAP ; + DUP ; + CAR %pour_auth @% ; + DIP { CDR %pour_amount @% ; SWAP ; PAIR ; PAIR ; PACK @packed } } ; + CHECK_SIGNATURE @pour_auth_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + NIL operation } } ; + CDR %pour_amount @% ; + UNIT ; + TRANSFER_TOKENS @pour_op ; + CONS } ; + PAIR } } } diff --git a/tezt/vesting_contract_test/contract_storage.ml b/tezt/vesting_contract_test/contract_storage.ml new file mode 100644 index 000000000000..9b9589376e7f --- /dev/null +++ b/tezt/vesting_contract_test/contract_storage.ml @@ -0,0 +1,129 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +type key_group = {signatories : string list; group_treshold : int} + +type key_info = {key_groups : key_group list; overall_treshold : int} + +type pour_info = {pour_dest : string; pour_authorizer : string} + +type t = { + replay_counter : int; + key_info : key_info; + vested_balance : Tez.t; + vesting_increment : Tez.t; + next_payout : Ptime.t; + payout_interval : Ptime.Span.t; + pour_info : pour_info option; +} + +let initial ?overall_treshold ?(vesting_increment = Tez.of_int 100) + ?(next_payout = Ptime.epoch) ?(payout_interval = Ptime.Span.of_int_s 60) + ?pour_info keys = + let overall_treshold = + Option.value ~default:(List.length keys - 1) overall_treshold + in + { + replay_counter = 0; + key_info = + { + key_groups = + List.map (fun (ks, t) -> {signatories = ks; group_treshold = t}) keys; + overall_treshold; + }; + vested_balance = Tez.zero; + vesting_increment; + next_payout; + payout_interval; + pour_info; + } + +let update_keys key_groups overall_treshold s = + { + s with + key_info = {key_groups; overall_treshold}; + replay_counter = s.replay_counter + 1; + } + +let increment_vested_balance s = + {s with vested_balance = Tez.(s.vested_balance + s.vesting_increment)} + +let next_payout s = + { + s with + next_payout = + Option.value + ~default:Ptime.epoch + (Ptime.add_span s.next_payout s.payout_interval); + } + +let pay_out amount s = + { + s with + vested_balance = Tez.(s.vested_balance - amount); + replay_counter = s.replay_counter + 1; + } + +let bump_replay_counter s = {s with replay_counter = s.replay_counter + 1} + +let set_pour_info info s = + {s with pour_info = info; replay_counter = s.replay_counter + 1} + +let interval (span : Ptime.span) = Int.of_float @@ Ptime.Span.to_float_s span + +let pour_info_micheline pi = + let open Test_michelson in + optional (fun i -> pair (str i.pour_dest) (str i.pour_authorizer)) pi + +let key_groups_micheline key_groups = + let open Test_michelson in + list + @@ List.map + (fun {signatories; group_treshold} -> + pair (list @@ List.map str signatories) (num group_treshold)) + key_groups + +let key_info_micheline {key_groups; overall_treshold} = + let open Test_michelson in + pair (key_groups_micheline key_groups) (num overall_treshold) + +let to_micheline storage = + let open Test_michelson in + tuple + [ + tuple + [ + num storage.replay_counter; + key_groups_micheline storage.key_info.key_groups; + num storage.key_info.overall_treshold; + ]; + tuple + [ + tuple [tez storage.vested_balance; tez storage.vesting_increment]; + timestamp storage.next_payout; + num @@ interval storage.payout_interval; + ]; + pour_info_micheline storage.pour_info; + ] diff --git a/tezt/vesting_contract_test/dune b/tezt/vesting_contract_test/dune new file mode 100644 index 000000000000..2fddb3077d71 --- /dev/null +++ b/tezt/vesting_contract_test/dune @@ -0,0 +1,9 @@ +(executable + (name main) + (libraries tezos-stdlib + tezos-alpha-test-helpers + tezos-micheline + tezos-protocol-alpha + tezt-tezos + ptime) + (flags (:standard -open Tezt -open Tezt_tezos -open Tezt.Base -open Tezos_stdlib))) diff --git a/tezt/vesting_contract_test/empty.tz b/tezt/vesting_contract_test/empty.tz new file mode 100644 index 000000000000..1b65230b92ff --- /dev/null +++ b/tezt/vesting_contract_test/empty.tz @@ -0,0 +1,3 @@ +code { CDR ; NIL operation ; PAIR }; +storage unit; +parameter unit; diff --git a/tezt/vesting_contract_test/main.ml b/tezt/vesting_contract_test/main.ml new file mode 100644 index 000000000000..8e0a1fde768e --- /dev/null +++ b/tezt/vesting_contract_test/main.ml @@ -0,0 +1,60 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +(* Testing + ------- + Component: Vesting contract + Invocation: dune exec tezt/vesting_contract_test/main.exe + Subject: This file runs a test suite for the vesting contract. It supports + the original version of the contract, executed under Athens + protocol which is the last protocol, where this version can be + originated. It also can execute against the patched version under + protocol Alpha. +*) + +let tests = + let open Vesting_test in + [ + (transfer_and_pour_happy_path, "transfer_and_pour_happy_path", 6); + (test_delegation, "test_delegation", 5); + (test_invalid_transfers, "test_invalid_transfers", 6); + (test_update_keys, "test_update_keys", 8); + (test_all_sigs_required, "test_all_sigs_required", 7); + (test_full_contract, "test_full_contract", 28); + ] + +let () = + (* Register your tests here. *) + Cli.init () ; + List.iter + (fun (test, title, user_count) -> + Test.register + ~__FILE__ + ~title + ~tags:["vesting"; title] + (Vesting_test.execute ~contract:"contract.tz" ~user_count test)) + tests ; + (* [Test.run] must be the last function to be called. *) + Test.run () diff --git a/tezt/vesting_contract_test/state.ml b/tezt/vesting_contract_test/state.ml new file mode 100644 index 000000000000..87bd4ea65bed --- /dev/null +++ b/tezt/vesting_contract_test/state.ml @@ -0,0 +1,114 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +type ('a, 's) t = 's -> 'a * 's + +let get : ('s, 's) t = fun s -> (s, s) + +let getf : ('s -> 'a) -> ('a, 's) t = fun f s -> (f s, s) + +let put : 's -> (unit, 's) t = fun s _ -> ((), s) + +let update : ('s -> 's) -> (unit, 's) t = fun f s -> ((), f s) + +let map : ('a -> 'b) -> ('a, 's) t -> ('b, 's) t = + fun f m s -> + let (a, s') = m s in + (f a, s') + +let bind : ('a -> ('b, 's) t) -> ('a, 's) t -> ('b, 's) t = + fun f m s -> + let (a, s') = m s in + f a s' + +module type MONAD = sig + type 'a t + + val return : 'a -> 'a t + + val map : ('a -> 'b) -> 'a t -> 'b t + + val bind : 'a t -> ('a -> 'b t) -> 'b t +end + +module Monad (State : sig + type t +end) +(M : MONAD) = +struct + type nonrec 'a t = State.t -> ('a * State.t) M.t + + let return a s = M.return (a, s) + + let map f m s = M.map (fun (a, s') -> (f a, s')) @@ m s + + let bind m f s = M.bind (m s) @@ fun (a, s') -> f a s' + + let ( >|= ) m f = map f m + + let ( let+ ) m f = map f m + + let ( >>= ) m f = bind m f + + let ( let* ) m f = bind m f + + let lift m s = M.map (fun a -> (a, s)) m + + let get s = M.return (s, s) + + let getf f s = M.return (f s, s) + + let put s _ = M.return ((), s) + + let update f s = M.return ((), f s) + + let run s m = m s + + let eval s m = M.map fst (m s) + + let exec s m = M.map snd (m s) + + let rec list_map : ('a -> 'b t) -> 'a list -> 'b list t = + fun f l -> + match l with + | [] -> return [] + | x :: xs -> + let* y = f x in + let* ys = list_map f xs in + return (y :: ys) + + let iter_int : (int -> unit t) -> int -> unit t = + fun f i -> + let rec exec i = + if i < 0 then return () + else + let* () = f i in + exec (i - 1) + in + exec (i - 1) + + let opt_map : ('a -> 'b t) -> 'a option -> 'b option t = + fun f -> function None -> return None | Some a -> map Option.some (f a) +end diff --git a/tezt/vesting_contract_test/test_michelson.ml b/tezt/vesting_contract_test/test_michelson.ml new file mode 100644 index 000000000000..e00785f08b39 --- /dev/null +++ b/tezt/vesting_contract_test/test_michelson.ml @@ -0,0 +1,111 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +open Tezos_micheline +open Micheline + +let no_comment : Micheline_printer.location = {comment = None} + +let nullary prim = Prim (no_comment, prim, [], []) + +let unary prim arg = Prim (no_comment, prim, [arg], []) + +let binary prim l r = Prim (no_comment, prim, [l; r], []) + +let unit = nullary "Unit" + +let none = nullary "None" + +let some = unary "Some" + +let num n = Int (no_comment, Z.of_int n) + +let tez t = Int (no_comment, Z.of_int64 @@ Tez.mutez_int64 t) + +let str s = String (no_comment, s) + +let tuple args = Prim (no_comment, "Pair", args, []) + +let left = unary "Left" + +let right = unary "Right" + +let optional constr = function None -> none | Some x -> some (constr x) + +let rec pairs = function + | [] -> Prim (no_comment, "Pair", [], []) + | [x] -> x + | x :: xs -> Prim (no_comment, "Pair", [x; pairs xs], []) + +let pair = binary "Pair" + +let timestamp t = String (no_comment, Ptime.to_rfc3339 ~tz_offset_s:0 t) + +let list xs = Seq (no_comment, xs) + +module Types = struct + let unit = nullary "unit" + + let nat = nullary "nat" + + let key = nullary "key" + + let key_hash = nullary "key_hash" + + let signature = nullary "signature" + + let mutez = nullary "mutez" + + let address = nullary "address" + + let contract = unary "contract" + + let option = unary "option" + + let list = unary "list" + + let pair = binary "pair" + + let tuple elems = Prim (no_comment, "Pair", elems, []) + + let either = binary "or" (* "or" is unfortunately a keyword *) +end + +let to_string expr = Format.asprintf "%a" Micheline_printer.print_expr expr + +let encoding = + Micheline_encoding.canonical_encoding + ~variant:"tezt-michelson-repr" + Data_encoding.string + +let parse code = + let (tokens, errors) = Micheline_parser.tokenize code in + let* () = + if List.compare_length_with errors 0 >= 0 then Lwt.return () + else Test.fail "Couldn't tokenize Micheline!" + in + let (expr, errors) = Micheline_parser.parse_expression tokens in + if List.compare_length_with errors 0 >= 0 then Lwt.return expr + else Test.fail "Couldn't parse Micheline!" diff --git a/tezt/vesting_contract_test/vesting_test.ml b/tezt/vesting_contract_test/vesting_test.ml new file mode 100644 index 000000000000..4d0d234ec55e --- /dev/null +++ b/tezt/vesting_contract_test/vesting_test.ml @@ -0,0 +1,1299 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +module StateRecord = struct + type t = { + node : Node.t; + client : Client.t; + keys : Account.key Array.t; + vesting_contract : string; + storage : Contract_storage.t; + } + + let get_client {client; _} = client + + let get_keys {keys; _} = keys + + let key i {keys; _} = Array.get keys i +end + +module StateMonad = struct + include State.Monad (StateRecord) (Lwt) + + let parameter_file = "src/proto_alpha/parameters/sandbox-parameters.json" + + let client = getf StateRecord.get_client + + let rec update_storage = function + | [] -> return () + | f :: fs -> + let* () = + update (fun s -> StateRecord.{s with storage = f s.storage}) + in + update_storage fs + + let alias = function + | `Alias alias -> return alias + | `User i -> + let+ k = getf (StateRecord.key i) in + k.alias + + let user_address i = + let+ k = getf (StateRecord.key i) in + k.public_key_hash + + let user_pk i = + let+ k = getf (StateRecord.key i) in + k.public_key + + let initialise_vesting_state ?overall_treshold ?vesting_increment ?next_payout + ?payout_interval ?pour_info key_indices = + let* keys = getf StateRecord.get_keys in + let storage = + Contract_storage.initial + ?overall_treshold + ?vesting_increment + ?next_payout + ?payout_interval + ?pour_info + @@ List.map + Account.( + fun (idx, treshold) -> + let ks = List.map (fun i -> (Array.get keys i).public_key) idx in + (ks, treshold)) + key_indices + in + update (fun s -> StateRecord.{s with storage}) + + let bake = + let* c = client in + lift @@ Client.bake_for c + + let activate_alpha = + let* c = client in + let* () = + lift + @@ Client.activate_protocol ~protocol:Protocol.Alpha ~parameter_file c + in + bake + + let transfer ?endpoint ?wait ?burn_cap ?fee ?gas_limit ?storage_limit ?counter + ?arg ?expect_failure ~source ~target amount = + let* c = client in + let* () = + lift + @@ Client.transfer + ?endpoint + ?wait + ?burn_cap + ?fee + ?gas_limit + ?storage_limit + ?counter + ?arg:(Option.map Test_michelson.to_string arg) + ?expect_failure + ~amount + ~giver:source + ~receiver:target + c + in + bake + + let originate ~storage ~alias contract = + let* c = client in + let* hash = + lift + @@ Client.originate_contract + ~alias + ~amount:Tez.zero + ~src:"bootstrap1" + ~prg:contract + ~init:(Test_michelson.to_string storage) + ~burn_cap:Tez.one + c + in + let* () = bake in + return hash + + let originate_vesting alias amount = + let* StateRecord.{client; vesting_contract; storage; _} = get in + let* hash = + lift + @@ Client.originate_contract + ~alias + ~amount + ~src:"bootstrap1" + ~prg:vesting_contract + ~init: + (Test_michelson.to_string @@ Contract_storage.to_micheline storage) + ~burn_cap:(Tez.of_int 2) + client + in + let* () = bake in + return hash + + let make_delegate u = + let* c = client in + let* target = alias (`User u) in + let* () = + transfer + ~source:"bootstrap1" + ~target + ~burn_cap:(Tez.of_int 1) + (Tez.of_int 100) + in + let* () = bake in + let* () = lift @@ Client.register_key target c in + bake + + let assert_balance account expected = + let* c = client in + let* actual = lift @@ Client.get_balance_for ~account c in + if actual = expected then return () + else + Test.fail + "Balance for %s is ꜩ %s instead of expected ꜩ %s." + account + (Tez.to_string actual) + (Tez.to_string expected) + + (* Assert that the actual storage is identical to the one maintained + by the test state. *) + let assert_storage account = + let open Tezos_micheline in + let* StateRecord.{client; storage; _} = get in + let expected = Contract_storage.to_micheline storage in + let* storage_code = lift @@ Client.contract_storage account client in + let* actual = lift @@ Test_michelson.parse storage_code in + match Micheline_diff.diff ~current:expected ~prev:actual () with + | Some diff -> + Test.fail + "Storage for %s is different than expected:\n%a" + account + (fun fmt e -> + Format.pp_print_string fmt @@ Test_michelson.to_string e) + diff + | None -> + Log.info + "Current storage:\n%a" + Micheline_printer.print_expr + (Micheline.map_node + (fun _ -> Micheline_printer.{comment = None}) + Fun.id + actual) ; + return () + + let assert_updated_storage updates account = + let* () = update_storage updates in + assert_storage account + + let get_signature ~typ ~data user = + let* c = client in + let* hash_data_output = + lift + @@ Client.hash_data + ~data:(Test_michelson.to_string data) + ~typ:(Test_michelson.to_string typ) + c + in + let packed_data = List.assoc "Raw packed data" hash_data_output in + let* signer = alias (`User user) in + lift @@ Client.sign_bytes ~signer ~data:packed_data c + + let signatures ~typ ~data signers = + list_map (list_map (fun u -> opt_map (get_signature ~typ ~data) u)) signers + + let assert_delegate src expected = + let* c = client in + let pp fmt = + let open Format in + fprintf fmt "%a" + @@ pp_print_option + ~none:(fun fmt () -> pp_print_string fmt "—") + (fun fmt s -> pp_print_string fmt s) + in + let* actual = lift @@ Client.get_delegate ~src c in + if expected = actual then return () + else + lift + @@ Test.fail + "Delegate for %s is %a, but %a was expected." + src + pp + actual + pp + expected + + let head_timestamp : Ptime.t t = + let open JSON in + let* c = client in + let* json = lift @@ Client.rpc GET ["chains"; "main"; "blocks"; "head"] c in + let timestamp_or_error = + json |-> "header" |-> "timestamp" |> as_string |> Ptime.of_rfc3339 + in + match Ptime.rfc3339_error_to_msg timestamp_or_error with + | Ok (timestamp, _, _) -> return timestamp + | Error (`Msg e) -> Test.fail "Couldn't parse last block's timestamp: %s" e +end + +let path_to file = Filename.(dirname __FILE__ ^ dir_sep ^ file) + +let empty_contract = path_to "empty.tz" + +let sigs_michelson sigs = + let open Test_michelson in + list @@ List.map (fun grp -> list @@ List.map (optional str) grp) sigs + +let vesting_arg_type = + let open Test_michelson.Types in + pair + (either + (either (pair (contract unit) mutez) (option (pair (contract unit) key))) + (either (pair (list (pair (list key) nat)) nat) (option key_hash))) + (pair address nat) + +let gen_keys count client = + let ( let+ ) = Fun.flip Lwt.map in + let gen alias = Client.gen_and_show_keys ~alias client in + let+ keys = + Lwt_list.map_s gen @@ List.init count (fun i -> "user" ^ string_of_int i) + in + Array.of_list keys + +let vest ?(expect_failure = false) ?(amount = Tez.zero) vesting_contract = + let open StateMonad in + let* () = + transfer + ~source:"bootstrap1" + ~target:vesting_contract + ~arg:Test_michelson.(right none) + ~burn_cap:Tez.one + ~expect_failure + amount + in + assert_updated_storage + (if expect_failure then [] + else Contract_storage.[increment_vested_balance; next_payout]) + vesting_contract + +let sign_transfer ?(expect_failure = false) ~contract ~replay ~receiver ~signers + amount = + let open StateMonad in + let data = + let open Test_michelson in + pair + (left @@ left @@ pair (str receiver) (tez amount)) + (pair (str contract) (num replay)) + in + let* signatures = signatures ~typ:vesting_arg_type ~data signers in + let arg = + let open Test_michelson in + left + @@ pair + (left @@ left @@ pair (str receiver) (tez amount)) + (sigs_michelson signatures) + in + let* () = + transfer + ~expect_failure + ~source:"bootstrap1" + ~target:contract + ~burn_cap:Tez.(of_mutez_int 100000) + ~arg + Tez.zero + in + assert_updated_storage + (if expect_failure then [] else Contract_storage.[pay_out amount]) + contract + +let set_pour ~replay ~signers info contract = + let open StateMonad in + let* keys = getf StateRecord.get_keys in + let pour_info (recipient, authorizer) = + let open Contract_storage in + let recp_pk_hash = (Array.get keys recipient).public_key_hash in + let auth = Array.get keys authorizer in + {pour_dest = recp_pk_hash; pour_authorizer = auth.public_key} + in + let new_pour_info = Option.map pour_info info in + let pour_info_micheline = + Contract_storage.pour_info_micheline new_pour_info + in + let to_sign = + let open Test_michelson in + pair (left @@ right pour_info_micheline) (pair (str contract) (num replay)) + in + let* signatures = signatures ~typ:vesting_arg_type ~data:to_sign signers in + let arg = + let open Test_michelson in + left @@ pair (left @@ right pour_info_micheline) (sigs_michelson signatures) + in + let* () = + transfer + ~arg + ~source:"bootstrap1" + ~target:contract + ~burn_cap:(Tez.of_mutez_int 100000) + Tez.zero + in + assert_updated_storage Contract_storage.[set_pour_info new_pour_info] contract + +let set_pour_for ~replay ~signers ~authorizer ~recipient contract = + set_pour ~replay ~signers (Some (recipient, authorizer)) contract + +let disable_pour ~replay ~signers contract = + set_pour ~replay ~signers None contract + +let execute_pour ?(expect_failure = false) ~authorizer ~recipient ~amount + ~replay contract = + let open StateMonad in + let* keys = getf StateRecord.get_keys in + let recp_pk_hash = (Array.get keys recipient).public_key_hash in + let to_sign = + let open Test_michelson in + pair + (pair (str recp_pk_hash) (tez amount)) + (pair (str contract) (num replay)) + in + let typ = + let open Test_michelson.Types in + pair (pair (contract unit) mutez) (pair address nat) + in + let* signature = get_signature ~typ ~data:to_sign authorizer in + let arg = + let open Test_michelson in + right @@ some @@ pair (str signature) (tez amount) + in + let* () = + transfer + ~source:"bootstrap1" + ~target:contract + ~arg + ~burn_cap:Tez.(of_mutez_int 100000) + ~expect_failure + Tez.zero + in + assert_updated_storage + (if expect_failure then [] else Contract_storage.[pay_out amount]) + contract + +let set_delegate ~delegate ~signers ~replay contract = + let open StateMonad in + let data = + let open Test_michelson in + pair + (right @@ right @@ optional str delegate) + (pair (str contract) (num replay)) + in + let* signatures = signatures ~typ:vesting_arg_type ~data signers in + let arg = + let open Test_michelson in + left + @@ pair + (right @@ right @@ optional str delegate) + (sigs_michelson signatures) + in + let* () = transfer ~source:"bootstrap1" ~target:contract ~arg Tez.zero in + assert_updated_storage Contract_storage.[bump_replay_counter] contract + +let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold + ~replay contract = + let open StateMonad in + let* keys = getf StateRecord.get_keys in + let key_groups = + List.map + (fun (ks, t) -> + Contract_storage. + { + signatories = List.map (fun i -> (Array.get keys i).public_key) ks; + group_treshold = t; + }) + key_groups + in + let key_groups_micheline = + let open Test_michelson in + right @@ left + @@ Contract_storage.key_info_micheline {key_groups; overall_treshold} + in + let typ = + let open Test_michelson.Types in + pair + (either unit (either (pair (list (pair (list key) nat)) nat) unit)) + (pair address nat) + in + let data = + let open Test_michelson in + pair key_groups_micheline (pair (str contract) (num replay)) + in + let* signatures = signatures ~typ ~data signers in + let arg = + let open Test_michelson in + left @@ pair key_groups_micheline (sigs_michelson signatures) + in + let* () = + transfer + ~expect_failure + ~source:"bootstrap1" + ~target:contract + ~burn_cap:Tez.(of_mutez_int 10000) + ~arg + Tez.zero + in + assert_updated_storage + (if expect_failure then [] + else Contract_storage.[update_keys key_groups overall_treshold]) + contract + +let transfer_and_pour_happy_path = + let open StateMonad in + let* () = activate_alpha in + let* () = initialise_vesting_state [([0], 1); ([1], 1); ([2], 1)] in + let* contract = originate_vesting "vesting_3_keys_60s" (Tez.of_int 500) in + let* () = assert_balance contract @@ Tez.of_int 500 in + let* () = assert_storage contract in + + (* Make 5 consecutive vest operations from the vesting contract. After each + of them [vested_balance] should increase by ꜩ100 and [next_payout] by 60s. + Appropriate assertions are performed automatically. *) + let* () = vest contract in + let* () = vest contract in + let* () = vest contract in + let* () = vest contract in + let* () = vest contract in + + let* receiver = user_address 3 in + let* () = assert_balance receiver Tez.zero in + let* () = + sign_transfer + ~contract + ~signers:[[Some 0]; [Some 1]; [None]] + ~receiver + ~replay:0 + Tez.(of_int 400) + in + let* () = assert_balance receiver @@ Tez.of_int 400 in + let* () = assert_balance contract @@ Tez.of_int 100 in + let* () = vest contract in + (* This is expected to fail, as we order transfer of more funds than is available. + ꜩ400 out of ꜩ500 transferred initially to the contract are already spent. *) + let* () = + sign_transfer + ~contract + ~signers:[[Some 0]; [Some 1]; [None]] + ~receiver + ~replay:1 + ~expect_failure:true + Tez.(of_int 100 + of_mutez_int 1) + in + (* Hence transferring exactly ꜩ100 is still possible. *) + let* () = + sign_transfer + ~contract + ~signers:[[Some 0]; [Some 1]; [None]] + ~receiver + ~replay:1 + Tez.(of_int 100) + in + let* () = assert_balance receiver @@ Tez.of_int 500 in + let* () = assert_balance contract @@ Tez.of_int 0 in + let* () = vest ~amount:(Tez.of_int 200) contract in + let* () = assert_balance contract @@ Tez.of_int 200 in + + (* Decide to pour funds from the vesting contract to a previously agreed + account by a single signature. *) + let* () = + set_pour_for + ~authorizer:5 + ~recipient:4 + ~signers:[[Some 0]; [Some 1]; [None]] + ~replay:2 + contract + in + let* pour_receiver = user_address 4 in + let* () = assert_balance pour_receiver @@ Tez.of_int 0 in + let* () = + execute_pour + ~authorizer:5 + ~recipient:4 + ~replay:3 + ~amount:Tez.(of_int 100) + contract + in + let* () = assert_balance contract @@ Tez.of_int 100 in + let* () = assert_balance pour_receiver @@ Tez.of_int 100 in + (* Pour cannot exceed the available balance. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:5 + ~recipient:4 + ~replay:4 + ~amount:Tez.(of_int 100 + of_mutez_int 1) + contract + in + (* Pour can equal the available balance, though. *) + let* () = + execute_pour + ~authorizer:5 + ~recipient:4 + ~replay:4 + ~amount:Tez.(of_int 100) + contract + in + let* () = assert_balance pour_receiver @@ Tez.of_int 200 in + let* () = assert_balance contract @@ Tez.of_int 0 in + (* Transfer of ꜩ0 to a smart contract is always possible. *) + let* empty_contract = + originate ~alias:"empty" ~storage:Test_michelson.unit empty_contract + in + let* () = + sign_transfer + ~contract + ~signers:[[Some 0]; [Some 1]; [None]] + ~receiver:empty_contract + ~replay:5 + Tez.zero + in + (* Nothing has changed. *) + let* () = assert_balance receiver @@ Tez.of_int 500 in + assert_balance contract @@ Tez.of_int 0 + +let vesting_3_keys_2s = + let open StateMonad in + let* () = activate_alpha in + (* For 4 first users (ids 0-3) give each ꜩ100 and register + him as a delegate. *) + let* () = iter_int make_delegate 4 in + + let* _empty_contract_hash = + originate ~alias:"empty" ~storage:Test_michelson.unit empty_contract + in + let* head_ts = head_timestamp in + let next_payout = + let open Ptime in + Option.value ~default:epoch @@ add_span head_ts @@ Span.of_int_s 30 + in + let* () = + initialise_vesting_state + ~next_payout + ~payout_interval:Ptime.Span.(of_int_s 2) + [([0], 1); ([1], 1); ([2], 1)] + in + let* contract = originate_vesting "vesting_3_keys_2s" (Tez.of_int 1000) in + let* () = vest ~expect_failure:true contract in + (* A block later, vest succeeds. *) + let* () = bake in + let* () = vest contract in + let* () = vest contract in + return contract + +let test_delegation = + let open StateMonad in + let* contract = vesting_3_keys_2s in + let* () = assert_delegate contract None in + let* deleg = user_address 0 in + let* () = + set_delegate + ~delegate:(Some deleg) + ~signers:[[Some 0]; [Some 1]; [Some 2]] + ~replay:0 + contract + in + let* () = assert_delegate contract (Some deleg) in + let* deleg1 = user_address 1 in + let* () = + set_delegate + ~delegate:(Some deleg1) + ~signers:[[None]; [Some 1]; [Some 2]] + ~replay:1 + contract + in + let* () = assert_delegate contract (Some deleg1) in + let* deleg2 = user_address 2 in + let* () = + set_delegate + ~delegate:(Some deleg2) + ~signers:[[Some 0]; [None]; [Some 2]] + ~replay:2 + contract + in + let* () = assert_delegate contract (Some deleg2) in + (* Now remove the delegate. *) + let* () = + set_delegate + ~delegate:None + ~signers:[[Some 0]; [None]; [Some 2]] + ~replay:3 + contract + in + let* () = assert_delegate contract None in + let* () = assert_balance deleg @@ Tez.of_mutez_int 99999393 in + let* () = assert_balance contract @@ Tez.of_int 1000 in + let* () = + sign_transfer + ~contract + ~replay:4 + ~receiver:deleg + ~signers:[[Some 0]; [None]; [Some 2]] + Tez.(of_int 100) + in + let* () = assert_balance deleg @@ Tez.of_mutez_int 199999393 in + assert_balance contract @@ Tez.of_int 900 + +let test_invalid_transfers = + let open StateMonad in + let* contract = vesting_3_keys_2s in + let* receiver = user_address 0 in + (* Transfer fails without enough signatures. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:0 + ~receiver + ~signers:[[None]; [None]; [None]] + Tez.zero + in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:0 + ~receiver + ~signers:[[Some 0]; [None]; [None]] + Tez.zero + in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:0 + ~receiver + ~signers:[[None]; [Some 1]; [None]] + Tez.zero + in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:0 + ~receiver + ~signers:[[None]; [None]; [Some 2]] + Tez.zero + in + + let* receiver = user_address 5 in + let* () = + set_pour_for + ~replay:0 + ~authorizer:4 + ~recipient:5 + ~signers:[[Some 0]; [None]; [Some 2]] + contract + in + (* Transaction exceeds available balance. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:1 + ~receiver + ~signers:[[Some 0]; [Some 1]; [Some 2]] + Tez.(of_int 1000) + in + let* () = assert_balance receiver @@ Tez.of_int 0 in + let* () = assert_balance contract @@ Tez.of_int 1000 in + let* () = + sign_transfer + ~contract + ~replay:1 + ~receiver + ~signers:[[Some 0]; [None]; [Some 2]] + Tez.(of_int 75) + in + let* () = assert_balance receiver @@ Tez.of_int 75 in + let* () = assert_balance contract @@ Tez.of_int 925 in + let* () = + sign_transfer + ~contract + ~replay:2 + ~receiver + ~signers:[[None]; [Some 1]; [Some 2]] + Tez.(of_int 25) + in + let* () = assert_balance receiver @@ Tez.of_int 100 in + let* () = assert_balance contract @@ Tez.of_int 900 in + + let* () = vest contract in + let* () = + execute_pour + ~authorizer:4 + ~recipient:5 + ~amount:Tez.(of_int 50) + ~replay:3 + contract + in + let* () = assert_balance receiver @@ Tez.of_int 150 in + let* () = assert_balance contract @@ Tez.of_int 850 in + + (* Pour fails if amount exceeds available funds. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:4 + ~recipient:5 + ~amount:Tez.(of_int 751) + ~replay:4 + contract + in + let* () = assert_balance receiver @@ Tez.of_int 150 in + let* () = assert_balance contract @@ Tez.of_int 850 in + (* Pour fails if replay counter is too large. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:4 + ~recipient:5 + ~amount:Tez.(of_int 20) + ~replay:5 + contract + in + let* () = assert_balance receiver @@ Tez.of_int 150 in + let* () = assert_balance contract @@ Tez.of_int 850 in + (* Pour fails if replay counter is too small. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:4 + ~recipient:5 + ~amount:Tez.(of_int 20) + ~replay:3 + contract + in + let* () = assert_balance receiver @@ Tez.of_int 150 in + let* () = assert_balance contract @@ Tez.of_int 850 in + (* Pour fails if signature is incorrect. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:5 + ~recipient:5 + ~amount:Tez.(of_int 20) + ~replay:4 + contract + in + let* () = assert_balance receiver @@ Tez.of_int 150 in + let* () = assert_balance contract @@ Tez.of_int 850 in + let* () = + disable_pour ~replay:4 ~signers:[[None]; [Some 1]; [Some 2]] contract + in + + let* () = vest contract in + (* Pour fails when no pour info is set. *) + execute_pour + ~expect_failure:true + ~replay:5 + ~recipient:5 + ~authorizer:4 + ~amount:Tez.zero + contract + +let test_update_keys : unit StateMonad.t = + let open StateMonad in + let* contract = vesting_3_keys_2s in + let* receiver = user_address 4 in + let* () = + sign_transfer + ~contract + ~replay:0 + ~receiver + ~signers:[[Some 0]; [Some 1]; [None]] + Tez.(of_int 100) + in + let* () = assert_balance contract @@ Tez.of_int 900 in + let* () = assert_balance receiver @@ Tez.of_int 100 in + let* () = + set_keys + ~expect_failure:true (* Overall treshold can't be 0. *) + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] + ~overall_treshold:0 + ~replay:1 + contract + in + let* () = + set_keys + ~expect_failure: + true (* Overall treshold can't be greater than number of keys. *) + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] + ~overall_treshold:4 + ~replay:1 + contract + in + let* () = + set_keys + ~expect_failure:true (* Group threshold can't be 0. *) + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 0); ([5], 1); ([6], 1)] + ~overall_treshold:2 + ~replay:1 + contract + in + let* () = + set_keys + ~expect_failure:true (* Group cannot be empty. *) + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 1); ([5], 1); ([], 1)] + ~overall_treshold:2 + ~replay:1 + contract + in + let* () = + set_keys + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] + ~overall_treshold:2 + ~replay:1 + contract + in + (* unchanged *) + let* () = assert_balance contract @@ Tez.of_int 900 in + let* receiver = user_address 1 in + (* Old signatures don't work anymore. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:2 + ~receiver + ~signers:[[Some 0]; [Some 1]; [Some 2]] + Tez.(of_int 200) + in + (* unchanged *) + let* () = assert_balance contract @@ Tez.of_int 900 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in + let* () = + sign_transfer + ~contract + ~replay:2 + ~receiver + ~signers:[[Some 3; None]; [Some 5]; [Some 6]] + Tez.(of_int 100) + in + let* () = assert_balance contract @@ Tez.of_int 800 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 199999393 in + let* () = vest contract in + let* () = + sign_transfer + ~contract + ~replay:3 + ~receiver + ~signers:[[Some 3; None]; [None]; [Some 6]] + Tez.(of_int 100) + in + let* () = assert_balance contract @@ Tez.of_int 700 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 299999393 in + let* () = vest contract in + let* () = + sign_transfer + ~contract + ~replay:4 + ~receiver + ~signers:[[None; None]; [Some 5]; [Some 6]] + Tez.(of_int 100) + in + let* () = assert_balance contract @@ Tez.of_int 600 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 399999393 in + let* () = vest contract in + let* () = + sign_transfer + ~contract + ~replay:5 + ~receiver + ~signers:[[None; Some 4]; [Some 5]; [None]] + Tez.(of_int 10) + in + let* () = assert_balance contract @@ Tez.of_int 590 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 409999393 in + (* Group treshold must be met. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:6 + ~receiver + ~signers:[[Some 3; Some 4]; [None]; [None]] + Tez.(of_int 10) + in + let* () = assert_balance contract @@ Tez.of_int 590 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 409999393 in + return () + +let test_all_sigs_required = + let open StateMonad in + let* contract = vesting_3_keys_2s in + let* () = + set_keys + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 2); ([5], 1); ([6], 1)] + ~overall_treshold:3 + ~replay:0 + contract + in + let* receiver = user_address 1 in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:1 + ~receiver + ~signers:[[Some 3; Some 4]; [Some 5]; [None]] + Tez.(of_int 10) + in + let* () = assert_balance contract @@ Tez.of_int 1000 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:1 + ~receiver + ~signers:[[None; None]; [Some 5]; [Some 6]] + Tez.(of_int 10) + in + let* () = assert_balance contract @@ Tez.of_int 1000 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in + let* () = + sign_transfer + ~contract + ~replay:1 + ~receiver + ~signers:[[Some 3; Some 4]; [Some 5]; [Some 6]] + Tez.(of_int 10) + in + let* () = assert_balance contract @@ Tez.of_int 990 in + let* () = assert_balance receiver @@ Tez.of_mutez_int 109999393 in + return () + +let test_full_contract = + let open StateMonad in + let* () = activate_alpha in + let* _empty_contract_hash = + originate ~alias:"empty" ~storage:Test_michelson.unit empty_contract + in + let* () = + initialise_vesting_state + ~vesting_increment: + (Tez.of_mutez_int 636089108075) + (* 1/12th of the total initial balance. *) + ~payout_interval: + Ptime.Span.(of_int_s (60 * 60 * 24 * 365 / 12)) + (* Approximately one month. *) + ~overall_treshold:4 + [ + ([0; 1; 2; 3], 2); + ([4; 5; 6; 7], 2); + ([8; 9; 10; 11], 2); + ([12; 13; 14; 15], 2); + ([16; 17; 18; 19], 2); + ([20; 21; 22; 23], 2); + ([24; 25; 26; 27], 2); + ] + in + (* 10% of the total token supply. *) + let initial_balance = Tez.of_mutez_int 7633069296900 in + (* Ensure bootstrap1 has enough funds to cover the initial balance. *) + let* () = + transfer ~source:"bootstrap2" ~target:"bootstrap1" Tez.(of_int 3000000) + in + let* () = + transfer ~source:"bootstrap3" ~target:"bootstrap1" Tez.(of_int 3000000) + in + let* contract = originate_vesting "full_vesting_contract" initial_balance in + let* () = vest contract (* 1 / 12 *) in + let* () = assert_balance contract @@ Tez.of_mutez_int 7633069296900 in + let* () = vest contract (* 2 / 12 *) in + + let* () = make_delegate 0 in + let* delegate = user_address 0 in + let* () = + set_delegate + ~delegate:(Some delegate) + ~signers: + [ + [Some 0; Some 1; None; None]; + [Some 4; Some 5; None; None]; + [Some 8; Some 9; None; None]; + [Some 12; Some 13; None; None]; + [None; None; None; None]; + [None; None; None; None]; + [None; None; None; None]; + ] + ~replay:0 + contract + in + let* () = assert_delegate contract (Some delegate) in + let* () = assert_balance contract @@ Tez.of_mutez_int 7633069296900 in + let* () = + set_delegate + ~delegate:None + ~signers: + [ + [None; None; Some 2; Some 3]; + [None; None; Some 6; Some 7]; + [None; None; Some 10; Some 11]; + [None; Some 13; Some 14; Some 15]; + [None; None; None; None]; + [None; None; None; None]; + [None; None; None; None]; + ] + ~replay:1 + contract + in + let* u27 = user_address 27 in + let* () = assert_delegate contract None in + let* () = assert_balance u27 @@ Tez.of_int 0 in + let* () = + sign_transfer + ~contract + ~replay:2 + ~receiver:u27 + ~signers: + [ + [None; None; None; None]; + [None; None; None; None]; + [None; None; None; None]; + [None; Some 13; None; Some 15]; + [Some 16; None; None; Some 19]; + [Some 20; None; None; Some 23]; + [None; Some 25; None; Some 27]; + ] + Tez.(of_int 100) + in + let* () = assert_balance u27 @@ Tez.of_int 100 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632969296900 in + let* () = + sign_transfer + ~contract + ~replay:3 + ~receiver:u27 + ~signers: + [ + [Some 0; Some 1; Some 2; Some 3]; + [Some 4; Some 5; Some 6; Some 7]; + [Some 8; Some 9; Some 10; Some 11]; + [Some 12; Some 13; Some 14; Some 15]; + [Some 16; Some 17; Some 18; Some 19]; + [Some 20; Some 21; Some 22; Some 23]; + [Some 24; Some 25; Some 26; Some 27]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 300 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in + (* Group thresholds must be met. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:4 + ~receiver:u27 + ~signers: + [ + [None; None; Some 2; None]; + [None; Some 5; None; None]; + [None; None; Some 10; None]; + [None; Some 13; None; None]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; None]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 300 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in + (* Overall threshold must be met. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:4 + ~receiver:u27 + ~signers: + [ + [Some 0; None; Some 2; None]; + [None; Some 5; None; None]; + [None; None; Some 10; Some 11]; + [None; Some 13; None; None]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; Some 27]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 300 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in + (* All signatures must be valid key (#0 signed in the wrong slot). *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:4 + ~receiver:u27 + ~signers: + [ + [None; Some 1; Some 2; Some 0]; + [None; Some 5; Some 6; None]; + [None; None; Some 10; Some 11]; + [None; Some 13; None; Some 15]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; None]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 300 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in + + (* Change keys: *) + let* () = + set_keys + ~signers: + [ + [None; Some 1; Some 2; None]; + [None; Some 5; Some 6; None]; + [None; None; Some 10; Some 11]; + [None; Some 13; None; Some 15]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; None]; + ] + ~key_groups: + [ + ([0; 7; 14; 21], 1); + ([1; 8; 15; 22], 1); + ([2; 9; 16; 23], 1); + ([3; 10; 17; 24], 1); + ([4; 11; 18; 25], 1); + ([5; 12; 19; 26], 1); + ([6; 13; 20; 27], 1); + ] + ~overall_treshold:4 + ~replay:4 + contract + in + (* Old keys no longer work. *) + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:5 + ~receiver:u27 + ~signers: + [ + [None; Some 1; Some 2; None]; + [None; Some 5; Some 6; None]; + [None; None; Some 10; Some 11]; + [None; Some 13; None; Some 15]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; None]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 300 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in + (* New keys do work. *) + let* () = + sign_transfer + ~contract + ~replay:5 + ~receiver:u27 + ~signers: + [ + [None; Some 7; None; None]; + [None; None; Some 15; None]; + [None; None; None; Some 23]; + [None; None; None; None]; + [Some 4; None; None; None]; + [None; None; None; None]; + [Some 6; None; None; None]; + ] + Tez.(of_int 200) + in + let* () = assert_balance u27 @@ Tez.of_int 500 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632569296900 in + + (* Pour must be set up first. *) + let* () = + execute_pour + ~expect_failure:true + ~authorizer:0 + ~recipient:27 + ~amount:Tez.(of_int 500) + ~replay:6 + contract + in + let* () = assert_balance u27 @@ Tez.of_int 500 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632569296900 in + let* () = + set_pour_for + ~replay:6 + ~signers: + [ + [None; Some 7; None; None]; + [None; None; Some 15; None]; + [None; None; None; Some 23]; + [None; None; None; None]; + [Some 4; None; None; None]; + [None; None; None; None]; + [Some 6; None; None; None]; + ] + ~authorizer:0 + ~recipient:27 + contract + in + let* () = + execute_pour + ~authorizer:0 + ~recipient:27 + ~amount:Tez.(of_int 500) + ~replay:7 + contract + in + let* () = assert_balance u27 @@ Tez.of_int 1000 in + let* () = assert_balance contract @@ Tez.of_mutez_int 7632069296900 in + return () + +let execute ~user_count ~contract test () = + let* node = Node.init [Connections 0; Synchronisation_threshold 0] in + let* client = Client.init ~endpoint:(Node node) () in + let* keys = gen_keys user_count client in + let vesting_contract = path_to contract in + let storage = Contract_storage.initial [] in + StateMonad.eval + StateRecord.{node; client; keys; vesting_contract; storage} + test -- GitLab From deb6b8a959b4d2e7ccec3869de015a312db9c8e2 Mon Sep 17 00:00:00 2001 From: Sventimir Date: Mon, 31 Jan 2022 09:18:58 +0100 Subject: [PATCH 4/9] Proto Alpha: Add automatic tests for the protocol migration. 1. verify that provided .patched.tz files represent binary scripts hard-coded in the migration. 2. verify that provided original scrip[ts have the same hashes as the original scripts that are going to be updated. 3. verify that .diff files represent actual diffs between original and patched versions. --- .../test/integration/michelson/dune | 3 +- .../test/integration/michelson/main.ml | 1 + ...JqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.diff | 23 + ...jsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz | 44 + ...sjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz | 41 + ...FYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.diff | 83 + ...eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz | 1503 +++++++++++++++++ ...1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz | 1503 +++++++++++++++++ ...jtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.diff | 12 + ...RamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz | 596 +++++++ ...vRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz | 597 +++++++ ...ktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.diff | 83 + ...qTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz | 1431 ++++++++++++++++ ...WqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz | 1431 ++++++++++++++++ ...XQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff | 64 + ...4DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz | 232 +++ ...44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz | 239 +++ ...GHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.diff | 23 + ...1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz | 46 + ...S1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz | 44 + ...zr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.diff | 19 + ...KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz | 234 +++ ...3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz | 236 +++ ...dpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.diff | 19 + ...RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz | 233 +++ ...8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz | 235 +++ .../michelson/test_patched_contracts.ml | 164 ++ 27 files changed, 9138 insertions(+), 1 deletion(-) create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.diff create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz create mode 100644 src/proto_alpha/lib_protocol/test/integration/michelson/test_patched_contracts.ml diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/dune b/src/proto_alpha/lib_protocol/test/integration/michelson/dune index 579ad635d131..ee14c3ffb8bb 100644 --- a/src/proto_alpha/lib_protocol/test/integration/michelson/dune +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/dune @@ -1,7 +1,8 @@ (test (name main) (package tezos-protocol-alpha-tests) - (deps (glob_files contracts/*)) + (deps (glob_files contracts/*) + (glob_files patched_contracts/*)) (libraries alcotest-lwt tezos-base tezos-protocol-alpha diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/main.ml b/src/proto_alpha/lib_protocol/test/integration/michelson/main.ml index 2f424ac6832d..69d5ea568d40 100644 --- a/src/proto_alpha/lib_protocol/test/integration/michelson/main.ml +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/main.ml @@ -52,5 +52,6 @@ let () = ("typechecking", Test_typechecking.tests); ("script cache", Test_script_cache.tests); ("block time instructions", Test_block_time_instructions.tests); + ("patched contracts", Test_patched_contracts.tests); ] |> Lwt_main.run diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.diff new file mode 100644 index 000000000000..91b36833e3ea --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.diff @@ -0,0 +1,23 @@ +--- patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz ++++ patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz +@@ -1,10 +1,5 @@ + { parameter (or (lambda %do unit (list operation)) (unit %default)) ; +- storage +- (pair key_hash +- (contract +- (or (option address) +- (or (pair (option address) (option mutez)) +- (or mutez (or (pair (option address) (option mutez)) address)))))) ; ++ storage (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT +@@ -28,6 +23,8 @@ + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; ++ CONTRACT (or (option address) (or (pair (option address) (option mutez)) (or mutez (or (pair (option address) (option mutez)) address)))); ++ IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + SENDER ; + SOME ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz new file mode 100644 index 000000000000..24a06dacc374 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.original.tz @@ -0,0 +1,44 @@ +{ parameter (or (lambda %do unit (list operation)) (unit %default)) ; + storage + (pair key_hash + (contract + (or (option address) + (or (pair (option address) (option mutez)) + (or mutez (or (pair (option address) (option mutez)) address)))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { CDR ; + DUP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + AMOUNT ; + SENDER ; + SOME ; + LEFT (or (pair (option address) (option mutez)) + (or mutez (or (pair (option address) (option mutez)) address))) ; + TRANSFER_TOKENS ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz new file mode 100644 index 000000000000..0ee44eafdb73 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc.patched.tz @@ -0,0 +1,41 @@ +{ parameter (or (lambda %do unit (list operation)) (unit %default)) ; + storage (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { CDR ; + DUP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONTRACT (or (option address) (or (pair (option address) (option mutez)) (or mutez (or (pair (option address) (option mutez)) address)))); + IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + SENDER ; + SOME ; + LEFT (or (pair (option address) (option mutez)) + (or mutez (or (pair (option address) (option mutez)) address))) ; + TRANSFER_TOKENS ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.diff new file mode 100644 index 000000000000..612523f46ddf --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.diff @@ -0,0 +1,83 @@ +--- patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz ++++ patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz +@@ -243,7 +243,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -432,7 +432,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -744,7 +744,7 @@ + CDR ; + CAR ; + CONTRACT unit ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; +@@ -755,7 +755,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; +@@ -909,7 +909,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; +@@ -1074,7 +1074,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -1240,7 +1240,7 @@ + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; +@@ -1260,7 +1260,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -1313,7 +1313,7 @@ + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz new file mode 100644 index 000000000000..975f95809b66 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.original.tz @@ -0,0 +1,1503 @@ +{ parameter + (or (or (or (pair %approve (address :spender) (pair (nat :allowance) (nat :currentAllowance))) + (pair %addLiquidity + (pair (address :owner) (nat :minLqtMinted)) + (pair (nat :maxTokensDeposited) (timestamp :deadline)))) + (or (pair %removeLiquidity + (pair (address :owner) (pair (address :to) (nat :lqtBurned))) + (pair (mutez :minXtzWithdrawn) (pair (nat :minTokensWithdrawn) (timestamp :deadline)))) + (or (pair %xtzToToken (address :to) (pair (nat :minTokensBought) (timestamp :deadline))) + (pair %tokenToXtz + (pair (address :owner) (address :to)) + (pair (nat :tokensSold) (pair (mutez :minXtzBought) (timestamp :deadline))))))) + (or (or (pair %tokenToToken + (pair (address :outputDexterContract) (pair (nat :minTokensBought) (address :owner))) + (pair (address :to) (pair (nat :tokensSold) (timestamp :deadline)))) + (or (key_hash %updateTokenPool) (nat %updateTokenPoolInternal))) + (or (pair %setBaker (option key_hash) bool) (or (address %setManager) (unit %default))))) ; + storage + (pair (big_map %accounts + (address :owner) + (pair (nat :balance) (map (address :spender) (nat :allowance)))) + (pair (pair (bool :selfIsUpdatingTokenPool) (pair (bool :freezeBaker) (nat :lqtTotal))) + (pair (pair (address :manager) (address :tokenAddress)) + (pair (nat :tokenPool) (mutez :xtzPool))))) ; + code { CAST (pair (or (or (or (pair address (pair nat nat)) (pair (pair address nat) (pair nat timestamp))) + (or (pair (pair address (pair address nat)) (pair mutez (pair nat timestamp))) + (or (pair address (pair nat timestamp)) + (pair (pair address address) (pair nat (pair mutez timestamp)))))) + (or (or (pair (pair address (pair nat address)) (pair address (pair nat timestamp))) + (or key_hash nat)) + (or (pair (option key_hash) bool) (or address unit)))) + (pair (big_map address (pair nat (map address nat))) + (pair (pair bool (pair bool nat)) (pair (pair address address) (pair nat mutez))))) ; + DUP ; + CAR ; + DIP { CDR } ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CAR ; + SENDER ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + COMPARE ; + EQ ; + IF {} + { PUSH string + "The current allowance parameter must equal the sender's current allowance for the owner." ; + FAILWITH } ; + DUP ; + CDR ; + DIG 2 ; + DUP ; + CAR ; + DIP { CDR ; CAR ; SOME } ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + NIL operation ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "maxTokensDeposited must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minLqtMinted must be greater than zero." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + GT ; + IF {} { PUSH string "Amount must be greater than zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CDR ; + INT ; + EQ ; + IF { AMOUNT ; + PUSH mutez 1000000 ; + COMPARE ; + LE ; + IF {} + { PUSH string + "The initial liquidity amount must be greater than or equal to 1 XTZ." ; + FAILWITH } ; + SWAP ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + SWAP ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + DIP { DUP ; CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + EDIV ; + IF_NONE + { PUSH string "divByZero." ; FAILWITH } + { DUP ; + CAR ; + DIP { CDR } ; + SWAP ; + INT ; + EQ ; + IF {} { PUSH nat 1 ; ADD } } ; + DUP ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensDeposited is zero." ; FAILWITH } ; + SWAP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CAR ; + CDR ; + CDR ; + MUL ; + DIP { SWAP } ; + EDIV ; + IF_NONE { FAILWITH } { CAR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + DIP { DUP } ; + COMPARE ; + LE ; + IF {} + { PUSH string "lqtMinted must be greater than or equal to minLqtMinted." ; + FAILWITH } ; + DIP { DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + DIP { DUP } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensDeposited is greater than maxTokensDeposited." ; + FAILWITH } } ; + DIP 3 { DUP } ; + DIG 3 ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { DIP { DIG 3 ; DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minXtzWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "lqtBurned must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + DIP { DIP { DUP } ; SWAP ; CAR } ; + GET ; + IF_NONE { PUSH string "owner has no liquidity." ; FAILWITH } {} ; + SWAP ; + DUP ; + CAR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + COMPARE ; + GE ; + IF {} + { PUSH string "lqtBurned is greater than owner's balance." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF { SWAP ; CAR } + { SWAP ; + DUP ; + CDR ; + SENDER ; + GET ; + IF_NONE { PUSH string "sender has no approval balance." ; FAILWITH } {} ; + DIP { SWAP ; DUP ; CAR ; CDR ; CDR ; DIP { PUSH int 0 } } ; + SUB ; + DUP ; + DIP { COMPARE ; + GE ; + IF {} + { PUSH string "sender approval balance is less than LQT burned." ; FAILWITH } } ; + ABS ; + SOME ; + DIG 2 ; + DUP ; + CDR ; + DIG 2 ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CAR ; + DIP { SOME ; + DUG 1 ; + DUP ; + CAR ; + CAR ; + SWAP ; + DIP { DIP { DIP { DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR } } } ; + DIP { DUP } ; + SWAP ; + CAR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CDR ; CDR } ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "xtzWithdrawn is less than minXtzWithdrawn." ; FAILWITH } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CDR ; + DIP { DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + SWAP ; + CDR ; + CDR ; + CDR ; + CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "tokensWithdrawn is less than minTokensWithdrawn." ; FAILWITH } ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CDR ; + DIG 3 ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIG 4 ; + DUP ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIP 4 { DUP } ; + DIG 4 ; + CAR ; + CDR ; + CDR ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CAR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DIP { CAR ; CDR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; + PAIR ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + GT ; + IF {} { PUSH string "Amount must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + PUSH nat 1000 ; + MUL ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { PUSH nat 997 ; MUL ; ADD } ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensBought is less than minTokensBought." ; FAILWITH } } ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; SELF ; ADDRESS } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensSold is zero" ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minXtzBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} { PUSH string "xtzBought is less than minXtzBought." ; FAILWITH } } ; + DIP { SWAP ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CDR ; CDR } ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 1 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + DIG 2 ; + CONS ; + SWAP ; + CONS ; + PAIR } } } } + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensSold is zero" ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + ADD ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; + IF_NONE { FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + DIP { DUP ; CAR ; CDR ; CAR ; DIP { DUP ; CDR ; CDR ; CDR } ; PAIR } ; + PAIR ; + SWAP ; + DROP ; + TRANSFER_TOKENS ; + SWAP ; + DIP { SWAP ; DUP ; CDR ; CDR ; CAR ; DIP { CAR ; CDR ; CDR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + NIL operation ; + SWAP ; + CONS ; + DIP { SWAP } ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "unsafeUpdateTokenPool" ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + PUSH bool True ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CAR ; + IF {} { PUSH string "Dexter did not initiate this operation." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} + { PUSH string "The sender is not the token contract associated with this contract." ; + FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + PUSH bool False ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CAR ; + NOT ; + IF {} + { PUSH string "Cannot change the baker while freezeBaker is true." ; + FAILWITH } ; + DUP ; + CAR ; + DIP { CDR } ; + SET_DELEGATE ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation } ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } + { DROP ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz new file mode 100644 index 000000000000..da23abebeef3 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe.patched.tz @@ -0,0 +1,1503 @@ +{ parameter + (or (or (or (pair %approve (address :spender) (pair (nat :allowance) (nat :currentAllowance))) + (pair %addLiquidity + (pair (address :owner) (nat :minLqtMinted)) + (pair (nat :maxTokensDeposited) (timestamp :deadline)))) + (or (pair %removeLiquidity + (pair (address :owner) (pair (address :to) (nat :lqtBurned))) + (pair (mutez :minXtzWithdrawn) (pair (nat :minTokensWithdrawn) (timestamp :deadline)))) + (or (pair %xtzToToken (address :to) (pair (nat :minTokensBought) (timestamp :deadline))) + (pair %tokenToXtz + (pair (address :owner) (address :to)) + (pair (nat :tokensSold) (pair (mutez :minXtzBought) (timestamp :deadline))))))) + (or (or (pair %tokenToToken + (pair (address :outputDexterContract) (pair (nat :minTokensBought) (address :owner))) + (pair (address :to) (pair (nat :tokensSold) (timestamp :deadline)))) + (or (key_hash %updateTokenPool) (nat %updateTokenPoolInternal))) + (or (pair %setBaker (option key_hash) bool) (or (address %setManager) (unit %default))))) ; + storage + (pair (big_map %accounts + (address :owner) + (pair (nat :balance) (map (address :spender) (nat :allowance)))) + (pair (pair (bool :selfIsUpdatingTokenPool) (pair (bool :freezeBaker) (nat :lqtTotal))) + (pair (pair (address :manager) (address :tokenAddress)) + (pair (nat :tokenPool) (mutez :xtzPool))))) ; + code { CAST (pair (or (or (or (pair address (pair nat nat)) (pair (pair address nat) (pair nat timestamp))) + (or (pair (pair address (pair address nat)) (pair mutez (pair nat timestamp))) + (or (pair address (pair nat timestamp)) + (pair (pair address address) (pair nat (pair mutez timestamp)))))) + (or (or (pair (pair address (pair nat address)) (pair address (pair nat timestamp))) + (or key_hash nat)) + (or (pair (option key_hash) bool) (or address unit)))) + (pair (big_map address (pair nat (map address nat))) + (pair (pair bool (pair bool nat)) (pair (pair address address) (pair nat mutez))))) ; + DUP ; + CAR ; + DIP { CDR } ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CAR ; + SENDER ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + COMPARE ; + EQ ; + IF {} + { PUSH string + "The current allowance parameter must equal the sender's current allowance for the owner." ; + FAILWITH } ; + DUP ; + CDR ; + DIG 2 ; + DUP ; + CAR ; + DIP { CDR ; CAR ; SOME } ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + NIL operation ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "maxTokensDeposited must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minLqtMinted must be greater than zero." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + GT ; + IF {} { PUSH string "Amount must be greater than zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CDR ; + INT ; + EQ ; + IF { AMOUNT ; + PUSH mutez 1000000 ; + COMPARE ; + LE ; + IF {} + { PUSH string + "The initial liquidity amount must be greater than or equal to 1 XTZ." ; + FAILWITH } ; + SWAP ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + SWAP ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + DIP { DUP ; CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + EDIV ; + IF_NONE + { PUSH string "divByZero." ; FAILWITH } + { DUP ; + CAR ; + DIP { CDR } ; + SWAP ; + INT ; + EQ ; + IF {} { PUSH nat 1 ; ADD } } ; + DUP ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensDeposited is zero." ; FAILWITH } ; + SWAP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CAR ; + CDR ; + CDR ; + MUL ; + DIP { SWAP } ; + EDIV ; + IF_NONE { FAILWITH } { CAR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + DIP { DUP } ; + COMPARE ; + LE ; + IF {} + { PUSH string "lqtMinted must be greater than or equal to minLqtMinted." ; + FAILWITH } ; + DIP { DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + DIP { DUP } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensDeposited is greater than maxTokensDeposited." ; + FAILWITH } } ; + DIP 3 { DUP } ; + DIG 3 ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { DIP { DIG 3 ; DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minXtzWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "lqtBurned must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + DIP { DIP { DUP } ; SWAP ; CAR } ; + GET ; + IF_NONE { PUSH string "owner has no liquidity." ; FAILWITH } {} ; + SWAP ; + DUP ; + CAR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + COMPARE ; + GE ; + IF {} + { PUSH string "lqtBurned is greater than owner's balance." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF { SWAP ; CAR } + { SWAP ; + DUP ; + CDR ; + SENDER ; + GET ; + IF_NONE { PUSH string "sender has no approval balance." ; FAILWITH } {} ; + DIP { SWAP ; DUP ; CAR ; CDR ; CDR ; DIP { PUSH int 0 } } ; + SUB ; + DUP ; + DIP { COMPARE ; + GE ; + IF {} + { PUSH string "sender approval balance is less than LQT burned." ; FAILWITH } } ; + ABS ; + SOME ; + DIG 2 ; + DUP ; + CDR ; + DIG 2 ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CAR ; + DIP { SOME ; + DUG 1 ; + DUP ; + CAR ; + CAR ; + SWAP ; + DIP { DIP { DIP { DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR } } } ; + DIP { DUP } ; + SWAP ; + CAR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CDR ; CDR } ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "xtzWithdrawn is less than minXtzWithdrawn." ; FAILWITH } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CDR ; + DIP { DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + SWAP ; + CDR ; + CDR ; + CDR ; + CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "tokensWithdrawn is less than minTokensWithdrawn." ; FAILWITH } ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CDR ; + DIG 3 ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIG 4 ; + DUP ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIP 4 { DUP } ; + DIG 4 ; + CAR ; + CDR ; + CDR ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CAR ; + CONTRACT unit ; + IF_NONE { CDR; FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DIP { CAR ; CDR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; + PAIR ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + GT ; + IF {} { PUSH string "Amount must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + PUSH nat 1000 ; + MUL ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { PUSH nat 997 ; MUL ; ADD } ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensBought is less than minTokensBought." ; FAILWITH } } ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; SELF ; ADDRESS } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensSold is zero" ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minXtzBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} { PUSH string "xtzBought is less than minXtzBought." ; FAILWITH } } ; + DIP { SWAP ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CDR ; CDR } ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 1 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + DIG 2 ; + CONS ; + SWAP ; + CONS ; + PAIR } } } } + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensSold is zero" ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "xtzPool must be greater than zero." ; FAILWITH } } ; + DIP { DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokenPool must be greater than zero" ; FAILWITH } } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + ADD ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; + IF_NONE { CDR; FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + DIP { DUP ; CAR ; CDR ; CAR ; DIP { DUP ; CDR ; CDR ; CDR } ; PAIR } ; + PAIR ; + SWAP ; + DROP ; + TRANSFER_TOKENS ; + SWAP ; + DIP { SWAP ; DUP ; CDR ; CDR ; CAR ; DIP { CAR ; CDR ; CDR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + NIL operation ; + SWAP ; + CONS ; + DIP { SWAP } ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "unsafeUpdateTokenPool" ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + PUSH bool True ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CAR ; + IF {} { PUSH string "Dexter did not initiate this operation." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} + { PUSH string "The sender is not the token contract associated with this contract." ; + FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + PUSH bool False ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CAR ; + NOT ; + IF {} + { PUSH string "Cannot change the baker while freezeBaker is true." ; + FAILWITH } ; + DUP ; + CAR ; + DIP { CDR } ; + SET_DELEGATE ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation } ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } + { DROP ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.diff new file mode 100644 index 000000000000..f0144a636aa0 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.diff @@ -0,0 +1,12 @@ +--- patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz ++++ patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz +@@ -293,7 +293,8 @@ + { IF_LEFT + { RENAME @amt_slash_33 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; +- PUSH @dest (contract :UnitContract unit) "tz1LBEKXaxQbd5Gtzbc1ATCwc3pppu81aWGc" ; ++ PUSH key_hash "tz1LBEKXaxQbd5Gtzbc1ATCwc3pppu81aWGc"; ++ IMPLICIT_ACCOUNT @dest; + { DIP { { DIP { DUP @amt } ; SWAP } } ; SWAP } ; + UNIT ; + TRANSFER_TOKENS @op ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz new file mode 100644 index 000000000000..ce3ec242a618 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.original.tz @@ -0,0 +1,596 @@ +{ parameter + (or (or (key_hash %set_delegate) (unit %remove_delegate)) + (or %default :_entries + (unit %_Liq_entry_main) + (or (nat %_Liq_entry_sellOut) + (or (mutez %_Liq_entry_withdraw) + (or (unit %_Liq_entry_deposit) + (pair :priceUpdate %_Liq_entry_updatePrices + (mutez %sellP) + (pair (mutez %buyP) (mutez %extraBalance)))))))) ; + storage + (pair key_hash + (pair :storage + (map %balances address nat) + (pair (string %name) + (pair (string %symbol) + (pair (nat %decimals) + (pair (nat %totalSupply) + (pair (mutez %inBaker) + (pair (address %owner) (pair (mutez %buyPrice) (mutez %sellPrice)))))))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { DIP { CDR ; NIL operation } ; + IF_LEFT + { SOME ; SET_DELEGATE ; CONS ; PAIR } + { DROP ; NONE key_hash ; SET_DELEGATE ; CONS ; PAIR } } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + DUP @parameter ; + IF_LEFT + { RENAME @nop_slash_3 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %buyPrice } ; + PUSH nat 1000000 ; + AMOUNT ; + MUL @micros ; + EDIV ; + IF_NONE + { PUSH string "Bad amount" ; FAILWITH } + { SENDER @addr ; + DUP @addr ; + CONTRACT unit ; + IF_NONE + { PUSH string "Cannot use this contract from non unit contract" ; FAILWITH } + { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } ; + CAR @tokens ; + { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @tokens } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CAR %totalSupply } ; + ADD ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + RENAME @have ; + { DIP { { DIP { { DIP { DUP @tokens } ; SWAP } } ; SWAP } } ; + SWAP } ; + ADD ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DIP { SOME } ; + DIP { DIP { DIP { DIP { DROP ; DROP } } } } ; + UPDATE ; + PAIR @s2 %balances ; + NIL operation ; + PAIR } ; + DIP { DROP ; DROP } } ; + DIP { DROP ; DROP } } + { IF_LEFT + { RENAME @amount_slash_14 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + PUSH mutez 1000000000000 ; + PUSH mutez 1000000 ; + { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } ; + MUL @zamt ; + EDIV ; + IF_NONE + { PUSH string "bad amount" ; FAILWITH } + { SENDER @addr ; + PUSH mutez 0 ; + AMOUNT @txAmount ; + COMPARE ; + NEQ ; + IF { PUSH string "cannot buy and sell in same transaction" ; FAILWITH } + { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } ; + CAR %balances ; + { DIP { DUP @addr } ; SWAP } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + RENAME @have ; + DUP @have ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + COMPARE ; + GT ; + IF { PUSH string "The address does not have that much stored" ; FAILWITH } + { { DIP { DUP @addr } ; SWAP } ; + CONTRACT unit ; + IF_NONE + { { DIP { DUP @addr } ; SWAP } ; + PUSH string "Cannot recover bool contract from:" ; + PAIR ; + FAILWITH } + { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CAR %totalSupply } ; + SUB ; + DUP ; + ABS ; + SWAP ; + GE ; + IF { { DIP { DUP @dst } ; SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR %sellPrice } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP } ; SWAP } } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR @nonMicros ; + MUL @toSend ; + UNIT ; + TRANSFER_TOKENS @op ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { DUP @have } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } ; + SUB ; + DUP ; + ABS ; + SWAP ; + GE ; + IF { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @newSupply } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { DUP @newBalance } ; SWAP } } ; SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DIP { SOME } ; + DIP { DIP { DIP { DIP { DROP } } } } ; + UPDATE ; + PAIR @s2 %balances ; + NIL operation ; + { DIP { { DIP { DUP } ; SWAP } } ; SWAP } ; + CONS ; + PAIR } + { PUSH string "bad amount" ; FAILWITH } ; + DIP { DROP ; DROP } } + { PUSH string "bad amount" ; FAILWITH } ; + DIP { DROP } } } ; + DIP { DROP } } ; + DIP { DROP ; DROP } } ; + DIP { DROP ; DROP } } + { IF_LEFT + { RENAME @amt_slash_33 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + PUSH @dest (contract :UnitContract unit) "tz1LBEKXaxQbd5Gtzbc1ATCwc3pppu81aWGc" ; + { DIP { { DIP { DUP @amt } ; SWAP } } ; SWAP } ; + UNIT ; + TRANSFER_TOKENS @op ; + { DIP { DUP @state } ; SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can withdraw" ; FAILWITH } + { { DIP { DUP @state } ; SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amt } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + ADD ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + NIL operation ; + { DIP { { DIP { DUP @op } ; SWAP } } ; SWAP } ; + CONS ; + PAIR } ; + DIP { DROP ; DROP ; DROP } } + { IF_LEFT + { RENAME @nop_slash_39 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can deposit" ; FAILWITH } + { DUP @state ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + AMOUNT @amount ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + SUB ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + NIL operation ; + PAIR } ; + DIP { DROP ; DROP } } + { RENAME @info_slash_44 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + DUP ; + CAR %inBaker ; + SWAP ; + CDR ; + DUP ; + CAR %owner ; + SWAP ; + CDR ; + CAR %buyPrice ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %sellP ; + SWAP ; + PAIR %buyPrice %sellPrice ; + SWAP ; + PAIR %owner ; + SWAP ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + DUP ; + CAR %inBaker ; + SWAP ; + CDR ; + DUP ; + CAR %owner ; + SWAP ; + CDR ; + CDR %sellPrice ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CAR %buyP } ; + PAIR %buyPrice %sellPrice ; + SWAP ; + PAIR %owner ; + SWAP ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s2 %balances ; + { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } ; + CAR %sellP ; + { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } ; + { CDR ; CAR %buyP } ; + COMPARE ; + LT ; + IF { PUSH string "invalid price, enables arbitrage" ; FAILWITH } + { { DIP { DUP @state } ; SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can set price" ; FAILWITH } + { DUP @s2 ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR %extraBalance } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @s2 } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + ADD ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s3 %balances ; + NIL operation ; + PAIR } } ; + DIP { DROP ; DROP ; DROP } } } } } ; + DIP { DROP ; DROP } } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz new file mode 100644 index 000000000000..265a4774c7e6 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD.patched.tz @@ -0,0 +1,597 @@ +{ parameter + (or (or (key_hash %set_delegate) (unit %remove_delegate)) + (or %default :_entries + (unit %_Liq_entry_main) + (or (nat %_Liq_entry_sellOut) + (or (mutez %_Liq_entry_withdraw) + (or (unit %_Liq_entry_deposit) + (pair :priceUpdate %_Liq_entry_updatePrices + (mutez %sellP) + (pair (mutez %buyP) (mutez %extraBalance)))))))) ; + storage + (pair key_hash + (pair :storage + (map %balances address nat) + (pair (string %name) + (pair (string %symbol) + (pair (nat %decimals) + (pair (nat %totalSupply) + (pair (mutez %inBaker) + (pair (address %owner) (pair (mutez %buyPrice) (mutez %sellPrice)))))))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { DIP { CDR ; NIL operation } ; + IF_LEFT + { SOME ; SET_DELEGATE ; CONS ; PAIR } + { DROP ; NONE key_hash ; SET_DELEGATE ; CONS ; PAIR } } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + DUP @parameter ; + IF_LEFT + { RENAME @nop_slash_3 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %buyPrice } ; + PUSH nat 1000000 ; + AMOUNT ; + MUL @micros ; + EDIV ; + IF_NONE + { PUSH string "Bad amount" ; FAILWITH } + { SENDER @addr ; + DUP @addr ; + CONTRACT unit ; + IF_NONE + { PUSH string "Cannot use this contract from non unit contract" ; FAILWITH } + { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } ; + CAR @tokens ; + { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @tokens } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CAR %totalSupply } ; + ADD ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + RENAME @have ; + { DIP { { DIP { { DIP { DUP @tokens } ; SWAP } } ; SWAP } } ; + SWAP } ; + ADD ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DIP { SOME } ; + DIP { DIP { DIP { DIP { DROP ; DROP } } } } ; + UPDATE ; + PAIR @s2 %balances ; + NIL operation ; + PAIR } ; + DIP { DROP ; DROP } } ; + DIP { DROP ; DROP } } + { IF_LEFT + { RENAME @amount_slash_14 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + PUSH mutez 1000000000000 ; + PUSH mutez 1000000 ; + { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } ; + MUL @zamt ; + EDIV ; + IF_NONE + { PUSH string "bad amount" ; FAILWITH } + { SENDER @addr ; + PUSH mutez 0 ; + AMOUNT @txAmount ; + COMPARE ; + NEQ ; + IF { PUSH string "cannot buy and sell in same transaction" ; FAILWITH } + { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } ; + CAR %balances ; + { DIP { DUP @addr } ; SWAP } ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + RENAME @have ; + DUP @have ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + COMPARE ; + GT ; + IF { PUSH string "The address does not have that much stored" ; FAILWITH } + { { DIP { DUP @addr } ; SWAP } ; + CONTRACT unit ; + IF_NONE + { { DIP { DUP @addr } ; SWAP } ; + PUSH string "Cannot recover bool contract from:" ; + PAIR ; + FAILWITH } + { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CAR %totalSupply } ; + SUB ; + DUP ; + ABS ; + SWAP ; + GE ; + IF { { DIP { DUP @dst } ; SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CDR %sellPrice } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP } ; SWAP } } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR @nonMicros ; + MUL @toSend ; + UNIT ; + TRANSFER_TOKENS @op ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amount } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { DUP @have } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } ; + SUB ; + DUP ; + ABS ; + SWAP ; + GE ; + IF { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @newSupply } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %balances ; + { DIP { { DIP { DUP @newBalance } ; SWAP } } ; SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @addr } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + DIP { SOME } ; + DIP { DIP { DIP { DIP { DROP } } } } ; + UPDATE ; + PAIR @s2 %balances ; + NIL operation ; + { DIP { { DIP { DUP } ; SWAP } } ; SWAP } ; + CONS ; + PAIR } + { PUSH string "bad amount" ; FAILWITH } ; + DIP { DROP ; DROP } } + { PUSH string "bad amount" ; FAILWITH } ; + DIP { DROP } } } ; + DIP { DROP } } ; + DIP { DROP ; DROP } } ; + DIP { DROP ; DROP } } + { IF_LEFT + { RENAME @amt_slash_33 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + PUSH key_hash "tz1LBEKXaxQbd5Gtzbc1ATCwc3pppu81aWGc"; + IMPLICIT_ACCOUNT @dest; + { DIP { { DIP { DUP @amt } ; SWAP } } ; SWAP } ; + UNIT ; + TRANSFER_TOKENS @op ; + { DIP { DUP @state } ; SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can withdraw" ; FAILWITH } + { { DIP { DUP @state } ; SWAP } ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @amt } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + ADD ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + NIL operation ; + { DIP { { DIP { DUP @op } ; SWAP } } ; SWAP } ; + CONS ; + PAIR } ; + DIP { DROP ; DROP ; DROP } } + { IF_LEFT + { RENAME @nop_slash_39 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can deposit" ; FAILWITH } + { DUP @state ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + AMOUNT @amount ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @state } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + SUB ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + NIL operation ; + PAIR } ; + DIP { DROP ; DROP } } + { RENAME @info_slash_44 ; + { DIP { { DIP { DUP @storage } ; SWAP } } ; SWAP } ; + DUP @state ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + DUP ; + CAR %inBaker ; + SWAP ; + CDR ; + DUP ; + CAR %owner ; + SWAP ; + CDR ; + CAR %buyPrice ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + CAR %sellP ; + SWAP ; + PAIR %buyPrice %sellPrice ; + SWAP ; + PAIR %owner ; + SWAP ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s1 %balances ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + DUP ; + CAR %inBaker ; + SWAP ; + CDR ; + DUP ; + CAR %owner ; + SWAP ; + CDR ; + CDR %sellPrice ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CAR %buyP } ; + PAIR %buyPrice %sellPrice ; + SWAP ; + PAIR %owner ; + SWAP ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s2 %balances ; + { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } ; + CAR %sellP ; + { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } ; + { CDR ; CAR %buyP } ; + COMPARE ; + LT ; + IF { PUSH string "invalid price, enables arbitrage" ; FAILWITH } + { { DIP { DUP @state } ; SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CDR ; CAR %owner } ; + SOURCE @addr ; + COMPARE ; + NEQ ; + IF { PUSH string "Only owner can set price" ; FAILWITH } + { DUP @s2 ; + DUP ; + CAR %balances ; + SWAP ; + CDR ; + DUP ; + CAR %name ; + SWAP ; + CDR ; + DUP ; + CAR %symbol ; + SWAP ; + CDR ; + DUP ; + CAR %decimals ; + SWAP ; + CDR ; + DUP ; + CAR %totalSupply ; + SWAP ; + CDR ; + CDR ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @info } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR %extraBalance } ; + { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { { DIP { DUP @s2 } ; SWAP } } ; SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } } ; + SWAP } ; + { CDR ; CDR ; CDR ; CDR ; CDR ; CAR %inBaker } ; + ADD ; + PAIR %inBaker ; + SWAP ; + PAIR %totalSupply ; + SWAP ; + PAIR %decimals ; + SWAP ; + PAIR %symbol ; + SWAP ; + PAIR %name ; + SWAP ; + PAIR @s3 %balances ; + NIL operation ; + PAIR } } ; + DIP { DROP ; DROP ; DROP } } } } } ; + DIP { DROP ; DROP } } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.diff new file mode 100644 index 000000000000..522e993afb15 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.diff @@ -0,0 +1,83 @@ +--- patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz ++++ patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz +@@ -245,7 +245,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -434,7 +434,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -746,7 +746,7 @@ + CDR ; + CAR ; + CONTRACT unit ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; +@@ -757,7 +757,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; +@@ -888,7 +888,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; +@@ -1028,7 +1028,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -1168,7 +1168,7 @@ + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; +@@ -1188,7 +1188,7 @@ + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; +@@ -1241,7 +1241,7 @@ + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; +- IF_NONE { FAILWITH } {} ; ++ IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz new file mode 100644 index 000000000000..2227de33667c --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.original.tz @@ -0,0 +1,1431 @@ +{ parameter + (or (or (or (pair %approve (address :spender) (pair (nat :allowance) (nat :currentAllowance))) + (pair %addLiquidity + (pair (address :owner) (nat :minLqtMinted)) + (pair (nat :maxTokensDeposited) (timestamp :deadline)))) + (or (pair %removeLiquidity + (pair (address :owner) (pair (address :to) (nat :lqtBurned))) + (pair (mutez :minXtzWithdrawn) (pair (nat :minTokensWithdrawn) (timestamp :deadline)))) + (or (pair %xtzToToken (address :to) (pair (nat :minTokensBought) (timestamp :deadline))) + (pair %tokenToXtz + (pair (address :owner) (address :to)) + (pair (nat :tokensSold) (pair (mutez :minXtzBought) (timestamp :deadline))))))) + (or (or (pair %tokenToToken + (pair (address :outputDexterContract) (pair (nat :minTokensBought) (address :owner))) + (pair (address :to) (pair (nat :tokensSold) (timestamp :deadline)))) + (or (key_hash %updateTokenPool) (nat %updateTokenPoolInternal))) + (or (pair %setBaker (option key_hash) bool) (or (address %setManager) (unit %default))))) ; + storage + (pair (big_map %accounts + (address :owner) + (pair (nat :balance) (map (address :spender) (nat :allowance)))) + (pair (pair (bool :selfIsUpdatingTokenPool) (pair (bool :freezeBaker) (nat :lqtTotal))) + (pair (pair (address :manager) (address :tokenAddress)) + (pair (nat :tokenPool) (mutez :xtzPool))))) ; + code { CAST (pair (or (or (or (pair address (pair nat nat)) (pair (pair address nat) (pair nat timestamp))) + (or (pair (pair address (pair address nat)) (pair mutez (pair nat timestamp))) + (or (pair address (pair nat timestamp)) + (pair (pair address address) (pair nat (pair mutez timestamp)))))) + (or (or (pair (pair address (pair nat address)) (pair address (pair nat timestamp))) + (or key_hash nat)) + (or (pair (option key_hash) bool) (or address unit)))) + (pair (big_map address (pair nat (map address nat))) + (pair (pair bool (pair bool nat)) (pair (pair address address) (pair nat mutez))))) ; + DUP ; + CAR ; + DIP { CDR } ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CAR ; + SENDER ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + COMPARE ; + EQ ; + IF {} + { PUSH string + "The current allowance parameter must equal the sender's current allowance for the owner." ; + FAILWITH } ; + DUP ; + CDR ; + DIG 2 ; + DUP ; + CAR ; + DIP { CDR ; CAR ; SOME } ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + NIL operation ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "maxTokensDeposited must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minLqtMinted must be greater than zero." ; FAILWITH } ; + AMOUNT ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "The amount of XTZ sent to Dexter must be greater than zero." ; + FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CDR ; + INT ; + EQ ; + IF { AMOUNT ; + PUSH mutez 1000000 ; + COMPARE ; + LE ; + IF {} + { PUSH string + "The initial liquidity amount must be greater than or equal to 1 XTZ." ; + FAILWITH } ; + SWAP ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + SWAP ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + DIP { DUP ; CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + EDIV ; + IF_NONE + { PUSH string "divByZero." ; FAILWITH } + { DUP ; + CAR ; + DIP { CDR } ; + SWAP ; + INT ; + EQ ; + IF {} { PUSH nat 1 ; ADD } } ; + DUP ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensDeposited is zero." ; FAILWITH } ; + SWAP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CAR ; + CDR ; + CDR ; + MUL ; + DIP { SWAP } ; + EDIV ; + IF_NONE { FAILWITH } { CAR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + DIP { DUP } ; + COMPARE ; + LE ; + IF {} + { PUSH string "lqtMinted must be greater than or equal to minLqtMinted." ; + FAILWITH } ; + DIP { DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + DIP { DUP } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensDeposited is greater than maxTokensDeposited." ; + FAILWITH } } ; + DIP 3 { DUP } ; + DIG 3 ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { DIP { DIG 3 ; DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minXtzWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "lqtBurned must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + DIP { DIP { DUP } ; SWAP ; CAR } ; + GET ; + IF_NONE { PUSH string "owner has no liquidity." ; FAILWITH } {} ; + SWAP ; + DUP ; + CAR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + COMPARE ; + GE ; + IF {} + { PUSH string "lqtBurned is greater than owner's balance." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF { SWAP ; CAR } + { SWAP ; + DUP ; + CDR ; + SENDER ; + GET ; + IF_NONE { PUSH string "sender has no approval balance." ; FAILWITH } {} ; + DIP { SWAP ; DUP ; CAR ; CDR ; CDR ; DIP { PUSH int 0 } } ; + SUB ; + DUP ; + DIP { COMPARE ; + GE ; + IF {} + { PUSH string "sender approval balance is less than LQT burned." ; FAILWITH } } ; + ABS ; + SOME ; + DIG 2 ; + DUP ; + CDR ; + DIG 2 ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CAR ; + DIP { SOME ; + DUG 1 ; + DUP ; + CAR ; + CAR ; + SWAP ; + DIP { DIP { DIP { DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR } } } ; + DIP { DUP } ; + SWAP ; + CAR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CDR ; CDR } ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "xtzWithdrawn is less than minXtzWithdrawn." ; FAILWITH } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CDR ; + DIP { DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + SWAP ; + CDR ; + CDR ; + CDR ; + CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "tokensWithdrawn is less than minTokensWithdrawn." ; FAILWITH } ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CDR ; + DIG 3 ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIG 4 ; + DUP ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIP 4 { DUP } ; + DIG 4 ; + CAR ; + CDR ; + CDR ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CAR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DIP { CAR ; CDR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; + PAIR ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + PUSH nat 1000 ; + MUL ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { PUSH nat 997 ; MUL ; ADD } ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensBought is less than minTokensBought." ; FAILWITH } } ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; SELF ; ADDRESS } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minXtzBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} { PUSH string "xtzBought is less than minXtzBought." ; FAILWITH } } ; + DIP { SWAP ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CDR ; CDR } ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 1 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } } } } + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + ADD ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; + IF_NONE { FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + DIP { DUP ; CAR ; CDR ; CAR ; DIP { DUP ; CDR ; CDR ; CDR } ; PAIR } ; + PAIR ; + SWAP ; + DROP ; + TRANSFER_TOKENS ; + SWAP ; + DIP { SWAP ; DUP ; CDR ; CDR ; CAR ; DIP { CAR ; CDR ; CDR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + NIL operation ; + SWAP ; + CONS ; + DIP { SWAP } ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "unsafeUpdateTokenPool" ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + PUSH bool True ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; + IF_NONE { FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CAR ; + IF {} { PUSH string "Dexter did not initiate this operation." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} + { PUSH string "The sender is not the token contract associated with this contract." ; + FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + PUSH bool False ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CAR ; + NOT ; + IF {} + { PUSH string "Cannot change the baker while freezeBaker is true." ; + FAILWITH } ; + DUP ; + CAR ; + DIP { CDR } ; + SET_DELEGATE ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation } ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } + { DROP ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz new file mode 100644 index 000000000000..ae1bef1807e2 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg.patched.tz @@ -0,0 +1,1431 @@ +{ parameter + (or (or (or (pair %approve (address :spender) (pair (nat :allowance) (nat :currentAllowance))) + (pair %addLiquidity + (pair (address :owner) (nat :minLqtMinted)) + (pair (nat :maxTokensDeposited) (timestamp :deadline)))) + (or (pair %removeLiquidity + (pair (address :owner) (pair (address :to) (nat :lqtBurned))) + (pair (mutez :minXtzWithdrawn) (pair (nat :minTokensWithdrawn) (timestamp :deadline)))) + (or (pair %xtzToToken (address :to) (pair (nat :minTokensBought) (timestamp :deadline))) + (pair %tokenToXtz + (pair (address :owner) (address :to)) + (pair (nat :tokensSold) (pair (mutez :minXtzBought) (timestamp :deadline))))))) + (or (or (pair %tokenToToken + (pair (address :outputDexterContract) (pair (nat :minTokensBought) (address :owner))) + (pair (address :to) (pair (nat :tokensSold) (timestamp :deadline)))) + (or (key_hash %updateTokenPool) (nat %updateTokenPoolInternal))) + (or (pair %setBaker (option key_hash) bool) (or (address %setManager) (unit %default))))) ; + storage + (pair (big_map %accounts + (address :owner) + (pair (nat :balance) (map (address :spender) (nat :allowance)))) + (pair (pair (bool :selfIsUpdatingTokenPool) (pair (bool :freezeBaker) (nat :lqtTotal))) + (pair (pair (address :manager) (address :tokenAddress)) + (pair (nat :tokenPool) (mutez :xtzPool))))) ; + code { CAST (pair (or (or (or (pair address (pair nat nat)) (pair (pair address nat) (pair nat timestamp))) + (or (pair (pair address (pair address nat)) (pair mutez (pair nat timestamp))) + (or (pair address (pair nat timestamp)) + (pair (pair address address) (pair nat (pair mutez timestamp)))))) + (or (or (pair (pair address (pair nat address)) (pair address (pair nat timestamp))) + (or key_hash nat)) + (or (pair (option key_hash) bool) (or address unit)))) + (pair (big_map address (pair nat (map address nat))) + (pair (pair bool (pair bool nat)) (pair (pair address address) (pair nat mutez))))) ; + DUP ; + CAR ; + DIP { CDR } ; + IF_LEFT + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CAR ; + SENDER ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + GET ; + IF_NONE { PUSH nat 0 } {} ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + COMPARE ; + EQ ; + IF {} + { PUSH string + "The current allowance parameter must equal the sender's current allowance for the owner." ; + FAILWITH } ; + DUP ; + CDR ; + DIG 2 ; + DUP ; + CAR ; + DIP { CDR ; CAR ; SOME } ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + NIL operation ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "maxTokensDeposited must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minLqtMinted must be greater than zero." ; FAILWITH } ; + AMOUNT ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "The amount of XTZ sent to Dexter must be greater than zero." ; + FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CDR ; + INT ; + EQ ; + IF { AMOUNT ; + PUSH mutez 1000000 ; + COMPARE ; + LE ; + IF {} + { PUSH string + "The initial liquidity amount must be greater than or equal to 1 XTZ." ; + FAILWITH } ; + SWAP ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + SWAP ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + DIP { DUP ; CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + EDIV ; + IF_NONE + { PUSH string "divByZero." ; FAILWITH } + { DUP ; + CAR ; + DIP { CDR } ; + SWAP ; + INT ; + EQ ; + IF {} { PUSH nat 1 ; ADD } } ; + DUP ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "tokensDeposited is zero." ; FAILWITH } ; + SWAP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CAR ; + CDR ; + CDR ; + MUL ; + DIP { SWAP } ; + EDIV ; + IF_NONE { FAILWITH } { CAR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + DIP { DUP } ; + COMPARE ; + LE ; + IF {} + { PUSH string "lqtMinted must be greater than or equal to minLqtMinted." ; + FAILWITH } ; + DIP { DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + DIP { DUP } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensDeposited is greater than maxTokensDeposited." ; + FAILWITH } } ; + DIP 3 { DUP } ; + DIG 3 ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DUP ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SOME ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CAR ; + DIP { DIP { DIG 3 ; DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minXtzWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensWithdrawn must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CDR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "lqtBurned must be greater than zero." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + DIP { DIP { DUP } ; SWAP ; CAR } ; + GET ; + IF_NONE { PUSH string "owner has no liquidity." ; FAILWITH } {} ; + SWAP ; + DUP ; + CAR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + COMPARE ; + GE ; + IF {} + { PUSH string "lqtBurned is greater than owner's balance." ; FAILWITH } ; + DUP ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF { SWAP ; CAR } + { SWAP ; + DUP ; + CDR ; + SENDER ; + GET ; + IF_NONE { PUSH string "sender has no approval balance." ; FAILWITH } {} ; + DIP { SWAP ; DUP ; CAR ; CDR ; CDR ; DIP { PUSH int 0 } } ; + SUB ; + DUP ; + DIP { COMPARE ; + GE ; + IF {} + { PUSH string "sender approval balance is less than LQT burned." ; FAILWITH } } ; + ABS ; + SOME ; + DIG 2 ; + DUP ; + CDR ; + DIG 2 ; + SENDER ; + UPDATE ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CAR ; + DIP { SOME ; + DUG 1 ; + DUP ; + CAR ; + CAR ; + SWAP ; + DIP { DIP { DIP { DUP ; CAR } } ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR } } } ; + DIP { DUP } ; + SWAP ; + CAR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CDR ; CDR } ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "xtzWithdrawn is less than minXtzWithdrawn." ; FAILWITH } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CDR ; + DIP { DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + SWAP ; + CDR ; + CDR ; + CDR ; + CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP 4 { DUP } ; + DIG 4 ; + CDR ; + CDR ; + CAR ; + COMPARE ; + LE ; + IF {} + { PUSH string "tokensWithdrawn is less than minTokensWithdrawn." ; FAILWITH } ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CDR ; + DIG 3 ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIG 4 ; + DUP ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + DIP { CAR } ; + GET ; + IF_NONE { EMPTY_MAP address nat ; PUSH nat 0 ; PAIR } {} ; + DIG 2 ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DIP { DUP ; CAR } ; + SOME ; + DIP 5 { DUP } ; + DIG 5 ; + CAR ; + CAR ; + UPDATE ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + CDR ; + DIP 4 { DUP } ; + DIG 4 ; + CAR ; + CDR ; + CDR ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 3 { DUP } ; + DIG 3 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 3 { DUP } ; + DIG 3 ; + CAR ; + CDR ; + CAR ; + CONTRACT unit ; + IF_NONE { CDR; FAILWITH } {} ; + DIG 3 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DIP { CAR ; CDR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 4 ; + PAIR ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + DUP ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + PUSH nat 1000 ; + MUL ; + AMOUNT ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + DUP ; + DIP { PUSH nat 997 ; MUL ; ADD } ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} + { PUSH string "tokensBought is less than minTokensBought." ; FAILWITH } } ; + DUP ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + SUB ; + DUP ; + PUSH int 0 ; + COMPARE ; + LE ; + IF { ABS } { PUSH string "" ; FAILWITH } ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP { DIP { CAR ; SELF ; ADDRESS } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + DIG 5 ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH mutez 0 ; + COMPARE ; + LT ; + IF {} { PUSH string "minXtzBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CAR } ; + COMPARE ; + GE ; + IF {} { PUSH string "xtzBought is less than minXtzBought." ; FAILWITH } } ; + DIP { SWAP ; + DUP ; + CDR ; + CDR ; + CDR ; + CAR ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CAR ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DUP ; + DIP { DIP { DUP ; CDR ; CDR ; CDR ; CDR } ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR } ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CDR ; + CONTRACT unit ; + IF_NONE { FAILWITH } {} ; + DIG 1 ; + UNIT ; + TRANSFER_TOKENS ; + DIP { DIP { DUP ; CDR ; CAR ; DIP { CAR ; CAR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS } ; + NIL operation ; + SWAP ; + CONS ; + SWAP ; + CONS ; + PAIR } } } } + { IF_LEFT + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CDR ; + NOW ; + COMPARE ; + LT ; + IF {} { PUSH string "NOW is greater than deadline." ; FAILWITH } ; + DUP ; + CAR ; + CDR ; + CAR ; + PUSH nat 0 ; + COMPARE ; + LT ; + IF {} + { PUSH string "minTokensBought must be greater than zero." ; FAILWITH } ; + DUP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 2 { DUP } ; + DIG 2 ; + CDR ; + CDR ; + CDR ; + CAR ; + PUSH nat 1000 ; + MUL ; + ADD ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + PUSH nat 997 ; + MUL ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP { PUSH mutez 1 } ; + EDIV ; + IF_NONE { PUSH string "" ; FAILWITH } { CAR } ; + MUL ; + EDIV ; + IF_NONE { PUSH string "divByZero." ; FAILWITH } { CAR } ; + PUSH mutez 1 ; + MUL ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + DIP 3 { DUP } ; + DIG 3 ; + CDR ; + CDR ; + CDR ; + CAR ; + ADD ; + DIP { DIG 2 } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + DIP 2 { DUP } ; + DIG 2 ; + SWAP ; + SUB ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DIP 2 { DUP } ; + DIG 2 ; + CAR ; + CAR ; + CONTRACT %xtzToToken (pair address (pair nat timestamp)) ; + IF_NONE { CDR; FAILWITH } {} ; + DIG 2 ; + DIP 3 { DUP } ; + DIG 3 ; + DUP ; + CDR ; + CAR ; + DIP { DUP ; CAR ; CDR ; CAR ; DIP { DUP ; CDR ; CDR ; CDR } ; PAIR } ; + PAIR ; + SWAP ; + DROP ; + TRANSFER_TOKENS ; + SWAP ; + DIP { SWAP ; DUP ; CDR ; CDR ; CAR ; DIP { CAR ; CDR ; CDR } } ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %transfer (pair address (pair address nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + DIG 3 ; + SELF ; + ADDRESS ; + DIG 5 ; + DIP { PAIR } ; + PAIR ; + TRANSFER_TOKENS ; + NIL operation ; + SWAP ; + CONS ; + DIP { SWAP } ; + SWAP ; + CONS ; + PAIR } + { IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "unsafeUpdateTokenPool" ; FAILWITH } ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + PUSH bool True ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + CDR ; + CAR ; + CDR ; + CONTRACT %getBalance (pair address (contract nat)) ; + IF_NONE { CDR; FAILWITH } {} ; + PUSH mutez 0 ; + SELF %updateTokenPoolInternal ; + SELF ; + ADDRESS ; + PAIR ; + TRANSFER_TOKENS ; + DIP { NIL operation } ; + CONS ; + PAIR } + { PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CAR ; + IF {} { PUSH string "Dexter did not initiate this operation." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CDR ; + SENDER ; + COMPARE ; + EQ ; + IF {} + { PUSH string "The sender is not the token contract associated with this contract." ; + FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + DUP ; + CDR ; + PUSH bool False ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CAR ; + CDR ; + CAR ; + NOT ; + IF {} + { PUSH string "Cannot change the baker while freezeBaker is true." ; + FAILWITH } ; + DUP ; + CAR ; + DIP { CDR } ; + SET_DELEGATE ; + DIP { DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation } ; + CONS ; + PAIR } + { IF_LEFT + { DIP { DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} } ; + PUSH mutez 0 ; + AMOUNT ; + COMPARE ; + EQ ; + IF {} { PUSH string "Amount must be zero." ; FAILWITH } ; + DIP { DUP } ; + SWAP ; + CDR ; + CDR ; + CAR ; + CAR ; + SENDER ; + COMPARE ; + EQ ; + IF {} { PUSH string "sender is not the contract manager." ; FAILWITH } ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + DIP { DUP ; DIP { CDR } ; CAR } ; + SWAP ; + DROP ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } + { DROP ; + DUP ; + CDR ; + CAR ; + CAR ; + IF { PUSH string "selfIsUpdatingToken must be false." ; FAILWITH } {} ; + DUP ; + CDR ; + CDR ; + CDR ; + CDR ; + AMOUNT ; + ADD ; + DIP { DUP ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + DIP { DUP ; DIP { CAR } ; CDR } ; + SWAP ; + DROP ; + SWAP ; + PAIR ; + NIL operation ; + PAIR } } } } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff new file mode 100644 index 000000000000..18f074777ba1 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff @@ -0,0 +1,64 @@ +--- patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz ++++ patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz +@@ -6,9 +6,9 @@ + (or (pair %Set_keys + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold)) +- (option %Set_delegate (key_hash %new_delegate)))) ++ (option %Set_delegate key_hash))) + (list %signatures (list (option signature)))) +- (option (pair %Pour (signature %pour_auth) (mutez %pour_amount)))) ; ++ (option (pair (signature %pour_auth) (mutez %pour_amount)))) ; + storage + (pair (pair (nat %replay_counter) + (pair %key_info +@@ -17,7 +17,7 @@ + (pair (pair %vesting + (pair %vesting_quantities (mutez %vested_balance) (mutez %vesting_increment)) + (pair %vesting_schedule (timestamp %next_payout) (int %payout_interval))) +- (option %pour_info (pair (contract %pour_dest unit) (key %pour_authorizer))))) ; ++ (option (pair (address %pour_dest) (key %pour_authorizer))))) ; + code { DUP ; + CAR ; + IF_LEFT +@@ -93,7 +93,8 @@ + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + SWAP ; +- SUB @vested_balance ; ++ SUB_MUTEZ ; ++ IF_NONE { UNIT ; FAILWITH } { RENAME @vested_balance } ; + DIP { CDR %vesting_increment @% } ; + PAIR @vesting_quantities %@ %@ ; + DIP { DUP ; CAR ; CDR %vesting_schedule @% ; DIP { CDR %pour_info @% } } ; +@@ -109,7 +110,10 @@ + TRANSFER_TOKENS @transfer_op ; + CONS @operations } + { SWAP ; +- DIP { SWAP ; ++ DIP { IF_NONE ++ { NONE (pair address key) } ++ { UNPAIR ; ADDRESS ; PAIR; SOME } ; ++ SWAP ; + DUP ; + CAR ; + DIP { CDR ; CAR %vesting @% ; PAIR %vesting %pour_info } ; +@@ -191,7 +195,8 @@ + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; +- SUB @new_cur_balance ; ++ SUB_MUTEZ @new_cur_balance ; ++ IF_NONE { UNIT ; FAILWITH } {} ; + DIP { CDR %vesting_increment @% } ; + PAIR %vested_balance %@ @vesting_quantities ; + DIP { CDR %vesting_schedule @% } ; +@@ -215,6 +220,8 @@ + DIP { SWAP ; + DUP ; + CAR %pour_dest @% ; ++ CONTRACT unit ; ++ { IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} } ; + DIP { DUP ; + CDR %pour_authorizer @% ; + DIP { CAR %pour_dest @% ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz new file mode 100644 index 000000000000..c5e4b394328f --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.original.tz @@ -0,0 +1,232 @@ +{ parameter + (or (pair %Action + (or %action_input + (or (pair %Transfer (contract %dest unit) (mutez %transfer_amount)) + (option %Set_pour (pair (contract %pour_dest unit) (key %pour_authorizer)))) + (or (pair %Set_keys + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold)) + (option %Set_delegate (key_hash %new_delegate)))) + (list %signatures (list (option signature)))) + (option (pair %Pour (signature %pour_auth) (mutez %pour_amount)))) ; + storage + (pair (pair (nat %replay_counter) + (pair %key_info + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold))) + (pair (pair %vesting + (pair %vesting_quantities (mutez %vested_balance) (mutez %vesting_increment)) + (pair %vesting_schedule (timestamp %next_payout) (int %payout_interval))) + (option %pour_info (pair (contract %pour_dest unit) (key %pour_authorizer))))) ; + code { DUP ; + CAR ; + IF_LEFT + { DIP { CDR ; DUP ; NIL @operations operation ; SWAP } ; + SWAP ; + CAR ; + DUP ; + CDR %key_info @% ; + DIP { CAR %replay_counter @% ; + DIP { DUP ; CDR %signatures @% } ; + SWAP ; + DIP { DIP { CAR %action_input @% ; DUP } ; + SELF ; + ADDRESS ; + PAIR ; + SWAP ; + PAIR ; + PACK @packed } } ; + SWAP ; + DIP { DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @% ; INT @overall_counter ; SWAP } } ; + ITER { DIP { IF_CONS + { DIP { SWAP } ; + DUP ; + CAR @%% ; + DIP { CDR @%% ; INT @group_counter ; SWAP } } + { { UNIT ; FAILWITH } } } ; + ITER { DIP { IF_CONS {} { { UNIT ; FAILWITH } } } ; + IF_NONE + { DROP } + { SWAP ; + DIP { DIP { SWAP ; DIP { DIP { PUSH int -1 ; ADD @group_counter } } ; DUP } } ; + CHECK_SIGNATURE @sig_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + SWAP } } ; + { DIP { DIP { PUSH int 0 ; + { COMPARE ; GE @group_threshold_met } ; + IF { DIP { PUSH int -1 ; ADD @overall_counter } } {} } } } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + SWAP } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + DROP ; + PUSH int 0 ; + { COMPARE ; GE @overall_threshold_met } ; + { IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DIP { DUP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + PUSH nat 1 ; + ADD @replay_counter ; + DIP { CDR %key_info @% } ; + PAIR %@ %@ ; + DIP { CDR } ; + PAIR } } } ; + IF_LEFT + { IF_LEFT + { DUP ; + DIP { CDR %transfer_amount @% ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; + CDR ; + DUP ; + CAR ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + SWAP ; + SUB @vested_balance ; + DIP { CDR %vesting_increment @% } ; + PAIR @vesting_quantities %@ %@ ; + DIP { DUP ; CAR ; CDR %vesting_schedule @% ; DIP { CDR %pour_info @% } } ; + PAIR @vesting %@ %@ ; + PAIR %@ %@ ; + SWAP ; + CAR ; + PAIR } } ; + DUP ; + CDR %transfer_amount @% ; + DIP { CAR %dest @% } ; + UNIT ; + TRANSFER_TOKENS @transfer_op ; + CONS @operations } + { SWAP ; + DIP { SWAP ; + DUP ; + CAR ; + DIP { CDR ; CAR %vesting @% ; PAIR %vesting %pour_info } ; + PAIR @storage } } } + { IF_LEFT + { DUP ; + DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @new_threshold ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH @counter nat 0 } ; + ITER { DUP ; + CAR %signatories @%% ; + DIP { CDR %group_threshold @%% ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } } ; + SIZE @num_keys ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH nat 1 ; + ADD @counter } ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; CAR ; CAR %replay_counter } ; + SWAP ; + PAIR %@ %key_info ; + DIP { CDR } ; + PAIR @storage } } + { SET_DELEGATE @set_delegate_op ; CONS } } ; + PAIR } + { IF_NONE + { CDR ; + DUP ; + CDR ; + DUP ; + DIP { CDR %pour_info @% } ; + CAR %vesting @% ; + DUP ; + CDR %vesting_schedule @% ; + DUP ; + CAR %next_payout @% ; + DUP ; + NOW ; + { COMPARE ; GT } ; + { IF {} { { UNIT ; FAILWITH } } } ; + DIP { CDR %payout_interval @% ; DUP } ; + ADD @new_next_payout ; + PAIR %next_payout %@ @new_vesting_schedule ; + SWAP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DIP { CDR %vesting_increment @% ; DUP } ; + ADD @new_balance ; + PAIR %vested_balance %@ ; + PAIR %vesting_quantities %vesting_schedule ; + PAIR %vesting %@ ; + SWAP ; + CAR ; + PAIR @storage ; + NIL operation } + { DIP { CDR ; + DUP ; + CDR ; + DUP ; + CAR %vesting @% ; + DUP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { CDR %pour_amount @%% ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + SUB @new_cur_balance ; + DIP { CDR %vesting_increment @% } ; + PAIR %vested_balance %@ @vesting_quantities ; + DIP { CDR %vesting_schedule @% } ; + PAIR %@ %@ @vesting ; + DIP { CDR %pour_info @% ; DUP ; IF_NONE { { UNIT ; FAILWITH } } {} } ; + SWAP ; + DIP { PAIR %@ %@ ; + SWAP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + DUP ; + PUSH nat 1 ; + ADD @replay_counter ; + SWAP ; + SELF ; + ADDRESS ; + PAIR ; + DIP { DIP { CDR %key_info @% } ; PAIR %@ %@ ; PAIR @storage } } } ; + DUP ; + DIP { SWAP ; + DUP ; + CAR %pour_dest @% ; + DIP { DUP ; + CDR %pour_authorizer @% ; + DIP { CAR %pour_dest @% ; + SWAP ; + DUP ; + CAR %pour_auth @% ; + DIP { CDR %pour_amount @% ; SWAP ; PAIR ; PAIR ; PACK @packed } } ; + CHECK_SIGNATURE @pour_auth_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + NIL operation } } ; + CDR %pour_amount @% ; + UNIT ; + TRANSFER_TOKENS @pour_op ; + CONS } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz new file mode 100644 index 000000000000..6c1d3712648c --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz @@ -0,0 +1,239 @@ +{ parameter + (or (pair %Action + (or %action_input + (or (pair %Transfer (contract %dest unit) (mutez %transfer_amount)) + (option %Set_pour (pair (contract %pour_dest unit) (key %pour_authorizer)))) + (or (pair %Set_keys + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold)) + (option %Set_delegate key_hash))) + (list %signatures (list (option signature)))) + (option (pair (signature %pour_auth) (mutez %pour_amount)))) ; + storage + (pair (pair (nat %replay_counter) + (pair %key_info + (list %key_groups (pair (list %signatories key) (nat %group_threshold))) + (nat %overall_threshold))) + (pair (pair %vesting + (pair %vesting_quantities (mutez %vested_balance) (mutez %vesting_increment)) + (pair %vesting_schedule (timestamp %next_payout) (int %payout_interval))) + (option (pair (address %pour_dest) (key %pour_authorizer))))) ; + code { DUP ; + CAR ; + IF_LEFT + { DIP { CDR ; DUP ; NIL @operations operation ; SWAP } ; + SWAP ; + CAR ; + DUP ; + CDR %key_info @% ; + DIP { CAR %replay_counter @% ; + DIP { DUP ; CDR %signatures @% } ; + SWAP ; + DIP { DIP { CAR %action_input @% ; DUP } ; + SELF ; + ADDRESS ; + PAIR ; + SWAP ; + PAIR ; + PACK @packed } } ; + SWAP ; + DIP { DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @% ; INT @overall_counter ; SWAP } } ; + ITER { DIP { IF_CONS + { DIP { SWAP } ; + DUP ; + CAR @%% ; + DIP { CDR @%% ; INT @group_counter ; SWAP } } + { { UNIT ; FAILWITH } } } ; + ITER { DIP { IF_CONS {} { { UNIT ; FAILWITH } } } ; + IF_NONE + { DROP } + { SWAP ; + DIP { DIP { SWAP ; DIP { DIP { PUSH int -1 ; ADD @group_counter } } ; DUP } } ; + CHECK_SIGNATURE @sig_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + SWAP } } ; + { DIP { DIP { PUSH int 0 ; + { COMPARE ; GE @group_threshold_met } ; + IF { DIP { PUSH int -1 ; ADD @overall_counter } } {} } } } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + SWAP } ; + IF_CONS { { UNIT ; FAILWITH } } {} ; + DROP ; + PUSH int 0 ; + { COMPARE ; GE @overall_threshold_met } ; + { IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DIP { DUP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + PUSH nat 1 ; + ADD @replay_counter ; + DIP { CDR %key_info @% } ; + PAIR %@ %@ ; + DIP { CDR } ; + PAIR } } } ; + IF_LEFT + { IF_LEFT + { DUP ; + DIP { CDR %transfer_amount @% ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; + CDR ; + DUP ; + CAR ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + SWAP ; + SUB_MUTEZ ; + IF_NONE { UNIT ; FAILWITH } { RENAME @vested_balance } ; + DIP { CDR %vesting_increment @% } ; + PAIR @vesting_quantities %@ %@ ; + DIP { DUP ; CAR ; CDR %vesting_schedule @% ; DIP { CDR %pour_info @% } } ; + PAIR @vesting %@ %@ ; + PAIR %@ %@ ; + SWAP ; + CAR ; + PAIR } } ; + DUP ; + CDR %transfer_amount @% ; + DIP { CAR %dest @% } ; + UNIT ; + TRANSFER_TOKENS @transfer_op ; + CONS @operations } + { SWAP ; + DIP { IF_NONE + { NONE (pair address key) } + { UNPAIR ; ADDRESS ; PAIR; SOME } ; + SWAP ; + DUP ; + CAR ; + DIP { CDR ; CAR %vesting @% ; PAIR %vesting %pour_info } ; + PAIR @storage } } } + { IF_LEFT + { DUP ; + DUP ; + CAR %key_groups @% ; + DIP { CDR %overall_threshold @new_threshold ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH @counter nat 0 } ; + ITER { DUP ; + CAR %signatories @%% ; + DIP { CDR %group_threshold @%% ; + DUP ; + PUSH nat 0 ; + { { COMPARE ; LT } ; IF {} { { UNIT ; FAILWITH } } } } ; + SIZE @num_keys ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + PUSH nat 1 ; + ADD @counter } ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + DIP { DIP { DUP ; CAR ; CAR %replay_counter } ; + SWAP ; + PAIR %@ %key_info ; + DIP { CDR } ; + PAIR @storage } } + { SET_DELEGATE @set_delegate_op ; CONS } } ; + PAIR } + { IF_NONE + { CDR ; + DUP ; + CDR ; + DUP ; + DIP { CDR %pour_info @% } ; + CAR %vesting @% ; + DUP ; + CDR %vesting_schedule @% ; + DUP ; + CAR %next_payout @% ; + DUP ; + NOW ; + { COMPARE ; GT } ; + { IF {} { { UNIT ; FAILWITH } } } ; + DIP { CDR %payout_interval @% ; DUP } ; + ADD @new_next_payout ; + PAIR %next_payout %@ @new_vesting_schedule ; + SWAP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DIP { CDR %vesting_increment @% ; DUP } ; + ADD @new_balance ; + PAIR %vested_balance %@ ; + PAIR %vesting_quantities %vesting_schedule ; + PAIR %vesting %@ ; + SWAP ; + CAR ; + PAIR @storage ; + NIL operation } + { DIP { CDR ; + DUP ; + CDR ; + DUP ; + CAR %vesting @% ; + DUP ; + CAR %vesting_quantities @% ; + DUP ; + CAR %vested_balance @% ; + DUP } ; + DUP ; + DIP { CDR %pour_amount @%% ; + DUP ; + DIP { { { COMPARE ; LE } ; IF {} { { UNIT ; FAILWITH } } } } ; + DUP ; + BALANCE @balance ; + { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; + SWAP ; + SUB_MUTEZ @new_cur_balance ; + IF_NONE { UNIT ; FAILWITH } {} ; + DIP { CDR %vesting_increment @% } ; + PAIR %vested_balance %@ @vesting_quantities ; + DIP { CDR %vesting_schedule @% } ; + PAIR %@ %@ @vesting ; + DIP { CDR %pour_info @% ; DUP ; IF_NONE { { UNIT ; FAILWITH } } {} } ; + SWAP ; + DIP { PAIR %@ %@ ; + SWAP ; + CAR ; + DUP ; + CAR %replay_counter @% ; + DUP ; + PUSH nat 1 ; + ADD @replay_counter ; + SWAP ; + SELF ; + ADDRESS ; + PAIR ; + DIP { DIP { CDR %key_info @% } ; PAIR %@ %@ ; PAIR @storage } } } ; + DUP ; + DIP { SWAP ; + DUP ; + CAR %pour_dest @% ; + CONTRACT unit ; + { IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} } ; + DIP { DUP ; + CDR %pour_authorizer @% ; + DIP { CAR %pour_dest @% ; + SWAP ; + DUP ; + CAR %pour_auth @% ; + DIP { CDR %pour_amount @% ; SWAP ; PAIR ; PAIR ; PACK @packed } } ; + CHECK_SIGNATURE @pour_auth_ok ; + { IF {} { { UNIT ; FAILWITH } } } ; + NIL operation } } ; + CDR %pour_amount @% ; + UNIT ; + TRANSFER_TOKENS @pour_op ; + CONS } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.diff new file mode 100644 index 000000000000..b692e4df4aef --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.diff @@ -0,0 +1,23 @@ +--- patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz ++++ patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz +@@ -1,10 +1,6 @@ + { parameter (or (lambda %do unit (list operation)) (unit %default)) ; + storage +- (pair key_hash +- (contract +- (or (option address) +- (or (pair (option address) (option mutez)) +- (or mutez (or (pair (option address) (option mutez)) address)))))) ; ++ (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT +@@ -28,6 +24,8 @@ + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; ++ CONTRACT (or (option address) (or (pair (option address) (option mutez)) (or mutez (or (pair (option address) (option mutez)) address)))); ++ IF_SOME {} {PUSH string "Bad contract in storage!"; FAILWITH}; + AMOUNT ; + NONE mutez ; + SENDER ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz new file mode 100644 index 000000000000..a4181d4ef03a --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.original.tz @@ -0,0 +1,46 @@ +{ parameter (or (lambda %do unit (list operation)) (unit %default)) ; + storage + (pair key_hash + (contract + (or (option address) + (or (pair (option address) (option mutez)) + (or mutez (or (pair (option address) (option mutez)) address)))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { CDR ; + DUP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + AMOUNT ; + NONE mutez ; + SENDER ; + SOME ; + PAIR ; + LEFT (or mutez (or (pair (option address) (option mutez)) address)) ; + RIGHT (option address) ; + TRANSFER_TOKENS ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz new file mode 100644 index 000000000000..2d206fe82d15 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ.patched.tz @@ -0,0 +1,44 @@ +{ parameter (or (lambda %do unit (list operation)) (unit %default)) ; + storage + (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { CDR ; + DUP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONTRACT (or (option address) (or (pair (option address) (option mutez)) (or mutez (or (pair (option address) (option mutez)) address)))); + IF_SOME {} {PUSH string "Bad contract in storage!"; FAILWITH}; + AMOUNT ; + NONE mutez ; + SENDER ; + SOME ; + PAIR ; + LEFT (or mutez (or (pair (option address) (option mutez)) address)) ; + RIGHT (option address) ; + TRANSFER_TOKENS ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.diff new file mode 100644 index 000000000000..2aaf7c9fc19d --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.diff @@ -0,0 +1,19 @@ +--- patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz ++++ patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz +@@ -1,6 +1,6 @@ + { parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage +- (pair key_hash (contract (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))))) ; ++ (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT +@@ -215,6 +215,8 @@ + RENAME @__pt_parameter ; + DIP { DROP } ; + { DIP { DUP } ; SWAP } ; ++ CONTRACT (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))); ++ IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz new file mode 100644 index 000000000000..32a80eb45e2d --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.original.tz @@ -0,0 +1,234 @@ +{ parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage + (pair key_hash (contract (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + PUSH (pair (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))) + (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))))) + (Pair (Pair (Pair 0 0) (Pair 0 (Pair 0 (Pair 0 255)))) {}) ; + { DIP { DUP @parameter } ; SWAP } ; + ITER { RENAME @_pointcolor_old_pt_old_color_list_slash_3 ; + DIP { DUP } ; + PAIR ; + DUP ; + CAR @pointcolor ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + INT ; + { DIP { DIP { DIP { DIP { DIP { DUP @color } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH string "Wrong range" ; FAILWITH } } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; + { DIP { DUP @color } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; { DIP { DUP @head } ; SWAP } ; PAIR ; NIL nat ; PAIR } ; + DIP { DROP ; DROP } } + { PUSH (pair (list nat) (pair (list nat) int)) (Pair {} (Pair {} 1)) } ; + RENAME @_pt2_pcolor2_n ; + DUP ; + { CDR ; CAR @pcolor2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong color" ; FAILWITH } + { DUP @a ; + { DIP { DIP { DIP { DUP @b } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + { DIP { DUP @b } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @g } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @r } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DUP } ; SWAP } ; CDR ; CAR ; CDR @old_color } ; + RENAME @pcolor ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + CDR ; + CAR ; + CAR @old_pt ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @pt2 ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR @n } ; + PAIR ; + PUSH bool True ; + LOOP { RENAME @tmp_sharp_1_slash_35 ; + DUP @tmp_sharp_1 ; + DUP ; + CAR @n ; + { DIP { DUP } ; SWAP } ; + { CDR ; CDR } ; + CAR @old_pt ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DIP { DIP { DIP { DUP @pcolor } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + { CDR ; CAR @pt2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong coordinates" ; FAILWITH } + { DUP @y ; + { DIP { DIP { DIP { DUP @x } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + CDR ; + { DIP { DUP @x } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + PUSH nat 1 ; + { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + CAR ; + ADD ; + PAIR } ; + RENAME @pt ; + { DIP { DIP { DIP { DIP { DIP { DROP ; DROP } } } } } } ; + PAIR @pt ; + CONS @list ; + SWAP ; + PAIR ; + NIL nat ; + PAIR ; + PUSH int 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + SUB ; + PAIR ; + PUSH int 0 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + COMPARE ; + GT ; + PAIR ; + DUP ; + CAR ; + DIP { CDR } } ; + RENAME @__n__pt2_old_pt_list ; + { DIP { DIP { DROP ; DROP ; DROP } } } ; + DUP ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CAR @old_pt ; + PAIR ; + PAIR } ; + RENAME @__pt_parameter ; + DIP { DROP } ; + { DIP { DUP } ; SWAP } ; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CDR @parameter ; + TRANSFER_TOKENS @op ; + SWAP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz new file mode 100644 index 000000000000..182aba56d6a5 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU.patched.tz @@ -0,0 +1,236 @@ +{ parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage + (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + PUSH (pair (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))) + (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))))) + (Pair (Pair (Pair 0 0) (Pair 0 (Pair 0 (Pair 0 255)))) {}) ; + { DIP { DUP @parameter } ; SWAP } ; + ITER { RENAME @_pointcolor_old_pt_old_color_list_slash_3 ; + DIP { DUP } ; + PAIR ; + DUP ; + CAR @pointcolor ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + INT ; + { DIP { DIP { DIP { DIP { DIP { DUP @color } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH string "Wrong range" ; FAILWITH } } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; + { DIP { DUP @color } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; { DIP { DUP @head } ; SWAP } ; PAIR ; NIL nat ; PAIR } ; + DIP { DROP ; DROP } } + { PUSH (pair (list nat) (pair (list nat) int)) (Pair {} (Pair {} 1)) } ; + RENAME @_pt2_pcolor2_n ; + DUP ; + { CDR ; CAR @pcolor2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong color" ; FAILWITH } + { DUP @a ; + { DIP { DIP { DIP { DUP @b } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + { DIP { DUP @b } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @g } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @r } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DUP } ; SWAP } ; CDR ; CAR ; CDR @old_color } ; + RENAME @pcolor ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + CDR ; + CAR ; + CAR @old_pt ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @pt2 ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR @n } ; + PAIR ; + PUSH bool True ; + LOOP { RENAME @tmp_sharp_1_slash_35 ; + DUP @tmp_sharp_1 ; + DUP ; + CAR @n ; + { DIP { DUP } ; SWAP } ; + { CDR ; CDR } ; + CAR @old_pt ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DIP { DIP { DIP { DUP @pcolor } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + { CDR ; CAR @pt2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong coordinates" ; FAILWITH } + { DUP @y ; + { DIP { DIP { DIP { DUP @x } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + CDR ; + { DIP { DUP @x } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + PUSH nat 1 ; + { DIP { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + CAR ; + ADD ; + PAIR } ; + RENAME @pt ; + { DIP { DIP { DIP { DIP { DIP { DROP ; DROP } } } } } } ; + PAIR @pt ; + CONS @list ; + SWAP ; + PAIR ; + NIL nat ; + PAIR ; + PUSH int 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + SUB ; + PAIR ; + PUSH int 0 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + COMPARE ; + GT ; + PAIR ; + DUP ; + CAR ; + DIP { CDR } } ; + RENAME @__n__pt2_old_pt_list ; + { DIP { DIP { DROP ; DROP ; DROP } } } ; + DUP ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CAR @old_pt ; + PAIR ; + PAIR } ; + RENAME @__pt_parameter ; + DIP { DROP } ; + { DIP { DUP } ; SWAP } ; + CONTRACT (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))); + IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CDR @parameter ; + TRANSFER_TOKENS @op ; + SWAP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.diff new file mode 100644 index 000000000000..72cad3c3069f --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.diff @@ -0,0 +1,19 @@ +--- patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz ++++ patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz +@@ -1,6 +1,6 @@ + { parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage +- (pair key_hash (contract (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))))) ; ++ (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT +@@ -214,6 +214,8 @@ + DIP { DROP } ; + RENAME @__pt_parameter ; + { DIP { DUP } ; SWAP } ; ++ CONTRACT (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))); ++ IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz new file mode 100644 index 000000000000..3aed2d80c4c3 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.original.tz @@ -0,0 +1,233 @@ +{ parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage + (pair key_hash (contract (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + PUSH (pair (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))) + (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))))) + (Pair (Pair (Pair 0 0) (Pair 0 (Pair 0 (Pair 0 255)))) {}) ; + { DIP { DUP @parameter } ; SWAP } ; + ITER { RENAME @_pointcolor_old_pt_old_color_list_slash_3 ; + DIP { DUP } ; + PAIR ; + DUP ; + CAR @pointcolor ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + INT ; + { DIP { DIP { DIP { DIP { DIP { DUP @color } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH string "Wrong range" ; FAILWITH } } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; + { DIP { DUP @color } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; { DIP { DUP @head } ; SWAP } ; PAIR ; NIL nat ; PAIR } ; + DIP { DROP ; DROP } } + { PUSH (pair (list nat) (pair (list nat) int)) (Pair {} (Pair {} 1)) } ; + RENAME @_pt2_pcolor2_n ; + DUP ; + { CDR ; CAR @pcolor2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong color" ; FAILWITH } + { DUP @a ; + { DIP { DIP { DIP { DUP @b } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + { DIP { DUP @b } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @g } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @r } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DUP } ; SWAP } ; CDR ; CAR ; CDR @old_color } ; + RENAME @pcolor ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + CDR ; + CAR ; + CAR @old_pt ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @pt2 ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR @n } ; + PAIR ; + PUSH bool True ; + LOOP { RENAME @tmp_sharp_1_slash_35 ; + DUP @tmp_sharp_1 ; + DUP ; + { CDR ; CDR } ; + CAR @old_pt ; + { DIP { DUP } ; SWAP } ; + { CDR ; CAR @pt2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong coordinates" ; FAILWITH } + { DUP @y ; + { DIP { DIP { DIP { DUP @x } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + { DIP { DUP @x } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { DUP ; + CDR ; + PUSH nat 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR ; + ADD ; + PAIR } ; + DIP { DROP } ; + { DIP { DIP { DROP } } } ; + RENAME @pt ; + PUSH int 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @n ; + SUB @n ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + PAIR @pt_color ; + CONS @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + PAIR ; + NIL nat ; + PAIR ; + { DIP { DUP } ; SWAP } ; + PAIR ; + PUSH int 0 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + COMPARE ; + GT ; + PAIR ; + DUP ; + CAR ; + DIP { CDR } } ; + { DIP { DIP { DROP ; DROP ; DROP } } } ; + RENAME @__n__pt2_old_pt_list ; + DUP ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CAR @old_pt ; + PAIR ; + PAIR } ; + DIP { DROP } ; + RENAME @__pt_parameter ; + { DIP { DUP } ; SWAP } ; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CDR @parameter ; + TRANSFER_TOKENS @op ; + SWAP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz new file mode 100644 index 000000000000..893b37c0fac5 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3.patched.tz @@ -0,0 +1,235 @@ +{ parameter (or (lambda %do unit (list operation)) (list %default (list (list nat)))) ; + storage + (pair key_hash address) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH mutez 0 ; + AMOUNT ; + { { COMPARE ; EQ } ; IF {} { { UNIT ; FAILWITH } } } ; + { DIP { DUP } ; SWAP } ; + CDR ; + CAR ; + IMPLICIT_ACCOUNT ; + ADDRESS ; + SENDER ; + { COMPARE ; + NEQ ; + IF { SENDER ; PUSH string "Only the owner can operate." ; PAIR ; FAILWITH } + { UNIT ; EXEC ; DIP { CDR } ; PAIR } } } + { DIP { CDR ; DUP ; CDR } ; + PAIR ; + { DUP ; + DIP { CDR } ; + CAR ; + PUSH (pair (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))) + (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat)))))) + (Pair (Pair (Pair 0 0) (Pair 0 (Pair 0 (Pair 0 255)))) {}) ; + { DIP { DUP @parameter } ; SWAP } ; + ITER { RENAME @_pointcolor_old_pt_old_color_list_slash_3 ; + DIP { DUP } ; + PAIR ; + DUP ; + CAR @pointcolor ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + IF_CONS + { { DIP { DUP @tail } ; SWAP } ; + IF_CONS + { PUSH string "Wrong point" ; FAILWITH } + { DUP @n ; + INT ; + { DIP { DIP { DIP { DIP { DIP { DUP @color } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH string "Wrong range" ; FAILWITH } } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; + { DIP { DUP @color } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @head } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH int 1 ; { DIP { DUP @head } ; SWAP } ; PAIR ; NIL nat ; PAIR } ; + DIP { DROP ; DROP } } + { PUSH (pair (list nat) (pair (list nat) int)) (Pair {} (Pair {} 1)) } ; + RENAME @_pt2_pcolor2_n ; + DUP ; + { CDR ; CAR @pcolor2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong color" ; FAILWITH } + { DUP @a ; + { DIP { DIP { DIP { DUP @b } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + { DIP { DUP @b } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @g } ; SWAP } ; SWAP } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + SWAP } ; + SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @g } ; SWAP } ; + PAIR ; + { DIP { DIP { DIP { DUP @r } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { PUSH nat 255 ; + PUSH nat 0 ; + PAIR ; + PUSH nat 0 ; + PAIR ; + { DIP { DUP @r } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DUP } ; SWAP } ; CDR ; CAR ; CDR @old_color } ; + RENAME @pcolor ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + CDR ; + CAR ; + CAR @old_pt ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @pt2 ; + PAIR ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { CDR ; CDR @n } ; + PAIR ; + PUSH bool True ; + LOOP { RENAME @tmp_sharp_1_slash_35 ; + DUP @tmp_sharp_1 ; + DUP ; + { CDR ; CDR } ; + CAR @old_pt ; + { DIP { DUP } ; SWAP } ; + { CDR ; CAR @pt2 } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { { DIP { DUP @tl } ; SWAP } ; + IF_CONS + { PUSH string "Wrong coordinates" ; FAILWITH } + { DUP @y ; + { DIP { DIP { DIP { DUP @x } ; SWAP } ; SWAP } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CDR ; + { DIP { DUP @x } ; SWAP } ; + PAIR } ; + DIP { DROP ; DROP } } + { DUP ; + CDR ; + PUSH nat 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR ; + ADD ; + PAIR } ; + DIP { DROP } ; + { DIP { DIP { DROP } } } ; + RENAME @pt ; + PUSH int 1 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + CAR @n ; + SUB @n ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DUP } ; SWAP } ; SWAP } ; SWAP } ; + PAIR @pt_color ; + CONS @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + PAIR ; + NIL nat ; + PAIR ; + { DIP { DUP } ; SWAP } ; + PAIR ; + PUSH int 0 ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + COMPARE ; + GT ; + PAIR ; + DUP ; + CAR ; + DIP { CDR } } ; + { DIP { DIP { DROP ; DROP ; DROP } } } ; + RENAME @__n__pt2_old_pt_list ; + DUP ; + { CDR ; CDR } ; + CDR @list ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + { CDR ; CDR } ; + CAR @old_pt ; + PAIR ; + PAIR } ; + DIP { DROP } ; + RENAME @__pt_parameter ; + { DIP { DUP } ; SWAP } ; + CONTRACT (list (pair (pair nat nat) (pair nat (pair nat (pair nat nat))))); + IF_SOME {} {PUSH string "Bad contract in storage"; FAILWITH}; + AMOUNT ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CDR @parameter ; + TRANSFER_TOKENS @op ; + SWAP ; + NIL operation ; + { DIP { DIP { DUP } ; SWAP } ; SWAP } ; + { DIP { DIP { DIP { DROP } } } } ; + CONS ; + PAIR } ; + SWAP ; + CAR ; + SWAP ; + { { DUP ; CAR ; DIP { CDR } } } ; + DIP { SWAP ; PAIR } ; + PAIR } } } diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/test_patched_contracts.ml b/src/proto_alpha/lib_protocol/test/integration/michelson/test_patched_contracts.ml new file mode 100644 index 000000000000..c866b36cc5b0 --- /dev/null +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/test_patched_contracts.ml @@ -0,0 +1,164 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2021 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +(** Testing + ------- + Component: Protocol Migration (patched scripts) + Invocation: cd src/proto_alpha/lib_protocol/test/integration/michelson + dune exec ./main.exe -- test "^patched contracts$" + Subject: Migration +*) + +open Tezos_micheline +open Protocol +open Legacy_script_patches_for_J + +let script_hash_testable = + Alcotest.testable Script_expr_hash.pp Script_expr_hash.equal + +let patched_contracts = + [ + exprtgpMFzTtyg1STJqANLQsjsMXmkf8UuJTuczQh8GPtqfw18x6Lc; + exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw; + expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ; + expruwujdJkc5y4iPzr83Sd3KrJhzxSUb67JdCZmXNKiTTNvEkMrRU; + expruZKjVy3JbWcJmjtnvMGvRamkDhMgM3urGGdne3pkN9VKgK7VnD; + exprv98vtze1uwbDXdpb27R8RQabWZMZDXGNAwaAZwCg6WSvXu8fw3; + expru1ukk6ZqdA32rFYFG7j1eGjfsatbdUZWz8Mi1kXWZYRZm4FZVe; + exprubv5oQmAUP8BwktmDgMWqTizYDJVhzHhJESGZhJ2GkHESZ1VWg; + ] + +let readable_micheline m = + let open Micheline in + map_node (fun _ -> ()) Michelson_v1_primitives.string_of_prim (root m) + +let contract_path ?(ext = "patched.tz") hash = + Filename.concat "patched_contracts" + @@ Format.asprintf "%a.%s" Script_expr_hash.pp hash ext + +let read_file ?ext hash = + let filename = contract_path ?ext hash in + Lwt_io.(with_file ~mode:Input filename read) + +(* Test that the hashes of the scripts in ./patched_contract/.original.tz + match hashes of the contracts being updated by the migration. *) +let test_original_contract {legacy_script_hash; _} () = + let open Lwt_result_syntax in + let*! code = read_file ~ext:"original.tz" legacy_script_hash in + let michelson = Michelson_v1_parser.parse_toplevel ~check:true code in + let*? prog = Micheline_parser.no_parsing_error michelson in + let bytes = + Data_encoding.Binary.to_bytes_exn + Alpha_context.Script.expr_encoding + prog.expanded + in + Alcotest.check + script_hash_testable + "Expr hash doesn't match" + legacy_script_hash + (Script_expr_hash.hash_bytes [bytes]) ; + return () + +(* Test that the binary-encoded versions of the patched contracts used during the + migration correspond to the content of the `./patched_contracts/.tz` + files *) +let test_patched_contract {legacy_script_hash; patched_code} () = + let open Lwt_result_syntax in + let*! expected_michelson = read_file legacy_script_hash in + let*? program = + Micheline_parser.no_parsing_error + @@ Michelson_v1_parser.parse_toplevel ~check:true expected_michelson + in + match + Micheline_diff.diff + ~prev:(readable_micheline patched_code) + ~current:(readable_micheline program.expanded) + () + with + | Some diff -> + let msg = + Format.asprintf + "Patched code for %a different than expected!\n%a" + Script_expr_hash.pp + legacy_script_hash + Micheline_printer.print_expr + diff + in + Alcotest.fail msg + | None -> return () + +(* Test that the diff files `./patched_contracts/.diff` + are the results of the `diff` command on the corresponding + original and patched files *) +let verify_diff {legacy_script_hash; _} () = + let open Lwt_result_syntax in + let*! expected_diff = read_file ~ext:"diff" legacy_script_hash in + let original_code = contract_path ~ext:"original.tz" legacy_script_hash in + (* The other test asserts that this is indeed the patched code. *) + let current_code = contract_path ~ext:"patched.tz" legacy_script_hash in + let diff_cmd = + ( "", + [| + "diff"; + "-u"; + "--label"; + original_code; + "--label"; + current_code; + original_code; + current_code; + |] ) + in + let*! actual_diff = Lwt_process.pread diff_cmd in + Alcotest.(check string) "same diff" expected_diff actual_diff ; + return () + +let tests = + List.concat_map + (fun patch -> + [ + Tztest.tztest + (Format.asprintf + "check original contract hash %a" + Script_expr_hash.pp + patch.legacy_script_hash) + `Quick + (test_original_contract patch); + Tztest.tztest + (Format.asprintf + "check patched contract %a" + Script_expr_hash.pp + patch.legacy_script_hash) + `Quick + (test_patched_contract patch); + Tztest.tztest + (Format.asprintf + "verify patch for %a" + Script_expr_hash.pp + patch.legacy_script_hash) + `Quick + (verify_diff patch); + ]) + patched_contracts -- GitLab From 6013b3c54b0ab6a2aea425bd4be3da0fc2aaa3ab Mon Sep 17 00:00:00 2001 From: Sventimir Date: Mon, 31 Jan 2022 14:17:53 +0100 Subject: [PATCH 5/9] Docs: Document the migration in changelog. --- docs/protocols/alpha.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/protocols/alpha.rst b/docs/protocols/alpha.rst index a38bee9e35cc..e79e0626a8e4 100644 --- a/docs/protocols/alpha.rst +++ b/docs/protocols/alpha.rst @@ -227,6 +227,16 @@ Michelson ``sapling_transaction_deprecated``. Existing onchain contracts are automatically converted. +- The protocol migration to Alpha will ensure that 8 smart contracts + on mainnet that depend on features deprecated in Babylon, type check + under the new protocol without the ``--legacy`` flag. This will be + ensured by patching the contracts. Their behaviour will remain + unchanged which was tested by replaying historic transactions to + these smart contracts with the updated code. For more information on + which contracts are patched and how the change can be tested read + the description of the MR that brought the migration. (MR + :gl:`!3730`) + Internal -------- -- GitLab From 9bbe30b7dcd5ed171ea5be48593233b3ba73abb6 Mon Sep 17 00:00:00 2001 From: Sventimir Date: Thu, 24 Feb 2022 13:39:10 +0100 Subject: [PATCH 6/9] Tezt: Add more high-level logging to the vesting contract test. --- tezt/vesting_contract_test/vesting_test.ml | 37 +++++++++++++++++----- 1 file changed, 29 insertions(+), 8 deletions(-) diff --git a/tezt/vesting_contract_test/vesting_test.ml b/tezt/vesting_contract_test/vesting_test.ml index 4d0d234ec55e..7bf8e726bdfe 100644 --- a/tezt/vesting_contract_test/vesting_test.ml +++ b/tezt/vesting_contract_test/vesting_test.ml @@ -284,6 +284,7 @@ let gen_keys count client = let vest ?(expect_failure = false) ?(amount = Tez.zero) vesting_contract = let open StateMonad in + Log.debug "Vesting %f ꜩ on %s" (Tez.to_float amount) vesting_contract ; let* () = transfer ~source:"bootstrap1" @@ -315,6 +316,11 @@ let sign_transfer ?(expect_failure = false) ~contract ~replay ~receiver ~signers (left @@ left @@ pair (str receiver) (tez amount)) (sigs_michelson signatures) in + Log.debug + "Signing transfer of %f ꜩ from %s to %s." + (Tez.to_float amount) + contract + receiver ; let* () = transfer ~expect_failure @@ -331,13 +337,22 @@ let sign_transfer ?(expect_failure = false) ~contract ~replay ~receiver ~signers let set_pour ~replay ~signers info contract = let open StateMonad in let* keys = getf StateRecord.get_keys in - let pour_info (recipient, authorizer) = - let open Contract_storage in - let recp_pk_hash = (Array.get keys recipient).public_key_hash in - let auth = Array.get keys authorizer in - {pour_dest = recp_pk_hash; pour_authorizer = auth.public_key} + let new_pour_info = + match info with + | Some (recipient, authorizer) -> + let open Contract_storage in + let recp_pk_hash = (Array.get keys recipient).public_key_hash in + let auth = Array.get keys authorizer in + Log.debug + "Setting pour from %s to %s (%s)." + contract + auth.alias + auth.public_key_hash ; + Some {pour_dest = recp_pk_hash; pour_authorizer = auth.public_key} + | None -> + Log.debug "Clearing pour on %s." contract ; + None in - let new_pour_info = Option.map pour_info info in let pour_info_micheline = Contract_storage.pour_info_micheline new_pour_info in @@ -370,11 +385,11 @@ let execute_pour ?(expect_failure = false) ~authorizer ~recipient ~amount ~replay contract = let open StateMonad in let* keys = getf StateRecord.get_keys in - let recp_pk_hash = (Array.get keys recipient).public_key_hash in + let recp = Array.get keys recipient in let to_sign = let open Test_michelson in pair - (pair (str recp_pk_hash) (tez amount)) + (pair (str recp.public_key_hash) (tez amount)) (pair (str contract) (num replay)) in let typ = @@ -386,6 +401,12 @@ let execute_pour ?(expect_failure = false) ~authorizer ~recipient ~amount let open Test_michelson in right @@ some @@ pair (str signature) (tez amount) in + Log.debug + "Executing pour of %f ꜩ from %s to %s (%s)." + (Tez.to_float amount) + contract + recp.alias + recp.public_key_hash ; let* () = transfer ~source:"bootstrap1" -- GitLab From 5c3779eddeae0a6513e669190ed6bcdaaf3aab11 Mon Sep 17 00:00:00 2001 From: Sventimir Date: Thu, 24 Feb 2022 15:59:54 +0100 Subject: [PATCH 7/9] Tezt: Add automatic balance tracking for the vesting test contract. --- tezt/lib_tezos/client.ml | 5 +- tezt/lib_tezos/client.mli | 3 + tezt/vesting_contract_test/vesting_test.ml | 330 ++++++++++++--------- 3 files changed, 189 insertions(+), 149 deletions(-) diff --git a/tezt/lib_tezos/client.ml b/tezt/lib_tezos/client.ml index 2c219a54614c..10e66cfa0ee1 100644 --- a/tezt/lib_tezos/client.ml +++ b/tezt/lib_tezos/client.ml @@ -1573,11 +1573,12 @@ let init_with_protocol ?path ?admin_path ?name ?color ?base_dir ?event_level let* _ = Node.wait_for_level node 1 in return (node, client) -let register_key owner client = +let spawn_register_key owner client = spawn_command client ["--wait"; "none"; "register"; "key"; owner; "as"; "delegate"] - |> Process.check + +let register_key owner client = spawn_register_key owner client |> Process.check let contract_storage ?unparsing_mode address client = let unparsing_mode_to_string = function diff --git a/tezt/lib_tezos/client.mli b/tezt/lib_tezos/client.mli index e56160f75ec1..a90276173d2d 100644 --- a/tezt/lib_tezos/client.mli +++ b/tezt/lib_tezos/client.mli @@ -1134,6 +1134,9 @@ val spawn_command : string list -> Process.t +(** Register public key for given account with given client. *) +val spawn_register_key : string -> t -> Process.t + (** Register public key for given account with given client. *) val register_key : string -> t -> unit Lwt.t diff --git a/tezt/vesting_contract_test/vesting_test.ml b/tezt/vesting_contract_test/vesting_test.ml index 7bf8e726bdfe..9a5fdf631a16 100644 --- a/tezt/vesting_contract_test/vesting_test.ml +++ b/tezt/vesting_contract_test/vesting_test.ml @@ -24,12 +24,20 @@ (*****************************************************************************) module StateRecord = struct + module AddrMap = Map.Make (String) + + type balance = {alias : string option; amount : Tez.t} + + let with_balance ~amount f balance = + {balance with amount = f balance.amount amount} + type t = { node : Node.t; client : Client.t; keys : Account.key Array.t; vesting_contract : string; storage : Contract_storage.t; + balances : balance AddrMap.t; } let get_client {client; _} = client @@ -37,6 +45,31 @@ module StateRecord = struct let get_keys {keys; _} = keys let key i {keys; _} = Array.get keys i + + let balance_of address {balances; _} = AddrMap.find address balances + + let track_balance addr amount state = + {state with balances = AddrMap.add addr amount state.balances} + + let increase_balance addr ~amount state = + { + state with + balances = + AddrMap.update + addr + (Option.map (with_balance ~amount Tez.( + ))) + state.balances; + } + + let decrease_balance addr ~amount state = + { + state with + balances = + AddrMap.update + addr + (Option.map (with_balance ~amount Tez.( - ))) + state.balances; + } end module StateMonad = struct @@ -46,6 +79,20 @@ module StateMonad = struct let client = getf StateRecord.get_client + let track_balance_of ?alias ?amount addr = + update + (StateRecord.track_balance + addr + StateRecord.{alias; amount = Option.value ~default:Tez.zero amount}) + + let get_balance_of addr = getf (StateRecord.balance_of addr) + + let increase_balance_of addr ~amount = + update (StateRecord.increase_balance addr ~amount) + + let decrease_balance_of addr ~amount = + update (StateRecord.decrease_balance addr ~amount) + let rec update_storage = function | [] -> return () | f :: fs -> @@ -68,6 +115,36 @@ module StateMonad = struct let+ k = getf (StateRecord.key i) in k.public_key + let assert_balance account = + let* c = client in + let* {alias; amount = expected} = get_balance_of account in + let* actual = lift @@ Client.get_balance_for ~account c in + let pp_account fmt = function + | None -> Format.(pp_print_string fmt account) + | Some al -> Format.fprintf fmt "%s (%s)" al account + in + if actual = expected then ( + Log.debug + "Balance of %s is ꜩ %s as expected." + account + (Tez.to_string expected) ; + return ()) + else + Test.fail + "Balance for %a is ꜩ %s instead of expected ꜩ %s." + pp_account + alias + (Tez.to_string actual) + (Tez.to_string expected) + + let assert_increased_balance account ~amount = + let* () = increase_balance_of account ~amount in + assert_balance account + + let assert_decreased_balance account ~amount = + let* () = decrease_balance_of account ~amount in + assert_balance account + let initialise_vesting_state ?overall_treshold ?vesting_increment ?next_payout ?payout_interval ?pour_info key_indices = let* keys = getf StateRecord.get_keys in @@ -152,32 +229,35 @@ module StateMonad = struct client in let* () = bake in + let* () = track_balance_of ~alias hash ~amount in return hash let make_delegate u = + let add_fees total line = + let open String in + let line = trim line in + if length line >= 16 && sub line 0 16 = "Fee to the baker" then + let fee = Tez.parse_floating line in + Tez.(fee + total) + else total + in let* c = client in let* target = alias (`User u) in + let* addr = user_address u in + let amount = Tez.of_int 100 in + let* () = track_balance_of addr ~alias:target in let* () = - transfer - ~source:"bootstrap1" - ~target - ~burn_cap:(Tez.of_int 1) - (Tez.of_int 100) + transfer ~source:"bootstrap1" ~target ~burn_cap:(Tez.of_int 1) amount in + let* () = assert_increased_balance ~amount addr in let* () = bake in - let* () = lift @@ Client.register_key target c in - bake - - let assert_balance account expected = - let* c = client in - let* actual = lift @@ Client.get_balance_for ~account c in - if actual = expected then return () - else - Test.fail - "Balance for %s is ꜩ %s instead of expected ꜩ %s." - account - (Tez.to_string actual) - (Tez.to_string expected) + let reg_process = Client.spawn_register_key target c in + let* () = lift @@ Process.check reg_process in + let* output = lift @@ Lwt_io.read (Process.stdout reg_process) in + let output_lines = String.split_on_char '\n' output in + let fee = List.fold_left add_fees Tez.zero output_lines in + let* () = bake in + assert_decreased_balance ~amount:fee addr (* Assert that the actual storage is identical to the one maintained by the test state. *) @@ -196,7 +276,7 @@ module StateMonad = struct Format.pp_print_string fmt @@ Test_michelson.to_string e) diff | None -> - Log.info + Log.debug "Current storage:\n%a" Micheline_printer.print_expr (Micheline.map_node @@ -284,7 +364,7 @@ let gen_keys count client = let vest ?(expect_failure = false) ?(amount = Tez.zero) vesting_contract = let open StateMonad in - Log.debug "Vesting %f ꜩ on %s" (Tez.to_float amount) vesting_contract ; + Log.debug "Vesting on %s." vesting_contract ; let* () = transfer ~source:"bootstrap1" @@ -294,6 +374,10 @@ let vest ?(expect_failure = false) ?(amount = Tez.zero) vesting_contract = ~expect_failure amount in + let* () = + if expect_failure then assert_balance vesting_contract + else assert_increased_balance ~amount vesting_contract + in assert_updated_storage (if expect_failure then [] else Contract_storage.[increment_vested_balance; next_payout]) @@ -330,6 +414,14 @@ let sign_transfer ?(expect_failure = false) ~contract ~replay ~receiver ~signers ~arg Tez.zero in + let* () = + if expect_failure then + let* () = assert_balance receiver in + assert_balance contract + else + let* () = assert_increased_balance receiver ~amount in + assert_decreased_balance contract ~amount + in assert_updated_storage (if expect_failure then [] else Contract_storage.[pay_out amount]) contract @@ -416,6 +508,12 @@ let execute_pour ?(expect_failure = false) ~authorizer ~recipient ~amount ~expect_failure Tez.zero in + let* () = + if expect_failure then assert_balance contract + else + let* () = assert_increased_balance ~amount recp.public_key_hash in + assert_decreased_balance ~amount contract + in assert_updated_storage (if expect_failure then [] else Contract_storage.[pay_out amount]) contract @@ -437,6 +535,7 @@ let set_delegate ~delegate ~signers ~replay contract = (sigs_michelson signatures) in let* () = transfer ~source:"bootstrap1" ~target:contract ~arg Tez.zero in + let* () = assert_balance contract in assert_updated_storage Contract_storage.[bump_replay_counter] contract let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold @@ -473,6 +572,7 @@ let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold let open Test_michelson in left @@ pair key_groups_micheline (sigs_michelson signatures) in + Log.debug "Setting keys for %s." contract ; let* () = transfer ~expect_failure @@ -482,6 +582,7 @@ let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold ~arg Tez.zero in + let* () = assert_balance contract in assert_updated_storage (if expect_failure then [] else Contract_storage.[update_keys key_groups overall_treshold]) @@ -492,12 +593,9 @@ let transfer_and_pour_happy_path = let* () = activate_alpha in let* () = initialise_vesting_state [([0], 1); ([1], 1); ([2], 1)] in let* contract = originate_vesting "vesting_3_keys_60s" (Tez.of_int 500) in - let* () = assert_balance contract @@ Tez.of_int 500 in let* () = assert_storage contract in - (* Make 5 consecutive vest operations from the vesting contract. After each - of them [vested_balance] should increase by ꜩ100 and [next_payout] by 60s. - Appropriate assertions are performed automatically. *) + Log.info "Make 5 consecutive vest operations." ; let* () = vest contract in let* () = vest contract in let* () = vest contract in @@ -505,7 +603,8 @@ let transfer_and_pour_happy_path = let* () = vest contract in let* receiver = user_address 3 in - let* () = assert_balance receiver Tez.zero in + let* () = track_balance_of ~alias:"receiver" receiver in + let* () = assert_balance receiver in let* () = sign_transfer ~contract @@ -514,11 +613,9 @@ let transfer_and_pour_happy_path = ~replay:0 Tez.(of_int 400) in - let* () = assert_balance receiver @@ Tez.of_int 400 in - let* () = assert_balance contract @@ Tez.of_int 100 in let* () = vest contract in - (* This is expected to fail, as we order transfer of more funds than is available. - ꜩ400 out of ꜩ500 transferred initially to the contract are already spent. *) + Log.info + "Next transfer is expected to fail due to insufficient contract's balance." ; let* () = sign_transfer ~contract @@ -528,7 +625,7 @@ let transfer_and_pour_happy_path = ~expect_failure:true Tez.(of_int 100 + of_mutez_int 1) in - (* Hence transferring exactly ꜩ100 is still possible. *) + Log.info "However, transferring exactly ꜩ100 is still possible. " ; let* () = sign_transfer ~contract @@ -537,13 +634,12 @@ let transfer_and_pour_happy_path = ~replay:1 Tez.(of_int 100) in - let* () = assert_balance receiver @@ Tez.of_int 500 in - let* () = assert_balance contract @@ Tez.of_int 0 in let* () = vest ~amount:(Tez.of_int 200) contract in - let* () = assert_balance contract @@ Tez.of_int 200 in - (* Decide to pour funds from the vesting contract to a previously agreed - account by a single signature. *) + Log.info + "Set a special account transfer to which require only a single signature." ; + let* pour_recipient = user_address 4 in + let* () = track_balance_of ~alias:"pour recipient" pour_recipient in let* () = set_pour_for ~authorizer:5 @@ -552,8 +648,6 @@ let transfer_and_pour_happy_path = ~replay:2 contract in - let* pour_receiver = user_address 4 in - let* () = assert_balance pour_receiver @@ Tez.of_int 0 in let* () = execute_pour ~authorizer:5 @@ -562,9 +656,7 @@ let transfer_and_pour_happy_path = ~amount:Tez.(of_int 100) contract in - let* () = assert_balance contract @@ Tez.of_int 100 in - let* () = assert_balance pour_receiver @@ Tez.of_int 100 in - (* Pour cannot exceed the available balance. *) + Log.info "Pour cannot exceed the available balance." ; let* () = execute_pour ~expect_failure:true @@ -574,7 +666,7 @@ let transfer_and_pour_happy_path = ~amount:Tez.(of_int 100 + of_mutez_int 1) contract in - (* Pour can equal the available balance, though. *) + Log.info "Pour can equal the available balance, though." ; let* () = execute_pour ~authorizer:5 @@ -583,12 +675,11 @@ let transfer_and_pour_happy_path = ~amount:Tez.(of_int 100) contract in - let* () = assert_balance pour_receiver @@ Tez.of_int 200 in - let* () = assert_balance contract @@ Tez.of_int 0 in - (* Transfer of ꜩ0 to a smart contract is always possible. *) + Log.info "Transfer of ꜩ0 to a smart contract is always possible." ; let* empty_contract = originate ~alias:"empty" ~storage:Test_michelson.unit empty_contract in + let* () = track_balance_of ~alias:"empty contract" empty_contract in let* () = sign_transfer ~contract @@ -597,15 +688,17 @@ let transfer_and_pour_happy_path = ~replay:5 Tez.zero in - (* Nothing has changed. *) - let* () = assert_balance receiver @@ Tez.of_int 500 in - assert_balance contract @@ Tez.of_int 0 + Log.info "Nothing has changed." ; + let* () = assert_balance empty_contract in + assert_balance contract let vesting_3_keys_2s = let open StateMonad in let* () = activate_alpha in - (* For 4 first users (ids 0-3) give each ꜩ100 and register - him as a delegate. *) + Log.info + "For 4 first users (ids 0-3) give each ꜩ100 and register him as a \ + delegate." ; + Log.info "This action automatically starts tracking their balances." ; let* () = iter_int make_delegate 4 in let* _empty_contract_hash = @@ -623,8 +716,9 @@ let vesting_3_keys_2s = [([0], 1); ([1], 1); ([2], 1)] in let* contract = originate_vesting "vesting_3_keys_2s" (Tez.of_int 1000) in + Log.info "Vesting operation will fail, because its time has not come yet." ; let* () = vest ~expect_failure:true contract in - (* A block later, vest succeeds. *) + Log.info "A block later vesting succeeds." ; let* () = bake in let* () = vest contract in let* () = vest contract in @@ -661,7 +755,7 @@ let test_delegation = contract in let* () = assert_delegate contract (Some deleg2) in - (* Now remove the delegate. *) + Log.info "Remove the delegate." ; let* () = set_delegate ~delegate:None @@ -670,8 +764,6 @@ let test_delegation = contract in let* () = assert_delegate contract None in - let* () = assert_balance deleg @@ Tez.of_mutez_int 99999393 in - let* () = assert_balance contract @@ Tez.of_int 1000 in let* () = sign_transfer ~contract @@ -680,14 +772,13 @@ let test_delegation = ~signers:[[Some 0]; [None]; [Some 2]] Tez.(of_int 100) in - let* () = assert_balance deleg @@ Tez.of_mutez_int 199999393 in - assert_balance contract @@ Tez.of_int 900 + return () let test_invalid_transfers = let open StateMonad in let* contract = vesting_3_keys_2s in let* receiver = user_address 0 in - (* Transfer fails without enough signatures. *) + Log.info "Transfer with insuficient number of signatures fails." ; let* () = sign_transfer ~expect_failure:true @@ -726,6 +817,7 @@ let test_invalid_transfers = in let* receiver = user_address 5 in + let* () = track_balance_of ~alias:"user5" receiver in let* () = set_pour_for ~replay:0 @@ -734,7 +826,7 @@ let test_invalid_transfers = ~signers:[[Some 0]; [None]; [Some 2]] contract in - (* Transaction exceeds available balance. *) + Log.info "Transaction fails because it exceeds available balance." ; let* () = sign_transfer ~expect_failure:true @@ -744,8 +836,6 @@ let test_invalid_transfers = ~signers:[[Some 0]; [Some 1]; [Some 2]] Tez.(of_int 1000) in - let* () = assert_balance receiver @@ Tez.of_int 0 in - let* () = assert_balance contract @@ Tez.of_int 1000 in let* () = sign_transfer ~contract @@ -754,8 +844,6 @@ let test_invalid_transfers = ~signers:[[Some 0]; [None]; [Some 2]] Tez.(of_int 75) in - let* () = assert_balance receiver @@ Tez.of_int 75 in - let* () = assert_balance contract @@ Tez.of_int 925 in let* () = sign_transfer ~contract @@ -764,8 +852,6 @@ let test_invalid_transfers = ~signers:[[None]; [Some 1]; [Some 2]] Tez.(of_int 25) in - let* () = assert_balance receiver @@ Tez.of_int 100 in - let* () = assert_balance contract @@ Tez.of_int 900 in let* () = vest contract in let* () = @@ -776,10 +862,8 @@ let test_invalid_transfers = ~replay:3 contract in - let* () = assert_balance receiver @@ Tez.of_int 150 in - let* () = assert_balance contract @@ Tez.of_int 850 in - (* Pour fails if amount exceeds available funds. *) + Log.info "Pour fails if amount exceeds available funds." ; let* () = execute_pour ~expect_failure:true @@ -789,9 +873,7 @@ let test_invalid_transfers = ~replay:4 contract in - let* () = assert_balance receiver @@ Tez.of_int 150 in - let* () = assert_balance contract @@ Tez.of_int 850 in - (* Pour fails if replay counter is too large. *) + Log.info "Pour fails if replay counter is too large." ; let* () = execute_pour ~expect_failure:true @@ -801,9 +883,7 @@ let test_invalid_transfers = ~replay:5 contract in - let* () = assert_balance receiver @@ Tez.of_int 150 in - let* () = assert_balance contract @@ Tez.of_int 850 in - (* Pour fails if replay counter is too small. *) + Log.info "Pour fails if replay counter is too small." ; let* () = execute_pour ~expect_failure:true @@ -813,9 +893,7 @@ let test_invalid_transfers = ~replay:3 contract in - let* () = assert_balance receiver @@ Tez.of_int 150 in - let* () = assert_balance contract @@ Tez.of_int 850 in - (* Pour fails if signature is incorrect. *) + Log.info "Pour fails if signature is incorrect." ; let* () = execute_pour ~expect_failure:true @@ -825,14 +903,12 @@ let test_invalid_transfers = ~replay:4 contract in - let* () = assert_balance receiver @@ Tez.of_int 150 in - let* () = assert_balance contract @@ Tez.of_int 850 in let* () = disable_pour ~replay:4 ~signers:[[None]; [Some 1]; [Some 2]] contract in let* () = vest contract in - (* Pour fails when no pour info is set. *) + Log.info "Pour fails when no pour info is set." ; execute_pour ~expect_failure:true ~replay:5 @@ -845,6 +921,7 @@ let test_update_keys : unit StateMonad.t = let open StateMonad in let* contract = vesting_3_keys_2s in let* receiver = user_address 4 in + let* () = track_balance_of receiver ~alias:"receiver" in let* () = sign_transfer ~contract @@ -853,39 +930,40 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 0]; [Some 1]; [None]] Tez.(of_int 100) in - let* () = assert_balance contract @@ Tez.of_int 900 in - let* () = assert_balance receiver @@ Tez.of_int 100 in + Log.info "Overall threshold cannot be 0." ; let* () = set_keys - ~expect_failure:true (* Overall treshold can't be 0. *) + ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] ~overall_treshold:0 ~replay:1 contract in + Log.info "Overall treshold can't be greater than number of keys." ; let* () = set_keys - ~expect_failure: - true (* Overall treshold can't be greater than number of keys. *) + ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] ~overall_treshold:4 ~replay:1 contract in + Log.info "Group threshold can't be 0." ; let* () = set_keys - ~expect_failure:true (* Group threshold can't be 0. *) + ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 0); ([5], 1); ([6], 1)] ~overall_treshold:2 ~replay:1 contract in + Log.info "Group cannot be empty." ; let* () = set_keys - ~expect_failure:true (* Group cannot be empty. *) + ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([], 1)] ~overall_treshold:2 @@ -900,10 +978,8 @@ let test_update_keys : unit StateMonad.t = ~replay:1 contract in - (* unchanged *) - let* () = assert_balance contract @@ Tez.of_int 900 in let* receiver = user_address 1 in - (* Old signatures don't work anymore. *) + Log.info "Old signatures don't work anymore." ; let* () = sign_transfer ~expect_failure:true @@ -913,9 +989,6 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 0]; [Some 1]; [Some 2]] Tez.(of_int 200) in - (* unchanged *) - let* () = assert_balance contract @@ Tez.of_int 900 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in let* () = sign_transfer ~contract @@ -924,8 +997,6 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 3; None]; [Some 5]; [Some 6]] Tez.(of_int 100) in - let* () = assert_balance contract @@ Tez.of_int 800 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 199999393 in let* () = vest contract in let* () = sign_transfer @@ -935,8 +1006,6 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 3; None]; [None]; [Some 6]] Tez.(of_int 100) in - let* () = assert_balance contract @@ Tez.of_int 700 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 299999393 in let* () = vest contract in let* () = sign_transfer @@ -946,8 +1015,6 @@ let test_update_keys : unit StateMonad.t = ~signers:[[None; None]; [Some 5]; [Some 6]] Tez.(of_int 100) in - let* () = assert_balance contract @@ Tez.of_int 600 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 399999393 in let* () = vest contract in let* () = sign_transfer @@ -957,9 +1024,7 @@ let test_update_keys : unit StateMonad.t = ~signers:[[None; Some 4]; [Some 5]; [None]] Tez.(of_int 10) in - let* () = assert_balance contract @@ Tez.of_int 590 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 409999393 in - (* Group treshold must be met. *) + Log.info "Group treshold must be met." ; let* () = sign_transfer ~expect_failure:true @@ -969,8 +1034,6 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 3; Some 4]; [None]; [None]] Tez.(of_int 10) in - let* () = assert_balance contract @@ Tez.of_int 590 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 409999393 in return () let test_all_sigs_required = @@ -994,8 +1057,6 @@ let test_all_sigs_required = ~signers:[[Some 3; Some 4]; [Some 5]; [None]] Tez.(of_int 10) in - let* () = assert_balance contract @@ Tez.of_int 1000 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in let* () = sign_transfer ~expect_failure:true @@ -1005,8 +1066,6 @@ let test_all_sigs_required = ~signers:[[None; None]; [Some 5]; [Some 6]] Tez.(of_int 10) in - let* () = assert_balance contract @@ Tez.of_int 1000 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 99999393 in let* () = sign_transfer ~contract @@ -1015,8 +1074,6 @@ let test_all_sigs_required = ~signers:[[Some 3; Some 4]; [Some 5]; [Some 6]] Tez.(of_int 10) in - let* () = assert_balance contract @@ Tez.of_int 990 in - let* () = assert_balance receiver @@ Tez.of_mutez_int 109999393 in return () let test_full_contract = @@ -1046,7 +1103,7 @@ let test_full_contract = in (* 10% of the total token supply. *) let initial_balance = Tez.of_mutez_int 7633069296900 in - (* Ensure bootstrap1 has enough funds to cover the initial balance. *) + Log.info "Ensure bootstrap1 has enough funds to cover the initial balance." ; let* () = transfer ~source:"bootstrap2" ~target:"bootstrap1" Tez.(of_int 3000000) in @@ -1055,7 +1112,6 @@ let test_full_contract = in let* contract = originate_vesting "full_vesting_contract" initial_balance in let* () = vest contract (* 1 / 12 *) in - let* () = assert_balance contract @@ Tez.of_mutez_int 7633069296900 in let* () = vest contract (* 2 / 12 *) in let* () = make_delegate 0 in @@ -1077,7 +1133,6 @@ let test_full_contract = contract in let* () = assert_delegate contract (Some delegate) in - let* () = assert_balance contract @@ Tez.of_mutez_int 7633069296900 in let* () = set_delegate ~delegate:None @@ -1095,8 +1150,9 @@ let test_full_contract = contract in let* u27 = user_address 27 in + let* () = track_balance_of u27 ~alias:"user27" in let* () = assert_delegate contract None in - let* () = assert_balance u27 @@ Tez.of_int 0 in + let* () = assert_balance u27 in let* () = sign_transfer ~contract @@ -1114,8 +1170,6 @@ let test_full_contract = ] Tez.(of_int 100) in - let* () = assert_balance u27 @@ Tez.of_int 100 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632969296900 in let* () = sign_transfer ~contract @@ -1133,9 +1187,7 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 300 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in - (* Group thresholds must be met. *) + Log.info "Group thresholds must be met." ; let* () = sign_transfer ~expect_failure:true @@ -1154,9 +1206,7 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 300 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in - (* Overall threshold must be met. *) + Log.info "Overall threshold must be met." ; let* () = sign_transfer ~expect_failure:true @@ -1175,9 +1225,7 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 300 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in - (* All signatures must be valid key (#0 signed in the wrong slot). *) + Log.info "All signatures must be valid key (#0 signed in the wrong slot)." ; let* () = sign_transfer ~expect_failure:true @@ -1196,10 +1244,8 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 300 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in - (* Change keys: *) + Log.info "Change keys." ; let* () = set_keys ~signers: @@ -1226,7 +1272,7 @@ let test_full_contract = ~replay:4 contract in - (* Old keys no longer work. *) + Log.info "Old keys no longer work." ; let* () = sign_transfer ~expect_failure:true @@ -1245,9 +1291,7 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 300 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632769296900 in - (* New keys do work. *) + Log.info "New keys do work." ; let* () = sign_transfer ~contract @@ -1265,10 +1309,8 @@ let test_full_contract = ] Tez.(of_int 200) in - let* () = assert_balance u27 @@ Tez.of_int 500 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632569296900 in - (* Pour must be set up first. *) + Log.info "Pour must be set up first." ; let* () = execute_pour ~expect_failure:true @@ -1278,8 +1320,6 @@ let test_full_contract = ~replay:6 contract in - let* () = assert_balance u27 @@ Tez.of_int 500 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632569296900 in let* () = set_pour_for ~replay:6 @@ -1297,17 +1337,12 @@ let test_full_contract = ~recipient:27 contract in - let* () = - execute_pour - ~authorizer:0 - ~recipient:27 - ~amount:Tez.(of_int 500) - ~replay:7 - contract - in - let* () = assert_balance u27 @@ Tez.of_int 1000 in - let* () = assert_balance contract @@ Tez.of_mutez_int 7632069296900 in - return () + execute_pour + ~authorizer:0 + ~recipient:27 + ~amount:Tez.(of_int 500) + ~replay:7 + contract let execute ~user_count ~contract test () = let* node = Node.init [Connections 0; Synchronisation_threshold 0] in @@ -1315,6 +1350,7 @@ let execute ~user_count ~contract test () = let* keys = gen_keys user_count client in let vesting_contract = path_to contract in let storage = Contract_storage.initial [] in + let balances = StateRecord.AddrMap.empty in StateMonad.eval - StateRecord.{node; client; keys; vesting_contract; storage} + StateRecord.{node; client; keys; vesting_contract; storage; balances} test -- GitLab From 520f30bb9de2e86baad2268e93870dae427874f9 Mon Sep 17 00:00:00 2001 From: Sventimir Date: Fri, 4 Mar 2022 13:34:10 +0100 Subject: [PATCH 8/9] Tezt: Add more test cases to the vesting contract test. --- tezt/vesting_contract_test/vesting_test.ml | 62 +++++++++++++++++++++- 1 file changed, 60 insertions(+), 2 deletions(-) diff --git a/tezt/vesting_contract_test/vesting_test.ml b/tezt/vesting_contract_test/vesting_test.ml index 9a5fdf631a16..07833904dc01 100644 --- a/tezt/vesting_contract_test/vesting_test.ml +++ b/tezt/vesting_contract_test/vesting_test.ml @@ -578,7 +578,7 @@ let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold ~expect_failure ~source:"bootstrap1" ~target:contract - ~burn_cap:Tez.(of_mutez_int 10000) + ~burn_cap:Tez.(of_mutez_int 20000) ~arg Tez.zero in @@ -940,7 +940,17 @@ let test_update_keys : unit StateMonad.t = ~replay:1 contract in - Log.info "Overall treshold can't be greater than number of keys." ; + Log.info "Overall threshold cannot be 0, even if there's no groups." ; + let* () = + set_keys + ~expect_failure:true + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[] + ~overall_treshold:0 + ~replay:1 + contract + in + Log.info "Overall treshold can't be greater than the number of keys." ; let* () = set_keys ~expect_failure:true @@ -950,6 +960,16 @@ let test_update_keys : unit StateMonad.t = ~replay:1 contract in + Log.info "There must be at least one group" ; + let* () = + set_keys + ~expect_failure:true + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[] + ~overall_treshold:2 + ~replay:1 + contract + in Log.info "Group threshold can't be 0." ; let* () = set_keys @@ -970,6 +990,17 @@ let test_update_keys : unit StateMonad.t = ~replay:1 contract in + Log.info "Group cannot be empty even if its threshold is 0." ; + let* () = + set_keys + ~expect_failure:true + ~signers:[[Some 0]; [Some 1]; [None]] + ~key_groups:[([3; 4], 1); ([5], 1); ([], 0)] + ~overall_treshold:2 + ~replay:1 + contract + in + Log.info "An example of valid keys settings." ; let* () = set_keys ~signers:[[Some 0]; [Some 1]; [None]] @@ -1034,6 +1065,33 @@ let test_update_keys : unit StateMonad.t = ~signers:[[Some 3; Some 4]; [None]; [None]] Tez.(of_int 10) in + Log.info "Keys can be repeated on many positions." ; + let* () = + set_keys + ~signers:[[Some 3; Some 4]; [Some 5]; [Some 6]] + ~key_groups:[([3; 4], 1); ([3; 5], 1); ([3; 6], 1)] + ~overall_treshold:2 + ~replay:6 + contract + in + Log.info "Transfer is possible without using duplicated keys" ; + let* () = + sign_transfer + ~contract + ~replay:7 + ~receiver + ~signers:[[None; Some 4]; [None; Some 5]; [None; Some 6]] + Tez.(of_int 10) + in + Log.info "The user #3 can sign everything himself." ; + let* () = + sign_transfer + ~contract + ~replay:8 + ~receiver + ~signers:[[Some 3; None]; [Some 3; None]; [Some 3; None]] + Tez.(of_int 10) + in return () let test_all_sigs_required = -- GitLab From 73f954a513f2429f0b7ef05264e9c71bed1ddcc9 Mon Sep 17 00:00:00 2001 From: Sventimir Date: Fri, 4 Mar 2022 14:42:00 +0100 Subject: [PATCH 9/9] Tezt: Extend the vesting contract test with additional cases. Add a case where the signer signs wrong data with a correct key. --- .../legacy_script_patches_for_J.ml | 2 +- ...XQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff | 12 ++- ...44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz | 6 +- .../vesting_contract_test/contract_storage.ml | 28 +++--- tezt/vesting_contract_test/main.ml | 19 ++-- tezt/vesting_contract_test/vesting_test.ml | 86 ++++++++++++------- 6 files changed, 92 insertions(+), 61 deletions(-) diff --git a/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml b/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml index f3ee4d8ed5a7..a11c2ed6d53d 100644 --- a/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml +++ b/src/proto_alpha/lib_protocol/legacy_script_patches_for_J.ml @@ -55,7 +55,7 @@ let exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw = "exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw"; patched_code = bin_expr_exn - "0200000f87050007640865086407640865065a036c000000052564657374046a00000010257472616e736665725f616d6f756e7400000009255472616e7366657206630765065a036c0000000a25706f75725f64657374045c0000001025706f75725f617574686f72697a657200000009255365745f706f757207640865065f0765065f035c0000000c257369676e61746f726965730462000000102567726f75705f7468726573686f6c640000000b256b65795f67726f757073046200000012256f766572616c6c5f7468726573686f6c6400000009255365745f6b6579730663035d0000000d255365745f64656c65676174650000000d25616374696f6e5f696e707574065f055f056303670000000b257369676e6174757265730000000725416374696f6e0563076504670000000a25706f75725f61757468046a0000000c25706f75725f616d6f756e7405010765076504620000000f257265706c61795f636f756e7465720865065f0765065f035c0000000c257369676e61746f726965730462000000102567726f75705f7468726573686f6c640000000b256b65795f67726f757073046200000012256f766572616c6c5f7468726573686f6c6400000009256b65795f696e666f076508650865046a0000000f257665737465645f62616c616e6365046a000000122576657374696e675f696e6372656d656e74000000132576657374696e675f7175616e7469746965730865046b0000000c256e6578745f7061796f7574045b00000010257061796f75745f696e74657276616c000000112576657374696e675f7363686564756c65000000082576657374696e6705630765046e0000000a25706f75725f64657374045c0000001025706f75725f617574686f72697a657205020200000cf903210316072e020000079d051f020000001903170321063d036d0000000b406f7065726174696f6e73034c034c0316032104170000000c256b65795f696e666f204025051f0200000074041600000012257265706c61795f636f756e746572204025051f0200000016032104170000000e257369676e617475726573204025034c051f0200000036051f020000001804160000001025616374696f6e5f696e7075742040250321034903540342034c0342040c00000007407061636b6564034c051f0200000050032104160000000e256b65795f67726f757073204025051f0200000033041700000015256f766572616c6c5f7468726573686f6c64204025043000000010406f766572616c6c5f636f756e746572034c0552020000016c051f020000004f072d020000003a051f0200000002034c0321041600000003402525051f020000001f04170000000340252504300000000e4067726f75705f636f756e746572034c02000000090200000004034f03270552020000008f051f0200000015072d020000000002000000090200000004034f0327072f020000000203200200000065034c051f0200000033051f020000002c034c051f0200000021051f020000001a0743035b004104120000000e4067726f75705f636f756e7465720321041800000007407369675f6f6b0200000015072c020000000002000000090200000004034f0327034c0200000064051f020000005d051f02000000560743035b0000020000001c03190428000000144067726f75705f7468726573686f6c645f6d6574072c0200000023051f020000001c0743035b0041041200000010406f766572616c6c5f636f756e7465720200000000072d02000000090200000004034f03270200000000034c072d02000000090200000004034f0327020000000003200743035b0000020000001e0319042800000016406f766572616c6c5f7468726573686f6c645f6d65740200000015072c020000000002000000090200000004034f03270200000076051f020000006f051f0200000068032103160321041600000012257265706c61795f636f756e74657220402507430362000104120000000f407265706c61795f636f756e746572051f020000001204170000000c256b65795f696e666f2040250442000000052540202540051f020000000203170342072e020000026c072e02000001f40321051f0200000196041700000013257472616e736665725f616d6f756e7420402503210415000000084062616c616e6365020000001e020000000403190328072c020000000002000000090200000004034f0327034c051f0200000141051f020000004003210317032103160416000000162576657374696e675f7175616e7469746965732040250321041600000012257665737465645f62616c616e636520402503210321051f0200000023020000001e020000000403190332072c020000000002000000090200000004034f0327034c0393072f0200000004034f0327020000001504580000000f407665737465645f62616c616e6365051f020000001b0417000000152576657374696e675f696e6372656d656e742040250442000000194076657374696e675f7175616e746974696573202540202540051f0200000038032103160417000000142576657374696e675f7363686564756c65204025051f020000001304170000000d25706f75725f696e666f20402504420000000e4076657374696e672025402025400442000000052540202540034c031603420321041700000013257472616e736665725f616d6f756e74204025051f020000000e0416000000082564657374204025034f044d0000000c407472616e736665725f6f70041b0000000b406f7065726174696f6e73020000006c034c051f0200000063072f0200000008053e0765036e035c0200000008037a035403420346034c03210316051f020000002c031704160000000b2576657374696e672040250442000000132576657374696e672025706f75725f696e666f0442000000084073746f7261676502000001cf072e02000001ab0321032104160000000e256b65795f67726f757073204025051f0200000064041700000021256f766572616c6c5f7468726573686f6c6420406e65775f7468726573686f6c640321074303620000020000001e020000000403190337072c020000000002000000090200000004034f03270843036200000000000840636f756e746572055202000000aa0321041600000010257369676e61746f7269657320402525051f02000000450417000000142567726f75705f7468726573686f6c64204025250321074303620000020000001e020000000403190337072c020000000002000000090200000004034f0327044500000009406e756d5f6b657973020000001e020000000403190328072c020000000002000000090200000004034f032707430362000104120000000840636f756e746572020000001e020000000403190328072c020000000002000000090200000004034f0327034c051f020000004b051f02000000190321031604160000000f257265706c61795f636f756e746572034c04420000000c254020256b65795f696e666f051f020000000203170442000000084073746f726167650200000018044e00000010407365745f64656c65676174655f6f70031b0342020000054c072f02000001c80317032103170321051f020000001304170000000d25706f75725f696e666f20402504160000000b2576657374696e6720402503210417000000142576657374696e675f7363686564756c65204025032104160000000f256e6578745f7061796f75742040250321034002000000040319032a0200000015072c020000000002000000090200000004034f0327051f020000001b041700000013257061796f75745f696e74657276616c2040250321041200000010406e65775f6e6578745f7061796f7574044200000025256e6578745f7061796f757420254020406e65775f76657374696e675f7363686564756c65034c0416000000162576657374696e675f7175616e7469746965732040250321041600000012257665737465645f62616c616e6365204025051f020000001d0417000000152576657374696e675f696e6372656d656e74204025032104120000000c406e65775f62616c616e6365044200000012257665737465645f62616c616e63652025400442000000252576657374696e675f7175616e746974696573202576657374696e675f7363686564756c6504420000000b2576657374696e67202540034c03160442000000084073746f72616765053d036d0200000376051f0200000053031703210317032104160000000b2576657374696e6720402503210416000000162576657374696e675f7175616e7469746965732040250321041600000012257665737465645f62616c616e636520402503210321051f02000001e104170000001025706f75725f616d6f756e74204025250321051f0200000023020000001e020000000403190332072c020000000002000000090200000004034f032703210415000000084062616c616e6365020000001e020000000403190328072c020000000002000000090200000004034f0327034c049300000010406e65775f6375725f62616c616e6365072f0200000004034f03270200000000051f020000001b0417000000152576657374696e675f696e6372656d656e74204025044200000026257665737465645f62616c616e6365202540204076657374696e675f7175616e746974696573051f020000001a0417000000142576657374696e675f7363686564756c6520402504420000000e2540202540204076657374696e67051f020000002a04170000000d25706f75725f696e666f2040250321072f02000000090200000004034f03270200000000034c051f02000000870442000000052540202540034c03160321041600000012257265706c61795f636f756e746572204025032107430362000104120000000f407265706c61795f636f756e746572034c034903540342051f0200000032051f020000001204170000000c256b65795f696e666f20402504420000000525402025400442000000084073746f726167650321051f0200000102034c032104160000000d25706f75725f646573742040250555036c020000002f072f0200000023074303680100000018426164207472616e73616374696f6e20726563656976657203270200000000051f02000000ac032104170000001325706f75725f617574686f72697a6572204025051f020000005904160000000d25706f75725f64657374204025034c032104160000000d25706f75725f61757468204025051f020000002804170000000f25706f75725f616d6f756e74204025034c03420342040c00000007407061636b656404180000000d40706f75725f617574685f6f6b0200000015072c020000000002000000090200000004034f0327053d036d04170000000f25706f75725f616d6f756e74204025034f044d0000000840706f75725f6f70031b0342"; + "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"; } let expruqNpURkmjQk5RGHjLrnS1U3DZnEsQCvQQNLSpN1powRmJeQgoJ = diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff index 18f074777ba1..005d5b674ef2 100644 --- a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.diff @@ -31,19 +31,17 @@ DIP { CDR %vesting_increment @% } ; PAIR @vesting_quantities %@ %@ ; DIP { DUP ; CAR ; CDR %vesting_schedule @% ; DIP { CDR %pour_info @% } } ; -@@ -109,7 +110,10 @@ +@@ -109,7 +110,8 @@ TRANSFER_TOKENS @transfer_op ; CONS @operations } { SWAP ; - DIP { SWAP ; -+ DIP { IF_NONE -+ { NONE (pair address key) } -+ { UNPAIR ; ADDRESS ; PAIR; SOME } ; ++ DIP { MAP { UNPAIR ; ADDRESS ; PAIR } ; + SWAP ; DUP ; CAR ; DIP { CDR ; CAR %vesting @% ; PAIR %vesting %pour_info } ; -@@ -191,7 +195,8 @@ +@@ -191,7 +193,8 @@ BALANCE @balance ; { { COMPARE ; GE } ; IF {} { { UNIT ; FAILWITH } } } ; SWAP ; @@ -53,12 +51,12 @@ DIP { CDR %vesting_increment @% } ; PAIR %vested_balance %@ @vesting_quantities ; DIP { CDR %vesting_schedule @% } ; -@@ -215,6 +220,8 @@ +@@ -215,6 +218,8 @@ DIP { SWAP ; DUP ; CAR %pour_dest @% ; + CONTRACT unit ; -+ { IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} } ; ++ IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} ; DIP { DUP ; CDR %pour_authorizer @% ; DIP { CAR %pour_dest @% ; diff --git a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz index 6c1d3712648c..dc49ffc70a94 100644 --- a/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz +++ b/src/proto_alpha/lib_protocol/test/integration/michelson/patched_contracts/exprucjN3PgUnqQHFXQmemT44DjkacU35NrSSKyz18JSSjJB9vtUEw.patched.tz @@ -110,9 +110,7 @@ TRANSFER_TOKENS @transfer_op ; CONS @operations } { SWAP ; - DIP { IF_NONE - { NONE (pair address key) } - { UNPAIR ; ADDRESS ; PAIR; SOME } ; + DIP { MAP { UNPAIR ; ADDRESS ; PAIR } ; SWAP ; DUP ; CAR ; @@ -221,7 +219,7 @@ DUP ; CAR %pour_dest @% ; CONTRACT unit ; - { IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} } ; + IF_NONE { PUSH string "Bad transaction receiver" ; FAILWITH } {} ; DIP { DUP ; CDR %pour_authorizer @% ; DIP { CAR %pour_dest @% ; diff --git a/tezt/vesting_contract_test/contract_storage.ml b/tezt/vesting_contract_test/contract_storage.ml index 9b9589376e7f..06d0edf71917 100644 --- a/tezt/vesting_contract_test/contract_storage.ml +++ b/tezt/vesting_contract_test/contract_storage.ml @@ -23,9 +23,9 @@ (* *) (*****************************************************************************) -type key_group = {signatories : string list; group_treshold : int} +type key_group = {signatories : string list; group_threshold : int} -type key_info = {key_groups : key_group list; overall_treshold : int} +type key_info = {key_groups : key_group list; overall_threshold : int} type pour_info = {pour_dest : string; pour_authorizer : string} @@ -39,19 +39,19 @@ type t = { pour_info : pour_info option; } -let initial ?overall_treshold ?(vesting_increment = Tez.of_int 100) +let initial ?overall_threshold ?(vesting_increment = Tez.of_int 100) ?(next_payout = Ptime.epoch) ?(payout_interval = Ptime.Span.of_int_s 60) ?pour_info keys = - let overall_treshold = - Option.value ~default:(List.length keys - 1) overall_treshold + let overall_threshold = + Option.value ~default:(List.length keys - 1) overall_threshold in { replay_counter = 0; key_info = { key_groups = - List.map (fun (ks, t) -> {signatories = ks; group_treshold = t}) keys; - overall_treshold; + List.map (fun (ks, t) -> {signatories = ks; group_threshold = t}) keys; + overall_threshold; }; vested_balance = Tez.zero; vesting_increment; @@ -60,10 +60,10 @@ let initial ?overall_treshold ?(vesting_increment = Tez.of_int 100) pour_info; } -let update_keys key_groups overall_treshold s = +let update_keys key_groups overall_threshold s = { s with - key_info = {key_groups; overall_treshold}; + key_info = {key_groups; overall_threshold}; replay_counter = s.replay_counter + 1; } @@ -101,13 +101,13 @@ let key_groups_micheline key_groups = let open Test_michelson in list @@ List.map - (fun {signatories; group_treshold} -> - pair (list @@ List.map str signatories) (num group_treshold)) + (fun {signatories; group_threshold} -> + pair (list @@ List.map str signatories) (num group_threshold)) key_groups -let key_info_micheline {key_groups; overall_treshold} = +let key_info_micheline {key_groups; overall_threshold} = let open Test_michelson in - pair (key_groups_micheline key_groups) (num overall_treshold) + pair (key_groups_micheline key_groups) (num overall_threshold) let to_micheline storage = let open Test_michelson in @@ -117,7 +117,7 @@ let to_micheline storage = [ num storage.replay_counter; key_groups_micheline storage.key_info.key_groups; - num storage.key_info.overall_treshold; + num storage.key_info.overall_threshold; ]; tuple [ diff --git a/tezt/vesting_contract_test/main.ml b/tezt/vesting_contract_test/main.ml index 8e0a1fde768e..9d16475c545c 100644 --- a/tezt/vesting_contract_test/main.ml +++ b/tezt/vesting_contract_test/main.ml @@ -27,12 +27,19 @@ ------- Component: Vesting contract Invocation: dune exec tezt/vesting_contract_test/main.exe - Subject: This file runs a test suite for the vesting contract. It supports - the original version of the contract, executed under Athens - protocol which is the last protocol, where this version can be - originated. It also can execute against the patched version under - protocol Alpha. -*) + Subject: This file runs a test suite for the vesting contract. It + contains the current version of the contract in contract.tz + file and executes a few testing scenarios against it. These + tests are conceptually based on much older test suite + originally written in Bash: + https://gitlab.com/smondet/tezos/-/tree/vesting-contracts/contracts/vesting + + NOTE: due to these tests' long execution time combined with the + fact that the contract doesn't change except when a protocol + migration patches legacy contracts, there's little point in + having these tests run in CI. Instead, it should be run + manually whenever a change is suspected to break it. + *) let tests = let open Vesting_test in diff --git a/tezt/vesting_contract_test/vesting_test.ml b/tezt/vesting_contract_test/vesting_test.ml index 07833904dc01..6ff54b52eb8e 100644 --- a/tezt/vesting_contract_test/vesting_test.ml +++ b/tezt/vesting_contract_test/vesting_test.ml @@ -145,21 +145,21 @@ module StateMonad = struct let* () = decrease_balance_of account ~amount in assert_balance account - let initialise_vesting_state ?overall_treshold ?vesting_increment ?next_payout - ?payout_interval ?pour_info key_indices = + let initialise_vesting_state ?overall_threshold ?vesting_increment + ?next_payout ?payout_interval ?pour_info key_indices = let* keys = getf StateRecord.get_keys in let storage = Contract_storage.initial - ?overall_treshold + ?overall_threshold ?vesting_increment ?next_payout ?payout_interval ?pour_info @@ List.map Account.( - fun (idx, treshold) -> + fun (idx, threshold) -> let ks = List.map (fun i -> (Array.get keys i).public_key) idx in - (ks, treshold)) + (ks, threshold)) key_indices in update (fun s -> StateRecord.{s with storage}) @@ -383,14 +383,17 @@ let vest ?(expect_failure = false) ?(amount = Tez.zero) vesting_contract = else Contract_storage.[increment_vested_balance; next_payout]) vesting_contract -let sign_transfer ?(expect_failure = false) ~contract ~replay ~receiver ~signers - amount = +let sign_transfer ?(expect_failure = false) ?data ~contract ~replay ~receiver + ~signers amount = let open StateMonad in let data = let open Test_michelson in - pair - (left @@ left @@ pair (str receiver) (tez amount)) - (pair (str contract) (num replay)) + Option.value + data + ~default: + (pair + (left @@ left @@ pair (str receiver) (tez amount)) + (pair (str contract) (num replay))) in let* signatures = signatures ~typ:vesting_arg_type ~data signers in let arg = @@ -538,7 +541,7 @@ let set_delegate ~delegate ~signers ~replay contract = let* () = assert_balance contract in assert_updated_storage Contract_storage.[bump_replay_counter] contract -let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold +let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_threshold ~replay contract = let open StateMonad in let* keys = getf StateRecord.get_keys in @@ -548,14 +551,14 @@ let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold Contract_storage. { signatories = List.map (fun i -> (Array.get keys i).public_key) ks; - group_treshold = t; + group_threshold = t; }) key_groups in let key_groups_micheline = let open Test_michelson in right @@ left - @@ Contract_storage.key_info_micheline {key_groups; overall_treshold} + @@ Contract_storage.key_info_micheline {key_groups; overall_threshold} in let typ = let open Test_michelson.Types in @@ -585,7 +588,7 @@ let set_keys ?(expect_failure = false) ~signers ~key_groups ~overall_treshold let* () = assert_balance contract in assert_updated_storage (if expect_failure then [] - else Contract_storage.[update_keys key_groups overall_treshold]) + else Contract_storage.[update_keys key_groups overall_threshold]) contract let transfer_and_pour_happy_path = @@ -778,7 +781,7 @@ let test_invalid_transfers = let open StateMonad in let* contract = vesting_3_keys_2s in let* receiver = user_address 0 in - Log.info "Transfer with insuficient number of signatures fails." ; + Log.info "Transfer with insufficient number of signatures fails." ; let* () = sign_transfer ~expect_failure:true @@ -936,7 +939,7 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] - ~overall_treshold:0 + ~overall_threshold:0 ~replay:1 contract in @@ -946,17 +949,17 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[] - ~overall_treshold:0 + ~overall_threshold:0 ~replay:1 contract in - Log.info "Overall treshold can't be greater than the number of keys." ; + Log.info "Overall threshold can't be greater than the number of keys." ; let* () = set_keys ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] - ~overall_treshold:4 + ~overall_threshold:4 ~replay:1 contract in @@ -966,7 +969,7 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:1 contract in @@ -976,7 +979,7 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 0); ([5], 1); ([6], 1)] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:1 contract in @@ -986,7 +989,7 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([], 1)] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:1 contract in @@ -996,7 +999,7 @@ let test_update_keys : unit StateMonad.t = ~expect_failure:true ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([], 0)] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:1 contract in @@ -1005,7 +1008,7 @@ let test_update_keys : unit StateMonad.t = set_keys ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 1); ([5], 1); ([6], 1)] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:1 contract in @@ -1055,7 +1058,7 @@ let test_update_keys : unit StateMonad.t = ~signers:[[None; Some 4]; [Some 5]; [None]] Tez.(of_int 10) in - Log.info "Group treshold must be met." ; + Log.info "Group threshold must be met." ; let* () = sign_transfer ~expect_failure:true @@ -1070,7 +1073,7 @@ let test_update_keys : unit StateMonad.t = set_keys ~signers:[[Some 3; Some 4]; [Some 5]; [Some 6]] ~key_groups:[([3; 4], 1); ([3; 5], 1); ([3; 6], 1)] - ~overall_treshold:2 + ~overall_threshold:2 ~replay:6 contract in @@ -1101,7 +1104,7 @@ let test_all_sigs_required = set_keys ~signers:[[Some 0]; [Some 1]; [None]] ~key_groups:[([3; 4], 2); ([5], 1); ([6], 1)] - ~overall_treshold:3 + ~overall_threshold:3 ~replay:0 contract in @@ -1148,7 +1151,7 @@ let test_full_contract = ~payout_interval: Ptime.Span.(of_int_s (60 * 60 * 24 * 365 / 12)) (* Approximately one month. *) - ~overall_treshold:4 + ~overall_threshold:4 [ ([0; 1; 2; 3], 2); ([4; 5; 6; 7], 2); @@ -1302,6 +1305,31 @@ let test_full_contract = ] Tez.(of_int 200) in + Log.info "Data signed by the signers must be correct." ; + let* wrong_address = user_address 26 in + let* () = + sign_transfer + ~expect_failure:true + ~contract + ~replay:4 + ~receiver:u27 + ~data: + Test_michelson.( + pair + (left @@ left @@ pair (str wrong_address) (tez @@ Tez.of_int 200)) + (pair (str contract) (num 4))) + ~signers: + [ + [None; Some 1; Some 2; None]; + [None; Some 5; Some 6; None]; + [None; None; Some 10; Some 11]; + [None; Some 13; None; Some 15]; + [Some 16; None; None; None]; + [None; Some 21; None; None]; + [None; None; Some 26; None]; + ] + Tez.(of_int 200) + in Log.info "Change keys." ; let* () = @@ -1326,7 +1354,7 @@ let test_full_contract = ([5; 12; 19; 26], 1); ([6; 13; 20; 27], 1); ] - ~overall_treshold:4 + ~overall_threshold:4 ~replay:4 contract in -- GitLab