diff --git a/src/bin/expect_tests/contract_tests.ml b/src/bin/expect_tests/contract_tests.ml index af6a644d7..69f2c4a7d 100644 --- a/src/bin/expect_tests/contract_tests.ml +++ b/src/bin/expect_tests/contract_tests.ml @@ -7,16 +7,16 @@ let bad_contract basename = let%expect_test _ = run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ; - [%expect {| 1874 bytes |}] ; + [%expect {| 1700 bytes |}] ; run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ; - [%expect {| 1163 bytes |}] ; + [%expect {| 995 bytes |}] ; run_ligo_good [ "measure-contract" ; contract "multisig-v2.ligo" ; "main" ] ; - [%expect {| 2867 bytes |}] ; + [%expect {| 2512 bytes |}] ; run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ; - [%expect {| 617 bytes |}] ; + [%expect {| 582 bytes |}] ; run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ; [%expect {| (Left (Left 1)) |}] ; @@ -59,720 +59,697 @@ let%expect_test _ = let%expect_test _ = run_ligo_good [ "compile-contract" ; contract "coase.ligo" ; "main" ] ; [%expect {| - { parameter - (or (or (nat %buy_single) (nat %sell_single)) - (pair %transfer_single (nat %card_to_transfer) (address %destination))) ; - storage - (pair (pair (map %card_patterns nat (pair (mutez %coefficient) (nat %quantity))) - (map %cards nat (pair (address %card_owner) (nat %card_pattern)))) - (nat %next_id)) ; - code { DUP ; - CDR ; - DIP { DUP } ; - SWAP ; - CAR ; +{ parameter + (or (or (nat %buy_single) (nat %sell_single)) + (pair %transfer_single (nat %card_to_transfer) (address %destination))) ; + storage + (pair (pair (map %card_patterns nat (pair (mutez %coefficient) (nat %quantity))) + (map %cards nat (pair (address %card_owner) (nat %card_pattern)))) + (nat %next_id)) ; + code { DUP ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + IF_LEFT + { DUP ; IF_LEFT - { DUP ; - IF_LEFT - { DUP ; - DIP { DIP 2 { DUP } ; DIG 2 } ; - PAIR ; - DUP ; - CAR ; - DIP { DUP } ; - SWAP ; - CDR ; - DIP { DUP } ; - SWAP ; - DIP { DUP ; CAR ; CAR } ; - GET ; - IF_NONE - { PUSH string "buy_single: No card pattern." ; FAILWITH } - { DUP ; DIP { DROP } } ; - DUP ; - CAR ; - DIP { DUP ; CDR ; PUSH nat 1 ; ADD } ; - MUL ; - DUP ; - AMOUNT ; - SWAP ; - COMPARE ; - GT ; - IF { PUSH string "Not enough money" ; FAILWITH } { PUSH unit Unit } ; - DIP 2 { DUP } ; - DIG 2 ; - DIP 3 { DUP } ; - DIG 3 ; - CDR ; - PUSH nat 1 ; - ADD ; - SWAP ; - CAR ; - PAIR ; - DIP 4 { DUP } ; - DIG 4 ; - DIP 6 { DUP } ; - DIG 6 ; - DIP { DIP { DUP } ; - SWAP ; - SOME ; - DIP { DIP 5 { DUP } ; DIG 5 ; CAR ; CAR } } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - DUP ; - CDR ; - DIP { DIP 6 { DUP } ; - DIG 6 ; - SENDER ; - PAIR ; - SOME ; - DIP { DUP ; CAR ; CDR } } ; - UPDATE ; - DIP { DUP } ; - SWAP ; - DIP { DUP } ; - SWAP ; - DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; - SWAP ; - PAIR ; - PAIR ; - DUP ; - DIP { DUP } ; - SWAP ; - CDR ; - PUSH nat 1 ; - ADD ; - SWAP ; - CAR ; - PAIR ; - DUP ; - NIL operation ; - PAIR ; - DIP { DROP 12 } } - { DUP ; - DIP { DIP 2 { DUP } ; DIG 2 } ; - PAIR ; - DUP ; - CAR ; - DIP { DUP } ; - SWAP ; - CDR ; - DIP { DUP } ; - SWAP ; - DIP { DUP ; CAR ; CDR } ; - GET ; - IF_NONE - { PUSH string "sell_single: No card." ; FAILWITH } - { DUP ; DIP { DROP } } ; - DUP ; - CAR ; - SENDER ; - SWAP ; - COMPARE ; - NEQ ; - IF { PUSH string "This card doesn't belong to you" ; FAILWITH } - { PUSH unit Unit } ; - DIP { DUP } ; - SWAP ; - CDR ; - DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR } ; - GET ; - IF_NONE - { PUSH string "sell_single: No card pattern." ; FAILWITH } - { DUP ; DIP { DROP } } ; - DUP ; - DIP { DUP } ; - SWAP ; - CDR ; - PUSH nat 1 ; - SWAP ; - SUB ; - ABS ; - SWAP ; - CAR ; - PAIR ; - DIP 4 { DUP } ; - DIG 4 ; - DIP 4 { DUP } ; - DIG 4 ; - CDR ; - DIP { DIP { DUP } ; - SWAP ; - SOME ; - DIP { DIP 5 { DUP } ; DIG 5 ; CAR ; CAR } } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - DIP 6 { DUP } ; - DIG 6 ; - DIP { DUP ; CAR ; CDR ; NONE (pair (address %card_owner) (nat %card_pattern)) } ; - UPDATE ; - DIP 2 { DUP } ; - DIG 2 ; - CAR ; - DIP { DIP 2 { DUP } ; DIG 2 ; CDR } ; - MUL ; - SENDER ; - CONTRACT unit ; - IF_NONE - { PUSH string "sell_single: No contract." ; FAILWITH } - { DUP ; DIP { DROP } } ; - DIP { DUP } ; - SWAP ; - DIP { DUP } ; - UNIT ; - TRANSFER_TOKENS ; - DUP ; - NIL operation ; - SWAP ; - CONS ; - DUP ; - DIP { DIP 5 { DUP } ; - DIG 5 ; - DIP 5 { DUP } ; - DIG 5 ; - DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; - SWAP ; - PAIR ; - PAIR } ; - PAIR ; - DIP { DROP 14 } } ; - DIP { DROP } } - { DUP ; - DIP { DIP { DUP } ; SWAP } ; + { DIG 2 ; + DUP ; + DUG 3 ; + DIG 1 ; + DUP ; + DUG 2 ; PAIR ; DUP ; CAR ; - DIP { DUP } ; - SWAP ; + DIG 1 ; + DUP ; + DUG 2 ; CDR ; DUP ; CAR ; - CDR ; - DIP 2 { DUP } ; - DIG 2 ; CAR ; - DIP { DUP } ; + DIG 2 ; + DUP ; + DUG 3 ; GET ; IF_NONE - { PUSH string "transfer_single: No card." ; FAILWITH } + { PUSH string "buy_single: No card pattern." ; FAILWITH } { DUP ; DIP { DROP } } ; + PUSH nat 1 ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + ADD ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + MUL ; + AMOUNT ; + DIG 1 ; + DUP ; + DUG 2 ; + COMPARE ; + GT ; + IF { PUSH string "Not enough money" ; FAILWITH } { PUSH unit Unit } ; + DIG 2 ; + DUP ; + DUG 3 ; + PUSH nat 1 ; + DIG 4 ; + DUP ; + DUG 5 ; + CDR ; + ADD ; + SWAP ; + CAR ; + PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 5 ; + DUP ; + DUG 6 ; + CAR ; + CAR ; + DIG 2 ; + DUP ; + DUG 3 ; + DIG 8 ; + DUP ; + DUG 9 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; DUP ; CAR ; + CDR ; + DIG 7 ; + DUP ; + DUG 8 ; SENDER ; + PAIR ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + SWAP ; + SOME ; SWAP ; - COMPARE ; - NEQ ; - IF { PUSH string "This card doesn't belong to you" ; FAILWITH } - { PUSH unit Unit } ; - DIP 3 { DUP } ; - DIG 3 ; - DIP 5 { DUP } ; - DIG 5 ; - CAR ; - DIP { DIP 2 { DUP } ; - DIG 2 ; - DIP 6 { DUP } ; - DIG 6 ; - CDR ; - SWAP ; - CDR ; - SWAP ; - PAIR ; - SOME ; - DIP { DIP 3 { DUP } ; DIG 3 } } ; UPDATE ; + DIG 1 ; + DUP ; + DUG 2 ; + DIG 1 ; + DUP ; + DUG 2 ; DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; SWAP ; PAIR ; PAIR ; + DUP ; + PUSH nat 1 ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + ADD ; + SWAP ; + CAR ; + PAIR ; + DUP ; NIL operation ; PAIR ; - DIP { DROP 7 } } ; - DIP { DROP 2 } } } |} ] + DIP { DROP 12 } } + { DIG 2 ; + DUP ; + DUG 3 ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DUP ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DUP ; + CAR ; + CDR ; + DIG 2 ; + DUP ; + DUG 3 ; + GET ; + IF_NONE + { PUSH string "sell_single: No card." ; FAILWITH } + { DUP ; DIP { DROP } } ; + SENDER ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + COMPARE ; + NEQ ; + IF { PUSH string "This card doesn't belong to you" ; FAILWITH } + { PUSH unit Unit } ; + DIG 2 ; + DUP ; + DUG 3 ; + CAR ; + CAR ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + GET ; + IF_NONE + { PUSH string "sell_single: No card pattern." ; FAILWITH } + { DUP ; DIP { DROP } } ; + DUP ; + PUSH nat 1 ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + SUB ; + ABS ; + SWAP ; + CAR ; + PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 5 ; + DUP ; + DUG 6 ; + CAR ; + CAR ; + DIG 2 ; + DUP ; + DUG 3 ; + DIG 6 ; + DUP ; + DUG 7 ; + CDR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; + DUP ; + CAR ; + CDR ; + DIG 7 ; + DUP ; + DUG 8 ; + NONE (pair (address %card_owner) (nat %card_pattern)) ; + SWAP ; + UPDATE ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + MUL ; + SENDER ; + CONTRACT unit ; + IF_NONE + { PUSH string "sell_single: No contract." ; FAILWITH } + { DUP ; DIP { DROP } } ; + DUP ; + DIG 2 ; + DUP ; + DUG 3 ; + UNIT ; + TRANSFER_TOKENS ; + NIL operation ; + DIG 1 ; + DUP ; + DUG 2 ; + CONS ; + DIG 5 ; + DUP ; + DUG 6 ; + DIG 5 ; + DUP ; + DUG 6 ; + DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; + SWAP ; + PAIR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DIP { DROP 14 } } ; + DIP { DROP } } + { DIG 1 ; + DUP ; + DUG 2 ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DUP ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DUP ; + CAR ; + CDR ; + DUP ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + GET ; + IF_NONE + { PUSH string "transfer_single: No card." ; FAILWITH } + { DUP ; DIP { DROP } } ; + SENDER ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + COMPARE ; + NEQ ; + IF { PUSH string "This card doesn't belong to you" ; FAILWITH } + { PUSH unit Unit } ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 7 ; + DUP ; + DUG 8 ; + CDR ; + SWAP ; + CDR ; + SWAP ; + PAIR ; + DIG 7 ; + DUP ; + DUG 8 ; + CAR ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; + SWAP ; + PAIR ; + PAIR ; + NIL operation ; + PAIR ; + DIP { DROP 7 } } ; + DIP { DROP 2 } } } |} ] let%expect_test _ = run_ligo_good [ "compile-contract" ; contract "multisig.ligo" ; "main" ] ; [%expect {| - { parameter - (pair (pair (nat %counter) (lambda %message unit (list operation))) - (list %signatures (pair key_hash signature))) ; - storage - (pair (pair (list %auth key) (nat %counter)) (pair (string %id) (nat %threshold))) ; - code { DUP ; - CAR ; - DIP { DUP } ; - SWAP ; - CDR ; - DIP { DUP } ; - SWAP ; - CAR ; - CDR ; - DIP 2 { DUP } ; - DIG 2 ; - CAR ; - CAR ; - DIP { DIP { DUP } ; SWAP ; CAR ; CDR } ; - COMPARE ; - NEQ ; - IF { PUSH string "Counters does not match" ; FAILWITH } - { DUP ; - DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR } ; - PAIR ; - DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CHAIN_ID ; SWAP ; PAIR } ; - PAIR ; - PACK ; - DIP 3 { DUP } ; - DIG 3 ; - CDR ; - DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR ; PUSH nat 0 ; SWAP ; PAIR } ; - ITER { SWAP ; - PAIR ; +{ parameter + (pair (pair (nat %counter) (lambda %message unit (list operation))) + (list %signatures (pair key_hash signature))) ; + storage + (pair (pair (list %auth key) (nat %counter)) (pair (string %id) (nat %threshold))) ; + code { DUP ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CDR ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + CAR ; + COMPARE ; + NEQ ; + IF { PUSH string "Counters does not match" ; FAILWITH } + { CHAIN_ID ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + CAR ; + PAIR ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + CAR ; + DIG 2 ; + DUP ; + DUG 3 ; + PAIR ; + PAIR ; + PACK ; + PUSH nat 0 ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + CAR ; + PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + CDR ; + ITER { SWAP ; + PAIR ; + DUP ; + CAR ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CAR ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + DIG 2 ; + DUP ; + DUG 3 ; + DIG 2 ; + DUP ; + DUG 3 ; + PAIR ; + DIG 2 ; + DUP ; + DUG 3 ; + IF_CONS + { DUP ; + HASH_KEY ; + DIG 4 ; DUP ; + DUG 5 ; CAR ; - CDR ; - DIP { DUP } ; - SWAP ; - CAR ; - CAR ; - DIP 2 { DUP } ; - DIG 2 ; - CDR ; - DIP { DUP } ; - SWAP ; - DIP { DIP 2 { DUP } ; DIG 2 } ; - PAIR ; - DIP 2 { DUP } ; - DIG 2 ; - IF_CONS - { DIP 3 { DUP } ; - DIG 3 ; - CAR ; - DIP { DUP ; HASH_KEY } ; - COMPARE ; - EQ ; - IF { DUP ; - DIP { DIP 3 { DUP } ; DIG 3 ; CDR ; DIP { DIP 7 { DUP } ; DIG 7 } } ; - CHECK_SIGNATURE ; - IF { DIP 5 { DUP } ; - DIG 5 ; - PUSH nat 1 ; - ADD ; - DIP 6 { DUP } ; - DIG 6 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } - { PUSH string "Invalid signature" ; FAILWITH } ; - DIP 6 { DUP } ; - DIG 6 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } - { DIP 5 { DUP } ; DIG 5 } ; - DIP 3 { DUP } ; - DIG 3 ; - DIP 3 { DUP } ; - DIG 3 ; - SWAP ; - CDR ; - SWAP ; - PAIR ; - CAR ; - DIP { DUP } ; - PAIR ; - DIP { DROP 3 } } - { DUP } ; - DIP 5 { DUP } ; - DIG 5 ; - DIP { DUP } ; - SWAP ; - CAR ; - DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - DIP { DUP } ; + COMPARE ; + EQ ; + IF { DIG 7 ; + DUP ; + DUG 8 ; + DIG 4 ; + DUP ; + DUG 5 ; + CDR ; + DIG 2 ; + DUP ; + DUG 3 ; + CHECK_SIGNATURE ; + IF { PUSH nat 1 ; + DIG 6 ; + DUP ; + DUG 7 ; + ADD ; + DIG 6 ; + DUP ; + DUG 7 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } + { PUSH string "Invalid signature" ; FAILWITH } ; + DIG 6 ; + DUP ; + DUG 7 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } + { DIG 5 ; DUP ; DUG 6 } ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 3 ; + DUP ; + DUG 4 ; SWAP ; CDR ; - DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; SWAP ; PAIR ; - PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + SWAP ; CAR ; - DIP { DROP 6 } } ; - DUP ; - CDR ; - DIP { DIP 3 { DUP } ; DIG 3 ; CDR ; CDR } ; - COMPARE ; - LT ; - IF { PUSH string "Not enough signatures passed the check" ; FAILWITH } - { DIP 3 { DUP } ; - DIG 3 ; - DIP 4 { DUP } ; - DIG 4 ; - CAR ; - CDR ; - PUSH nat 1 ; - ADD ; - DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; - SWAP ; - PAIR ; - PAIR ; - DIP 4 { DUP } ; - DIG 4 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } ; - DIP 4 { DUP } ; - DIG 4 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 4 } } ; - DIP { DUP } ; - SWAP ; - UNIT ; - EXEC ; - DIP { DUP } ; - PAIR ; - DIP { DROP 5 } } } |} ] + PAIR ; + DIP { DROP 3 } } + { DUP } ; + DIG 5 ; + DUP ; + DUG 6 ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; + SWAP ; + PAIR ; + PAIR ; + CAR ; + DIP { DROP 6 } } ; + DIG 3 ; + DUP ; + DUG 4 ; + CDR ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + COMPARE ; + LT ; + IF { PUSH string "Not enough signatures passed the check" ; FAILWITH } + { DIG 3 ; + DUP ; + DUG 4 ; + PUSH nat 1 ; + DIG 5 ; + DUP ; + DUG 6 ; + CAR ; + CDR ; + ADD ; + DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ; + SWAP ; + PAIR ; + PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 4 } } ; + DUP ; + UNIT ; + DIG 3 ; + DUP ; + DUG 4 ; + SWAP ; + EXEC ; + PAIR ; + DIP { DROP 5 } } } |} ] let%expect_test _ = run_ligo_good [ "compile-contract" ; contract "multisig-v2.ligo" ; "main" ] ; [%expect {| - { parameter - (or (or (unit %default) (lambda %send bytes (list operation))) - (lambda %withdraw bytes (list operation))) ; - storage - (pair (pair (pair (set %authorized_addresses address) (nat %max_message_size)) - (pair (nat %max_proposal) (map %message_store bytes (set address)))) - (pair (pair (map %proposal_counters address nat) (bytes %state_hash)) - (nat %threshold))) ; - code { DUP ; - CDR ; - DIP { DUP } ; - SWAP ; - CAR ; +{ parameter + (or (or (unit %default) (lambda %send bytes (list operation))) + (lambda %withdraw bytes (list operation))) ; + storage + (pair (pair (pair (set %authorized_addresses address) (nat %max_message_size)) + (pair (nat %max_proposal) (map %message_store bytes (set address)))) + (pair (pair (map %proposal_counters address nat) (bytes %state_hash)) + (nat %threshold))) ; + code { DUP ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + IF_LEFT + { DUP ; IF_LEFT - { DUP ; - IF_LEFT - { DIP 2 { DUP } ; DIG 2 ; NIL operation ; PAIR ; DIP { DROP } } - { DUP ; - DIP { DIP 2 { DUP } ; DIG 2 } ; - PAIR ; + { DIG 2 ; DUP ; DUG 3 ; NIL operation ; PAIR ; DIP { DROP } } + { DIG 2 ; + DUP ; + DUG 3 ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DUP ; + CDR ; + DUP ; + CAR ; + CAR ; + CAR ; + SENDER ; + MEM ; + NOT ; + IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ; + DIG 2 ; + DUP ; + DUG 3 ; + CAR ; + DUP ; + PACK ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + CAR ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + SIZE ; + COMPARE ; + GT ; + IF { PUSH string "Message size exceed maximum limit" ; FAILWITH } + { PUSH unit Unit } ; + EMPTY_SET address ; + DIG 5 ; + DUP ; + DUG 6 ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DIG 6 ; + DUP ; + DUG 7 ; + CAR ; + CDR ; + CDR ; + DIG 4 ; + DUP ; + DUG 5 ; + GET ; + IF_NONE + { DIG 6 ; DUP ; + DUG 7 ; + DIG 7 ; + DUP ; + DUG 8 ; CDR ; - DUP ; CAR ; CAR ; - CAR ; - SENDER ; - MEM ; - NOT ; - IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ; - DIP 2 { DUP } ; - DIG 2 ; - CAR ; - DUP ; - PACK ; - DUP ; - SIZE ; - DIP { DIP 3 { DUP } ; DIG 3 ; CAR ; CAR ; CDR } ; - COMPARE ; - GT ; - IF { PUSH string "Message size exceed maximum limit" ; FAILWITH } - { PUSH unit Unit } ; - EMPTY_SET address ; - DUP ; - DIP { DIP 5 { DUP } ; DIG 5 } ; - PAIR ; - DIP 3 { DUP } ; - DIG 3 ; - DIP { DIP 6 { DUP } ; DIG 6 ; CAR ; CDR ; CDR } ; - GET ; - IF_NONE - { DIP 6 { DUP } ; - DIG 6 ; - DIP 7 { DUP } ; - DIG 7 ; - CDR ; - CAR ; - CAR ; - SENDER ; - GET ; - IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; - PUSH nat 1 ; - ADD ; - SOME ; - DIP { DIP 7 { DUP } ; DIG 7 ; CDR ; CAR ; CAR } ; - SENDER ; - UPDATE ; - DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - SWAP ; - PAIR ; - EMPTY_SET address ; - PUSH bool True ; - SENDER ; - UPDATE ; - DIP 2 { DUP } ; - DIG 2 ; - DIP 2 { DUP } ; - DIG 2 ; - SWAP ; - CAR ; - PAIR ; - CDR ; - DIP { DUP } ; - SWAP ; - PAIR ; - DIP { DROP 2 } } - { DUP ; - SENDER ; - MEM ; - IF { DIP 7 { DUP } ; DIG 7 } - { DIP 7 { DUP } ; - DIG 7 ; - DIP 8 { DUP } ; - DIG 8 ; - CDR ; - CAR ; - CAR ; - SENDER ; - GET ; - IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; - PUSH nat 1 ; - ADD ; - SOME ; - DIP { DIP 8 { DUP } ; DIG 8 ; CDR ; CAR ; CAR } ; - SENDER ; - UPDATE ; - DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - SWAP ; - PAIR ; - DIP 8 { DUP } ; - DIG 8 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } ; - DIP { DUP } ; - SWAP ; - PUSH bool True ; - SENDER ; - UPDATE ; - DIP 3 { DUP } ; - DIG 3 ; - DIP 2 { DUP } ; - DIG 2 ; - SWAP ; - CAR ; - PAIR ; - CDR ; - DIP { DUP } ; - SWAP ; - PAIR ; - DIP { DROP 3 } } ; - DUP ; - CAR ; - DIP { DUP } ; - SWAP ; - CDR ; + PUSH nat 1 ; + DIG 9 ; DUP ; + DUG 10 ; CDR ; CAR ; CAR ; SENDER ; GET ; IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; - DUP ; - DIP { DIP { DUP } ; SWAP ; CAR ; CDR ; CAR } ; - COMPARE ; - GT ; - IF { PUSH string "Maximum number of proposal reached" ; FAILWITH } - { PUSH unit Unit } ; - NIL operation ; - DUP ; - DIP { DIP 3 { DUP } ; DIG 3 } ; - PAIR ; - DIP 5 { DUP } ; - DIG 5 ; - SIZE ; - DIP { DIP 4 { DUP } ; DIG 4 ; CDR ; CDR } ; - COMPARE ; - GE ; - IF { DIP 4 { DUP } ; - DIG 4 ; - DIP 11 { DUP } ; - DIG 11 ; - DIP { DIP 5 { DUP } ; DIG 5 ; CAR ; CDR ; CDR ; NONE (set address) } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; - SWAP ; - PAIR ; - SWAP ; - PAIR ; - PAIR ; - DUP ; - CDR ; - CAR ; - CDR ; - DIP { DIP 12 { DUP } ; DIG 12 } ; - EXEC ; - DIP { DUP } ; - SWAP ; - DIP 2 { DUP } ; - DIG 2 ; - CDR ; - CAR ; - CDR ; - DIP { DIP 13 { DUP } ; DIG 13 } ; - CONCAT ; - SHA256 ; - DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CAR } ; - SWAP ; - PAIR ; - PAIR ; - SWAP ; - PAIR ; - DUP ; - CDR ; - CAR ; - CAR ; - DIP { DUP } ; - ITER { SWAP ; - PAIR ; - DUP ; - CAR ; - DIP { DUP } ; - SWAP ; - CDR ; - CAR ; - DUP ; - DIP { DIP 11 { DUP } ; DIG 11 } ; - MEM ; - IF { DIP { DUP } ; - SWAP ; - DIP { DUP } ; - SWAP ; - DIP { DIP 3 { DUP } ; - DIG 3 ; - CDR ; - CDR ; - PUSH nat 1 ; - SWAP ; - SUB ; - ABS ; - SOME ; - DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CAR } } ; - UPDATE ; - DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; - PAIR ; - PAIR ; - SWAP ; - PAIR ; - DIP 2 { DUP } ; - DIG 2 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } - { DIP { DUP } ; SWAP } ; - DIP 3 { DUP } ; - DIG 3 ; - CDR ; - DIP { DUP } ; - SWAP ; - PAIR ; - CAR ; - DIP { DROP 4 } } ; - DIP 4 { DUP } ; - DIG 4 ; - DIP 4 { DUP } ; - DIG 4 ; - SWAP ; - CAR ; - PAIR ; - DIP 3 { DUP } ; - DIG 3 ; - SWAP ; - CDR ; - SWAP ; - PAIR ; - DIP 2 { DUP } ; - DIG 2 ; - SWAP ; - CAR ; - PAIR ; - CAR ; - DIP { DUP } ; - PAIR ; - DIP { DROP 4 } } - { DUP ; - DIP 5 { DUP } ; - DIG 5 ; - DIP 12 { DUP } ; - DIG 12 ; - DIP { DIP 7 { DUP } ; - DIG 7 ; - SOME ; - DIP { DIP 6 { DUP } ; DIG 6 ; CAR ; CDR ; CDR } } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; - SWAP ; - PAIR ; - SWAP ; - PAIR ; - PAIR ; - SWAP ; - CAR ; - PAIR } ; - DUP ; - DIP { DROP 17 } } ; - DIP { DROP } } - { DUP ; - DIP { DIP { DUP } ; SWAP } ; - PAIR ; - DUP ; - CDR ; - DIP { DUP } ; - SWAP ; - CAR ; - PACK ; - DUP ; - DIP { DIP { DUP } ; SWAP ; CAR ; CDR ; CDR } ; - GET ; - IF_NONE - { DIP { DUP } ; SWAP } - { DUP ; - PUSH bool False ; + ADD ; + SOME ; SENDER ; UPDATE ; - DIP { DUP } ; + DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; SWAP ; - SIZE ; - DIP { DUP ; SIZE } ; - COMPARE ; - NEQ ; - IF { DIP 3 { DUP } ; - DIG 3 ; - DIP 4 { DUP } ; - DIG 4 ; + PAIR ; + EMPTY_SET address ; + PUSH bool True ; + SENDER ; + UPDATE ; + DIG 2 ; + DUP ; + DUG 3 ; + DIG 2 ; + DUP ; + DUG 3 ; + SWAP ; + CAR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + SWAP ; + CDR ; + SWAP ; + PAIR ; + DIP { DROP 2 } } + { DUP ; + SENDER ; + MEM ; + IF { DIG 7 ; DUP ; DUG 8 } + { DIG 7 ; + DUP ; + DUG 8 ; + DIG 8 ; + DUP ; + DUG 9 ; + CDR ; + CAR ; + CAR ; + PUSH nat 1 ; + DIG 10 ; + DUP ; + DUG 11 ; CDR ; CAR ; CAR ; SENDER ; GET ; IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; - PUSH nat 1 ; - SWAP ; - SUB ; - ABS ; + ADD ; SOME ; - DIP { DIP 4 { DUP } ; DIG 4 ; CDR ; CAR ; CAR } ; SENDER ; UPDATE ; DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; @@ -780,144 +757,524 @@ let%expect_test _ = PAIR ; SWAP ; PAIR ; - DIP 4 { DUP } ; - DIG 4 ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } - { DIP 3 { DUP } ; DIG 3 } ; - DIP { DUP } ; - SWAP ; - SIZE ; - PUSH nat 0 ; - SWAP ; - COMPARE ; - EQ ; - IF { DUP ; - DIP 4 { DUP } ; - DIG 4 ; - DIP { DIP { DUP } ; SWAP ; CAR ; CDR ; CDR ; NONE (set address) } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; - SWAP ; - PAIR ; - SWAP ; - PAIR ; - PAIR ; - DIP { DUP } ; - SWAP ; - DIP { DUP } ; - SWAP ; - DIP { DROP 2 } } - { DUP ; - DIP { DUP } ; - SWAP ; - DIP 5 { DUP } ; - DIG 5 ; - DIP { DIP 3 { DUP } ; - DIG 3 ; - SOME ; - DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CDR ; CDR } } ; - UPDATE ; - DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; - SWAP ; - PAIR ; - SWAP ; - PAIR ; - PAIR ; - DIP { DROP } } ; - DIP 5 { DUP } ; - DIG 5 ; - DIP 2 { DUP } ; + DIG 8 ; + DUP ; + DUG 9 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } ; + DIG 1 ; + DUP ; + DUG 2 ; + PUSH bool True ; + SENDER ; + UPDATE ; + DIG 3 ; + DUP ; + DUG 4 ; DIG 2 ; - DIP { DROP ; DUP } ; + DUP ; + DUG 3 ; SWAP ; - DIP { DROP 5 } } ; + CAR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + SWAP ; + CDR ; + SWAP ; + PAIR ; + DIP { DROP 3 } } ; DUP ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DUP ; + CDR ; + CAR ; + CAR ; + SENDER ; + GET ; + IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CDR ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + COMPARE ; + GT ; + IF { PUSH string "Maximum number of proposal reached" ; FAILWITH } + { PUSH unit Unit } ; NIL operation ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 1 ; + DUP ; + DUG 2 ; PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + CDR ; + CDR ; + DIG 6 ; + DUP ; + DUG 7 ; + SIZE ; + COMPARE ; + GE ; + IF { DIG 4 ; + DUP ; + DUG 5 ; + DIG 5 ; + DUP ; + DUG 6 ; + CAR ; + CDR ; + CDR ; + DIG 12 ; + DUP ; + DUG 13 ; + NONE (set address) ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DUP ; + CDR ; + CAR ; + CDR ; + DIG 13 ; + DUP ; + DUG 14 ; + SWAP ; + EXEC ; + DIG 1 ; + DUP ; + DUG 2 ; + DIG 13 ; + DUP ; + DUG 14 ; + DIG 3 ; + DUP ; + DUG 4 ; + CDR ; + CAR ; + CDR ; + CONCAT ; + SHA256 ; + DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CAR } ; + SWAP ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DUP ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + CAR ; + CAR ; + ITER { SWAP ; + PAIR ; + DUP ; + CAR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + CAR ; + DIG 11 ; + DUP ; + DUG 12 ; + DIG 1 ; + DUP ; + DUG 2 ; + MEM ; + IF { DIG 1 ; + DUP ; + DUG 2 ; + DIG 2 ; + DUP ; + DUG 3 ; + CDR ; + CAR ; + CAR ; + PUSH nat 1 ; + DIG 5 ; + DUP ; + DUG 6 ; + CDR ; + CDR ; + SUB ; + ABS ; + DIG 3 ; + DUP ; + DUG 4 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIG 2 ; + DUP ; + DUG 3 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } + { DIG 1 ; DUP ; DUG 2 } ; + DIG 3 ; + DUP ; + DUG 4 ; + DIG 1 ; + DUP ; + DUG 2 ; + SWAP ; + CDR ; + SWAP ; + PAIR ; + CAR ; + DIP { DROP 4 } } ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 4 ; + DUP ; + DUG 5 ; + SWAP ; + CAR ; + PAIR ; + DIG 3 ; + DUP ; + DUG 4 ; + SWAP ; + CDR ; + SWAP ; + PAIR ; + DIG 2 ; + DUP ; + DUG 3 ; + SWAP ; + CAR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + SWAP ; + CAR ; + PAIR ; + DIP { DROP 4 } } + { DUP ; + DIG 5 ; + DUP ; + DUG 6 ; + DIG 6 ; + DUP ; + DUG 7 ; + CAR ; + CDR ; + CDR ; + DIG 8 ; + DUP ; + DUG 9 ; + DIG 14 ; + DUP ; + DUG 15 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + SWAP ; + CAR ; + PAIR } ; + DUP ; + DIP { DROP 17 } } ; + DIP { DROP } } + { DIG 1 ; + DUP ; + DUG 2 ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DUP ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + PACK ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CDR ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + GET ; + IF_NONE + { DIG 1 ; DUP ; DUG 2 } + { DUP ; + PUSH bool False ; + SENDER ; + UPDATE ; + DUP ; + SIZE ; + DIG 2 ; + DUP ; + DUG 3 ; + SIZE ; + COMPARE ; + NEQ ; + IF { DIG 3 ; + DUP ; + DUG 4 ; + DIG 4 ; + DUP ; + DUG 5 ; + CDR ; + CAR ; + CAR ; + PUSH nat 1 ; + DIG 6 ; + DUP ; + DUG 7 ; + CDR ; + CAR ; + CAR ; + SENDER ; + GET ; + IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ; + SUB ; + ABS ; + SOME ; + SENDER ; + UPDATE ; + DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ; + PAIR ; + PAIR ; + SWAP ; + PAIR ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } + { DIG 3 ; DUP ; DUG 4 } ; + PUSH nat 0 ; + DIG 2 ; + DUP ; + DUG 3 ; + SIZE ; + COMPARE ; + EQ ; + IF { DUP ; + DIG 1 ; + DUP ; + DUG 2 ; + CAR ; + CDR ; + CDR ; + DIG 5 ; + DUP ; + DUG 6 ; + NONE (set address) ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + DIG 1 ; + DUP ; + DUG 2 ; + DIP { DROP 2 } } + { DUP ; + DIG 1 ; + DUP ; + DUG 2 ; + DIG 2 ; + DUP ; + DUG 3 ; + CAR ; + CDR ; + CDR ; + DIG 4 ; + DUP ; + DUG 5 ; + DIG 7 ; + DUP ; + DUG 8 ; + SWAP ; + SOME ; + SWAP ; + UPDATE ; + DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ; + SWAP ; + PAIR ; + SWAP ; + PAIR ; + PAIR ; + DIP { DROP } } ; + DIG 5 ; + DUP ; + DUG 6 ; + DIG 2 ; + DUP ; + DUG 3 ; + DIP { DROP } ; + DIG 1 ; + DUP ; + DUG 2 ; DIP { DROP 5 } } ; - DIP { DROP 2 } } } |} ] + DUP ; + NIL operation ; + PAIR ; + DIP { DROP 5 } } ; + DIP { DROP 2 } } } |} ] let%expect_test _ = run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ; [%expect {| - { parameter - (or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title)) - (or %vote (unit %nay) (unit %yea))) ; - storage - (pair (pair (pair (timestamp %finish_time) (nat %nay)) - (pair (timestamp %start_time) (string %title))) - (pair (set %voters address) (nat %yea))) ; - code { DUP ; +{ parameter + (or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title)) + (or %vote (unit %nay) (unit %yea))) ; + storage + (pair (pair (pair (timestamp %finish_time) (nat %nay)) + (pair (timestamp %start_time) (string %title))) + (pair (set %voters address) (nat %yea))) ; + code { DUP ; + CAR ; + IF_LEFT + { PUSH nat 0 ; + EMPTY_SET address ; + PAIR ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DIG 2 ; + DUP ; + DUG 3 ; + CAR ; + CDR ; + PAIR ; + PUSH nat 0 ; + DIG 3 ; + DUP ; + DUG 4 ; + CAR ; + CAR ; + PAIR ; + PAIR ; + PAIR ; + NIL operation ; + PAIR ; + DIP { DROP } } + { DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + DIG 1 ; + DUP ; + DUG 2 ; + PAIR ; + DUP ; + CDR ; + NOW ; + SENDER ; + DIG 3 ; + DUP ; + DUG 4 ; CAR ; IF_LEFT - { DUP ; + { DIG 3 ; + DUP ; + DUG 4 ; + PUSH nat 1 ; + DIG 5 ; + DUP ; + DUG 6 ; CAR ; CAR ; - PUSH nat 0 ; + CDR ; + ADD ; + DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ; SWAP ; PAIR ; - DIP { DUP ; CAR ; CDR ; DIP { DUP ; CDR } ; PAIR } ; PAIR ; - DIP { PUSH nat 0 ; EMPTY_SET address ; PAIR } ; - PAIR ; - NIL operation ; PAIR ; DIP { DROP } } - { DUP ; - DIP { DIP { DUP } ; SWAP ; CDR } ; - PAIR ; + { DIG 3 ; DUP ; + DUG 4 ; + PUSH nat 1 ; + DIG 5 ; + DUP ; + DUG 6 ; CDR ; - NOW ; - SENDER ; - DIP 3 { DUP } ; - DIG 3 ; - CAR ; - IF_LEFT - { DIP 3 { DUP } ; - DIG 3 ; - DIP 4 { DUP } ; - DIG 4 ; - CAR ; - CAR ; - CDR ; - PUSH nat 1 ; - ADD ; - DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ; - SWAP ; - PAIR ; - PAIR ; - PAIR ; - DIP { DROP } } - { DIP 3 { DUP } ; - DIG 3 ; - DIP 4 { DUP } ; - DIG 4 ; - CDR ; - CDR ; - PUSH nat 1 ; - ADD ; - DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ; - SWAP ; - PAIR ; - SWAP ; - PAIR ; - DIP { DROP } } ; - DUP ; - DIP 2 { DUP } ; - DIG 2 ; - DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; PUSH bool True } ; - UPDATE ; - DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ; + CDR ; + ADD ; + DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ; + SWAP ; PAIR ; SWAP ; PAIR ; - NIL operation ; - PAIR ; - DIP { DROP 6 } } ; - DIP { DROP } } } |}] + DIP { DROP } } ; + DUP ; + DIG 1 ; + DUP ; + DUG 2 ; + CDR ; + CAR ; + DIG 3 ; + DUP ; + DUG 4 ; + PUSH bool True ; + SWAP ; + UPDATE ; + DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ; + PAIR ; + SWAP ; + PAIR ; + NIL operation ; + PAIR ; + DIP { DROP 6 } } ; + DIP { DROP } } } |}] let%expect_test _ = run_ligo_good [ "compile-contract" ; contract "implicit.mligo" ; "main" ] ; @@ -945,7 +1302,7 @@ let%expect_test _ = LAMBDA (pair mutez unit) mutez - { DUP ; CAR ; SWAP ; CDR ; DIP { DUP } ; SWAP ; DIP { DROP 2 } } ; + { DUP ; CAR ; SWAP ; CDR ; DIG 1 ; DUP ; DUG 2 ; DIP { DROP 2 } } ; SWAP ; APPLY ; DIP { DROP } } @@ -1131,12 +1488,16 @@ ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, char storage string ; code { PUSH string "one" ; NIL operation ; PAIR ; DIP { DROP } } } ; PAIR ; + DIG 1 ; DUP ; - CAR ; + DUG 2 ; + CDR ; NIL operation ; - SWAP ; + DIG 2 ; + DUP ; + DUG 3 ; + CAR ; CONS ; - DIP { DIP { DUP } ; SWAP ; CDR } ; PAIR ; DIP { DROP 2 } } } |}]; @@ -1144,10 +1505,12 @@ ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, char [%expect {| { parameter int ; storage (pair (pair int string) (pair nat bool)) ; - code { PUSH string "2" ; + code { PUSH bool False ; + PUSH nat 2 ; + PAIR ; + PUSH string "2" ; PUSH int 2 ; PAIR ; - DIP { PUSH bool False ; PUSH nat 2 ; PAIR } ; PAIR ; NIL operation ; PAIR ; @@ -1171,9 +1534,10 @@ let%expect_test _ = [%expect {| { parameter nat ; storage int ; - code { DUP ; - SELF %default ; - SWAP ; + code { SELF %default ; + DIG 1 ; + DUP ; + DUG 2 ; CDR ; NIL operation ; PAIR ; @@ -1229,11 +1593,15 @@ let%expect_test _ = PUSH mutez 300000000 ; PUSH int 2 ; TRANSFER_TOKENS ; + DIG 2 ; DUP ; + DUG 3 ; + CDR ; NIL operation ; - SWAP ; + DIG 2 ; + DUP ; + DUG 3 ; CONS ; - DIP { DIP 2 { DUP } ; DIG 2 ; CDR } ; PAIR ; DIP { DROP 3 } } } |}] ; @@ -1246,11 +1614,15 @@ let%expect_test _ = PUSH mutez 300000000 ; PUSH int 2 ; TRANSFER_TOKENS ; + DIG 2 ; DUP ; + DUG 3 ; + CDR ; NIL operation ; - SWAP ; + DIG 2 ; + DUP ; + DUG 3 ; CONS ; - DIP { DIP 2 { DUP } ; DIG 2 ; CDR } ; PAIR ; DIP { DROP 3 } } } |}] ; diff --git a/src/passes/12-compiler/compiler_environment.ml b/src/passes/12-compiler/compiler_environment.ml index 0736593ee..5b429208f 100644 --- a/src/passes/12-compiler/compiler_environment.ml +++ b/src/passes/12-compiler/compiler_environment.ml @@ -15,22 +15,15 @@ let get : environment -> expression_variable -> michelson result = fun e s -> error title content in generic_try error @@ (fun () -> Environment.get_i s e) in - let rec aux_bubble = fun n -> - match n with - | 0 -> i_dup - | n -> seq [ - dip @@ aux_bubble (n - 1) ; - i_swap ; - ] - in let aux_dig = fun n -> seq [ - dipn n i_dup ; i_dig n ; + i_dup ; + i_dug (n + 1) ; ] in let code = - if position < 2 - then aux_bubble position + if position < 1 + then i_dup else aux_dig position in ok code diff --git a/src/passes/12-compiler/compiler_program.ml b/src/passes/12-compiler/compiler_program.ml index 200bd0cf9..be42521db 100644 --- a/src/passes/12-compiler/compiler_program.ml +++ b/src/passes/12-compiler/compiler_program.ml @@ -251,11 +251,12 @@ and translate_expression (expr:expression) (env:environment) : michelson result ) | E_application (f , arg) -> ( trace (simple_error "Compiling quote application") @@ - let%bind f = translate_expression f env in + let%bind f = translate_expression f (Environment.add (Var.fresh (), arg.type_value) env) in let%bind arg = translate_expression arg env in return @@ seq [ arg ; - dip f ; + f ; + i_swap ; prim I_EXEC ; ] ) @@ -273,15 +274,18 @@ and translate_expression (expr:expression) (env:environment) : michelson result ) | E_constant{cons_name=str;arguments= lst} -> let module L = Logger.Stateful() in - let%bind pre_code = - let aux code expr = + let%bind (pre_code, _env) = + let aux (code, env) expr = let%bind expr_code = translate_expression expr env in L.log @@ Format.asprintf "\n%a -> %a in %a\n" PP.expression expr Michelson.pp expr_code PP.environment env ; - ok (seq [ expr_code ; dip code ]) in - bind_fold_right_list aux (seq []) lst in + let env = Environment.add (Var.fresh (), expr.type_value) env in + let code = code @ [expr_code] in + ok (code, env) in + bind_fold_right_list aux ([], env) lst in + let pre_code = seq pre_code in let%bind predicate = get_operator str ty lst in let%bind code = match (predicate, List.length lst) with | Constant c, 0 -> ok @@ seq [ @@ -426,12 +430,15 @@ and translate_expression (expr:expression) (env:environment) : michelson result ) ) | E_fold ((v , body) , collection , initial) -> ( - let%bind collection' = translate_expression collection env in + let%bind collection' = + translate_expression + collection + (Environment.add (Var.fresh (), initial.type_value) env) in let%bind initial' = translate_expression initial env in let%bind body' = translate_expression body (Environment.add v env) in let code = seq [ + initial' ; collection' ; - dip initial' ; i_iter (seq [ i_swap ; i_pair ; body' ; dip i_drop ;