diff --git a/src/bin/expect_tests/contract_tests.ml b/src/bin/expect_tests/contract_tests.ml
index 485d91c8b..7492ce39d 100644
--- a/src/bin/expect_tests/contract_tests.ml
+++ b/src/bin/expect_tests/contract_tests.ml
@@ -11,7 +11,7 @@ let%expect_test _ =
   [%expect {| 1093 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
-  [%expect {| 627 bytes |}] ;
+  [%expect {| 2717 bytes |}] ;
 
   run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
   [%expect {| 628 bytes |}] ;
@@ -393,77 +393,432 @@ let%expect_test _ =
 let%expect_test _ =
   run_ligo_good [ "compile-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
   [%expect {|
-    { parameter (lambda unit (list operation)) ;
+    { parameter
+        (or (or (unit %default) (lambda %send bytes (list operation)))
+            (lambda %withdraw bytes (list operation))) ;
       storage
-        (pair (pair (set %auth address) (big_map %message_store bytes (set address)))
-              (nat %threshold)) ;
+        (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 ;
-             CAR ;
-             DIP { DUP ; CDR } ;
-             PAIR ;
-             DUP ;
              CDR ;
-             DUP ;
-             CAR ;
-             CAR ;
-             SENDER ;
-             MEM ;
-             NOT ;
-             IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ;
-             DROP ;
              DIP { DUP } ;
              SWAP ;
              CAR ;
-             DUP ;
-             PACK ;
-             DUP ;
-             NIL operation ;
-             SWAP ;
-             DIP { DIP 3 { DUP } ; DIG 3 ; CAR ; CDR } ;
-             GET ;
-             IF_NONE
-               { EMPTY_SET address }
-               { DUP ; PUSH bool True ; SENDER ; UPDATE ; DIP { DROP } } ;
-             DUP ;
-             SIZE ;
-             DIP { DIP 4 { DUP } ; DIG 4 ; CDR } ;
-             COMPARE ;
-             GE ;
-             IF { DIP 2 { DUP } ;
-                  DIG 2 ;
-                  DIP { DIP 4 { DUP } ; DIG 4 ; CAR ; CDR ; NONE (set address) } ;
-                  UPDATE ;
-                  DIP { DIP 4 { DUP } ; DIG 4 ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
-                  SWAP ;
-                  PAIR ;
-                  PAIR ;
-                  DIP 5 { DROP } ;
-                  DUG 4 ;
-                  DIP 3 { DUP } ;
-                  DIG 3 ;
-                  UNIT ;
-                  EXEC ;
-                  DIP { DIP { DUP } ; SWAP ; DROP } ;
-                  SWAP ;
-                  DIP { DIP { DROP } } ;
-                  PUSH unit Unit }
-                { DIP 2 { DUP } ;
-                  DIG 2 ;
-                  DIP { DUP ; SOME ; DIP { DIP 4 { DUP } ; DIG 4 ; CAR ; CDR } } ;
-                  UPDATE ;
-                  DIP { DIP 4 { DUP } ; DIG 4 ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
-                  SWAP ;
-                  PAIR ;
-                  PAIR ;
-                  DIP 5 { DROP } ;
-                  DUG 4 ;
-                  PUSH unit Unit } ;
-             DROP ;
-             DIP { DUP } ;
-             SWAP ;
-             DIP { DIP 4 { DUP } ; DIG 4 } ;
-             PAIR ;
-             DIP { DROP 7 } } } |} ]
+             IF_LEFT
+               { DUP ;
+                 IF_LEFT
+                   { DIP 2 { DUP } ; DIG 2 ; NIL operation ; PAIR ; DIP { DROP } }
+                   { DUP ;
+                     DIP { DIP 2 { DUP } ; DIG 2 } ;
+                     PAIR ;
+                     DUP ;
+                     CDR ;
+                     DUP ;
+                     CAR ;
+                     CAR ;
+                     CAR ;
+                     SENDER ;
+                     MEM ;
+                     NOT ;
+                     IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ;
+                     DROP ;
+                     DIP { DUP } ;
+                     SWAP ;
+                     CAR ;
+                     DUP ;
+                     PACK ;
+                     DUP ;
+                     SIZE ;
+                     DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR ; CDR } ;
+                     COMPARE ;
+                     GT ;
+                     IF { PUSH string "Message size exceed maximum limit" ; FAILWITH }
+                        { PUSH unit Unit } ;
+                     DROP ;
+                     DUP ;
+                     EMPTY_SET address ;
+                     SWAP ;
+                     DIP { DIP 3 { DUP } ; DIG 3 ; CAR ; CDR ; CDR } ;
+                     GET ;
+                     IF_NONE
+                       { DIP 3 { DUP } ;
+                         DIG 3 ;
+                         CDR ;
+                         CAR ;
+                         CAR ;
+                         SENDER ;
+                         GET ;
+                         IF_NONE { PUSH string "GET_FORCE" ; FAILWITH } {} ;
+                         PUSH nat 1 ;
+                         ADD ;
+                         SOME ;
+                         DIP { DIP 3 { DUP } ; DIG 3 ; CDR ; CAR ; CAR } ;
+                         SENDER ;
+                         UPDATE ;
+                         DIP { DIP 3 { DUP } ;
+                               DIG 3 ;
+                               DUP ;
+                               CAR ;
+                               SWAP ;
+                               CDR ;
+                               DUP ;
+                               CDR ;
+                               SWAP ;
+                               CAR ;
+                               CDR } ;
+                         PAIR ;
+                         PAIR ;
+                         SWAP ;
+                         PAIR ;
+                         DIP 4 { DROP } ;
+                         DUG 3 ;
+                         EMPTY_SET address ;
+                         PUSH bool True ;
+                         SENDER ;
+                         UPDATE ;
+                         DIP { DROP } ;
+                         PUSH unit Unit }
+                       { DUP ;
+                         SENDER ;
+                         MEM ;
+                         IF { PUSH unit Unit }
+                            { DIP 4 { DUP } ;
+                              DIG 4 ;
+                              CDR ;
+                              CAR ;
+                              CAR ;
+                              SENDER ;
+                              GET ;
+                              IF_NONE { PUSH string "GET_FORCE" ; FAILWITH } {} ;
+                              PUSH nat 1 ;
+                              ADD ;
+                              SOME ;
+                              DIP { DIP 4 { DUP } ; DIG 4 ; CDR ; CAR ; CAR } ;
+                              SENDER ;
+                              UPDATE ;
+                              DIP { DIP 4 { DUP } ;
+                                    DIG 4 ;
+                                    DUP ;
+                                    CAR ;
+                                    SWAP ;
+                                    CDR ;
+                                    DUP ;
+                                    CDR ;
+                                    SWAP ;
+                                    CAR ;
+                                    CDR } ;
+                              PAIR ;
+                              PAIR ;
+                              SWAP ;
+                              PAIR ;
+                              DIP 5 { DROP } ;
+                              DUG 4 ;
+                              PUSH unit Unit } ;
+                         DROP ;
+                         DUP ;
+                         PUSH bool True ;
+                         SENDER ;
+                         UPDATE ;
+                         DIP { DIP { DUP } ; SWAP ; DROP } ;
+                         SWAP ;
+                         DROP ;
+                         DIP { DROP } ;
+                         PUSH unit Unit } ;
+                     DROP ;
+                     DIP 3 { DUP } ;
+                     DIG 3 ;
+                     CDR ;
+                     CAR ;
+                     CAR ;
+                     SENDER ;
+                     GET ;
+                     IF_NONE { PUSH string "GET_FORCE" ; FAILWITH } {} ;
+                     DUP ;
+                     DIP { DIP 4 { DUP } ; DIG 4 ; CAR ; CDR ; CAR } ;
+                     COMPARE ;
+                     GT ;
+                     IF { PUSH string "Maximum number of proposal reached" ; FAILWITH }
+                        { PUSH unit Unit } ;
+                     DROP ;
+                     NIL operation ;
+                     DIP 2 { DUP } ;
+                     DIG 2 ;
+                     SIZE ;
+                     DIP { DIP 5 { DUP } ; DIG 5 ; CDR ; CDR } ;
+                     COMPARE ;
+                     GE ;
+                     IF { DIP 3 { DUP } ;
+                          DIG 3 ;
+                          DIP { DIP 5 { DUP } ; DIG 5 ; CAR ; CDR ; CDR ; NONE (set address) } ;
+                          UPDATE ;
+                          DIP { DIP 5 { DUP } ;
+                                DIG 5 ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                CAR } ;
+                          SWAP ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          PAIR ;
+                          DIP 6 { DROP } ;
+                          DUG 5 ;
+                          DIP 5 { DUP } ;
+                          DIG 5 ;
+                          CDR ;
+                          CAR ;
+                          CDR ;
+                          DIP { DIP 4 { DUP } ; DIG 4 } ;
+                          EXEC ;
+                          DIP { DROP } ;
+                          DIP 5 { DUP } ;
+                          DIG 5 ;
+                          CDR ;
+                          CAR ;
+                          CDR ;
+                          DIP { DIP 3 { DUP } ; DIG 3 } ;
+                          CONCAT ;
+                          SHA256 ;
+                          DIP { DIP 5 { DUP } ;
+                                DIG 5 ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                CAR } ;
+                          SWAP ;
+                          PAIR ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          DIP 6 { DROP } ;
+                          DUG 5 ;
+                          DIP 5 { DUP } ;
+                          DIG 5 ;
+                          CDR ;
+                          CAR ;
+                          CAR ;
+                          DIP { DIP 5 { DUP } ; DIG 5 } ;
+                          ITER { SWAP ;
+                                 PAIR ;
+                                 DUP ;
+                                 CAR ;
+                                 DIP { DUP } ;
+                                 SWAP ;
+                                 CDR ;
+                                 CAR ;
+                                 DIP 2 { DUP } ;
+                                 DIG 2 ;
+                                 CDR ;
+                                 CDR ;
+                                 DIP { DUP } ;
+                                 SWAP ;
+                                 DIP { DIP 6 { DUP } ; DIG 6 } ;
+                                 MEM ;
+                                 IF { DIP { DUP } ;
+                                      SWAP ;
+                                      DIP { DUP ;
+                                            PUSH nat 1 ;
+                                            SWAP ;
+                                            SUB ;
+                                            ABS ;
+                                            SOME ;
+                                            DIP { DIP 2 { DUP } ; DIG 2 ; CDR ; CAR ; CAR } } ;
+                                      UPDATE ;
+                                      DIP { DIP 2 { DUP } ;
+                                            DIG 2 ;
+                                            DUP ;
+                                            CAR ;
+                                            SWAP ;
+                                            CDR ;
+                                            DUP ;
+                                            CDR ;
+                                            SWAP ;
+                                            CAR ;
+                                            CDR } ;
+                                      PAIR ;
+                                      PAIR ;
+                                      SWAP ;
+                                      PAIR ;
+                                      DIP 3 { DROP } ;
+                                      DUG 2 ;
+                                      PUSH unit Unit }
+                                    { PUSH unit Unit } ;
+                                 DROP ;
+                                 DIP 2 { DUP } ;
+                                 DIG 2 ;
+                                 DIP { DROP 4 } } ;
+                          DUP ;
+                          DIP { DIP 6 { DUP } ; DIG 6 ; DROP } ;
+                          DIP 7 { DROP } ;
+                          DUG 6 ;
+                          DROP ;
+                          PUSH unit Unit }
+                        { DIP 3 { DUP } ;
+                          DIG 3 ;
+                          DIP { DIP 2 { DUP } ;
+                                DIG 2 ;
+                                SOME ;
+                                DIP { DIP 5 { DUP } ; DIG 5 ; CAR ; CDR ; CDR } } ;
+                          UPDATE ;
+                          DIP { DIP 5 { DUP } ;
+                                DIG 5 ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                CAR } ;
+                          SWAP ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          PAIR ;
+                          DIP 6 { DROP } ;
+                          DUG 5 ;
+                          PUSH unit Unit } ;
+                     DROP ;
+                     DUP ;
+                     DIP { DIP 5 { DUP } ; DIG 5 } ;
+                     PAIR ;
+                     DIP { DROP 8 } } ;
+                 DIP { DROP } }
+               { DUP ;
+                 DIP { DIP { DUP } ; SWAP } ;
+                 PAIR ;
+                 DUP ;
+                 CDR ;
+                 DIP { DUP } ;
+                 SWAP ;
+                 CAR ;
+                 DUP ;
+                 PACK ;
+                 DUP ;
+                 DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CDR ; CDR } ;
+                 GET ;
+                 IF_NONE
+                   { PUSH unit Unit }
+                   { DUP ;
+                     PUSH bool False ;
+                     SENDER ;
+                     UPDATE ;
+                     DIP { DUP } ;
+                     SWAP ;
+                     SIZE ;
+                     DIP { DUP ; SIZE } ;
+                     COMPARE ;
+                     NEQ ;
+                     IF { DIP 4 { DUP } ;
+                          DIG 4 ;
+                          CDR ;
+                          CAR ;
+                          CAR ;
+                          SENDER ;
+                          GET ;
+                          IF_NONE { PUSH string "GET_FORCE" ; FAILWITH } {} ;
+                          PUSH nat 1 ;
+                          SWAP ;
+                          SUB ;
+                          ABS ;
+                          SOME ;
+                          DIP { DIP 4 { DUP } ; DIG 4 ; CDR ; CAR ; CAR } ;
+                          SENDER ;
+                          UPDATE ;
+                          DIP { DIP 4 { DUP } ;
+                                DIG 4 ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                CDR } ;
+                          PAIR ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          DIP 5 { DROP } ;
+                          DUG 4 ;
+                          PUSH unit Unit }
+                        { PUSH unit Unit } ;
+                     DROP ;
+                     DUP ;
+                     SIZE ;
+                     PUSH nat 0 ;
+                     SWAP ;
+                     COMPARE ;
+                     EQ ;
+                     IF { DIP 2 { DUP } ;
+                          DIG 2 ;
+                          DIP { DIP 4 { DUP } ; DIG 4 ; CAR ; CDR ; CDR ; NONE (set address) } ;
+                          UPDATE ;
+                          DIP { DIP 4 { DUP } ;
+                                DIG 4 ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                CAR } ;
+                          SWAP ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          PAIR ;
+                          DIP 5 { DROP } ;
+                          DUG 4 ;
+                          PUSH unit Unit }
+                        { DIP 2 { DUP } ;
+                          DIG 2 ;
+                          DIP { DUP ; SOME ; DIP { DIP 4 { DUP } ; DIG 4 ; CAR ; CDR ; CDR } } ;
+                          UPDATE ;
+                          DIP { DIP 4 { DUP } ;
+                                DIG 4 ;
+                                DUP ;
+                                CDR ;
+                                SWAP ;
+                                CAR ;
+                                DUP ;
+                                CAR ;
+                                SWAP ;
+                                CDR ;
+                                CAR } ;
+                          SWAP ;
+                          PAIR ;
+                          SWAP ;
+                          PAIR ;
+                          PAIR ;
+                          DIP 5 { DROP } ;
+                          DUG 4 ;
+                          PUSH unit Unit } ;
+                     DIP { DROP 2 } } ;
+                 DROP ;
+                 DIP 2 { DUP } ;
+                 DIG 2 ;
+                 NIL operation ;
+                 PAIR ;
+                 DIP { DROP 5 } } ;
+             DIP { DROP 2 } } } |} ]
 
 let%expect_test _ =
   run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
diff --git a/src/bin/expect_tests/help_tests.ml b/src/bin/expect_tests/help_tests.ml
index 76e177fb9..bcfa99912 100644
--- a/src/bin/expect_tests/help_tests.ml
+++ b/src/bin/expect_tests/help_tests.ml
@@ -37,6 +37,9 @@ let%expect_test _ =
            evaluate-value
                Subcommand: evaluate a given definition.
 
+           measure-contract
+               Subcommand: measure a contract's compiled size in bytes.
+
            run-function
                Subcommand: run a function with the given parameter.
 
@@ -81,13 +84,12 @@ let%expect_test _ =
            evaluate-value
                Subcommand: evaluate a given definition.
 
-           run-function
-               Subcommand: run a function with the given parameter.
-
-    COMMANDS
            measure-contract
                Subcommand: measure a contract's compiled size in bytes.
 
+           run-function
+               Subcommand: run a function with the given parameter.
+
     OPTIONS
            --help[=FMT] (default=auto)
                Show this help in format FMT. The value FMT must be one of `auto',