sbuilder-ethereum 0.0.6

data/lib/sbuilder/constants.rb

@@ -0,0 +1,93 @@
+module Sbuilder
+  module Ethereum
+
+    class Constants
+
+      # ------------------------------------------------------------------
+      # Domains 
+      DOMAIN_ADDRESS = "eth_address"
+      DOMAIN_VALUE = "eth_value"
+      DOMAIN_GAS = "eth_gas"
+      DOMAIN_CODE_HASH = "eth_code_hash"
+      DOMAIN_BOOLEAN = "BOOLEAN"
+      DOMAIN_DEFAULT = "default" # when no better candidate not found
+
+
+      # ------------------------------------------------------------------
+      # Symbol table helpers
+      SYMBOL_RETURN_PREFIX="return-"
+      
+
+      # ------------------------------------------------------------------
+      # Solidity constans
+      
+      SOL_MSG="msg"
+      SOL_NOW="now"
+      SOL_ADDRESS="address"
+      SOL_UINT="uint"            
+      SOL_SEND="send"
+      SOL_BOOLEAN_TYPE="bool"
+      
+      # ------------------------------------------------------------------
+      # Configuration defaults
+
+      # configuration validation
+      VALIDATION = {
+        :class_configure => {
+          :allowed => %w( solc_command ),
+          :required => %w( ),
+        },
+        :configure => {
+          :allowed => %w( preferences  ),
+          :required => %w( ),
+        }
+      }
+      
+
+      # preferences used - unless otherwise stated
+      DEFAULT_PREFERENCES = {
+        "tla-debug" => false,    # debug messages
+        "tla-trace" => false,    # framework trace messages
+      }
+  
+
+      # defauls for configuration
+
+      CONFIGURATION_DEFAULTS = {
+        'service_completion' => nil   # TLA macro called to complete interface service
+      }
+
+
+      # ------------------------------------------------------------------
+      # Field names
+      # Contract ID
+      FIELD_NAME_CID = "cid"
+      # Original transactor
+      FIELD_NAME_ORIGINATOR = "originator"
+      # Original transactor
+      FIELD_NAME_SENDER = "sender"
+      # Account ID
+      FIELD_NAME_ADDRESS = "address"
+      # Account ID
+      FIELD_NAME_RECIPIENT = "recipient"
+      # Beneficiary account (in mining)
+      FIELD_NAME_BENEFICIARY = "beneficiary"
+      # Eth VALUE
+      FIELD_NAME_BALANCE = "balance"
+      # Eth VALUE
+      FIELD_NAME_VALUE = "value"
+      # Result
+      FIELD_NAME_RESULT = "result"      
+      # Result
+      FIELD_NAME_GAS = "gas"
+      # EVM code (name of class)
+      FIELD_NAME_CODE_HASH = "codeHash"      
+      # # Balace on address, inherited to contract
+      # FIELD_NAME_BALANCE = "balance"
+      FIELD_NAME_STATUS = "status"      
+      
+
+      
+    end
+  end
+end

data/lib/sbuilder/exception.rb

@@ -0,0 +1,22 @@
+module Sbuilder
+  module Ethereum
+    class SbuilderEtherumException < Exception
+    end
+    
+    class SbuilderEtherumScopeException < SbuilderEtherumException
+    end
+
+    class SexpException < SbuilderEtherumException
+    end
+
+    class SexpProcessorDataflowException < SbuilderEtherumException
+    end
+
+    class  SbuilderEtherumMustacheException < SbuilderEtherumException
+    end
+    class  SbuilderEtherumPluginException < SbuilderEtherumException
+    end
+    class  SbuilderEtherumCompileException < SbuilderEtherumException
+    end
+  end
+end

data/lib/sbuilder/generate/sexp_processor_tla.rb

@@ -0,0 +1,2674 @@
+# coding: utf-8
+module Sbuilder
+  module Ethereum
+    
+    ##
+    # Extract snippets and interfaces from SexpAst.
+    #
+    # Assume
+    # - symbols defined && resolved
+    # - dataflows identified
+    #
+    # Actions
+    # - Create Snippets:
+    #    -- VariableDeclaration --> TLA_State, :name
+    #    -- FunctionDefinition --> TLA_procedure, :name, :body
+    #       -- :body:
+    #              Return --> :TLA_Return
+    #              Assignment --> :TLA_Assignment
+    #              Identifier --> :TLA_Identifier
+
+    ## 
+    # This abstract class manages 'elementGenerator, which knows how
+    # to create TLA language building block (gen_ methods). This class
+    # also manages 'partials' datastructure, which actually know, how
+    # to render s-expressio to TLA building block string. Element
+    # generator is created in entry klass 'SexpProcessorTla', which
+    # passes reference to this one element generator to specialized
+    # klasses e.g. 'FunctionBodyProcessor'.
+    class SexpProcessorTlaRoot < SexpProcessorEthereum
+      
+      # ------------------------------------------------------------------
+      # element generator methods
+
+      # @attr [TlaElementGenerator] elementGenerator helper to create
+      # SEXP data elements, and mustache partials to render the SEXP
+      # data elements to TLA language. 
+      attr_reader :elementGenerator
+      
+      extend Forwardable                      # for easy delegation
+
+      def_delegators :elementGenerator,       # generator methods
+                     :requiresLabelAfter,     # return true is next statement should have a label
+                     :gen_empty_set,
+                     :gen_set,
+                     :gen_list,                     
+                     :gen_nilElement,
+                     :gen_op_set_minus,
+                     :gen_operator,
+                     :gen_macro_call,                     
+                     :gen_operator_call,
+                     :gen_expression2,
+                     :gen_identifier,
+                     :gen_service_name,                     
+                     :gen_state_variable,
+                     :gen_record_definition,
+                     :gen_name_op_operand,
+                     # names
+                     :gen_specname,
+                     :gen_interface_input_variable_name,
+                     :gen_interface_abort_label,
+                     :gen_interface_fail_label,
+                     :gen_interface_end_label,
+                     :gen_plainname,
+                     # 
+                     :gen_constant,
+                     :gen_str,
+                     :gen_parenthesis,
+                     # :gen_service_entry,
+                     :gen_service_procedure,
+                     :gen_free_text,
+                     :gen_debug_msg,
+                     :gen_assert,
+                     :gen_commented,
+                     :gen_traced_stmt,
+                     :gen_labeled_stmt, # add label to stmt
+                     :gen_label,     # skip which is followed by label
+                     :gen_label_it,  # wrapts stmt to require label after
+                     :gen_goto,
+                     :gen_either,                                          
+                     :gen_skip,
+                     # :gen_check_resume,
+                     :gen_assign,
+                     :gen_record_field_definition,
+                     :gen_record_named_field,
+                     :gen_record_field,
+                     :gen_stmts,
+                     :gen_operator_dummy,
+                     :gen_construct_contract,
+                     :gen_new_record,
+                     :gen_procedure_call,
+                     :gen_if,
+                     :gen_not,                     
+                     :gen_IF,
+                     :gen_TRUE,
+                     :gen_FALSE,                                          
+                     :gen_EXCEPT,
+                     :gen_and,
+                     :gen_bin_op,
+                     :gen_unary_op,
+                     :gen_set_iterate,
+                     :gen_set_map,                     
+                     :gen_macro            
+
+      
+
+      # ------------------------------------------------------------------
+      # Attributes set in configuration
+
+      # @attr [Hash] options set in initialize
+      attr_accessor :options
+      
+
+      def initialize( options )
+        super( options )
+        @options = options
+
+        # visitors just recurses - do not shift sexp (as sexp_processor default does)
+        self.default_method = :process_skip
+
+      end
+
+      # ------------------------------------------------------------------
+      # Utitities callable from base klasses
+
+      ##
+      # Address of storage root - support transaction
+      def g_storageRoot
+        gen_specname(:eth, TlaElementText::FW_STATE_STORAGE_ROOT)
+      end
+
+      def g_storageRoot_temp
+        gen_specname(:eth, TlaElementText::FW_STATE_STORAGE_ROOT_TEMP)
+      end
+
+      #
+      # storage root to use in execution
+      def g_storageRoot_exec
+        gen_operator_call( 'Head', g_storageRoot_temp )
+      end
+
+      def g_dispatcherMeta
+        :dispatcher
+      end
+      def g_dispatcherReturnMeta
+        :dispatcher_ret
+      end
+
+      # @return [sTla] for 'dispatcherName' macro
+      def g_dispatcher( dispatcherName )
+        gen_specname( g_dispatcherMeta, dispatcherName  )
+      end
+      
+      def g_dispatcherReturn( dispatcherName )
+        gen_specname( g_dispatcherReturnMeta, dispatcherName  )
+      end
+      
+      # def g_ethGasUsed
+      #   gen_specname(:eth, TlaElementText::FW_STATE_GAS_USED )
+      # end
+
+      # def g_ethGasUsed_temp
+      #   gen_specname(:eth, TlaElementText::FW_STATE_GAS_USED_TEMP )        
+      # end
+      
+      # def g_ethGasUsed_exec
+      #   gen_operator_call( 'Head', g_ethGasUsed_temp )        
+      # end
+
+      # def g_ethGasUsed_temp
+      #   gen_specname(:eth, TlaElementText::FW_STATE_GAS_USED_TEMP )
+      # end
+
+      def g_ethAccounts
+        gen_specname(:eth, TlaElementText::FW_STATE_ACCOUNTS )
+      end
+
+      def g_ethAccounts_temp
+        gen_specname(:eth, TlaElementText::FW_STATE_ACCOUNTS_TEMP )
+      end
+
+      def g_ethAccounts_exec
+        gen_operator_call( 'Head', g_ethAccounts_temp )
+      end
+
+
+      # stack = <<value> \o Tail( stack )
+      def gen_assignOnTop( stackElement, value )
+        gen_assign(
+          stackElement,
+          gen_operator_call( TlaElementText::OP_INFRA_UPDATE_TOP, s(stackElement, value )) 
+        )
+        
+      end
+
+
+      ##
+      # Utilitiy operator stackVariable := valtoAssing \o Tail(
+      # g_blockStack ). Direct replacement to gen_assign
+      def g_assignOnTop( stackVariable, valtoAssing  )
+        gen_assign(
+          stackVariable,
+          gen_operator_call( 'Push', s(gen_operator_call("Tail", stackVariable ), valtoAssing)))
+      end
+
+      ##
+      # Make it permanent
+      def g_assignOnStack( stackVariable, valtoAssing  )
+        gen_assign(
+          stackVariable,
+          gen_operator_call(
+            'Push',
+            s(
+              gen_operator_call( 'PropageOnStack', s(gen_operator_call("Tail", stackVariable ), valtoAssing)),
+              valtoAssing
+            )))
+      end
+
+
+      # def g_useIntrinsicGas( interfaceName, service_formal_parameter_name )
+      #   sender_account = gen_record_field(  gen_identifier(service_formal_parameter_name), Constants::FIELD_NAME_SENDER)
+      #   gasValue = g_gasToValue(gen_operator_call( TlaElementText::ETH_OPEATOR_INTRINSIC_GAS) )
+      #   accountsUpdated = gen_set_map(
+      #     gen_IF( gen_bin_op(
+      #               "=",
+      #               gen_record_field(  gen_plainname('a'), Constants::FIELD_NAME_ADDRESS),
+      #               sender_account
+      #             ),
+      #             gen_EXCEPT( "a",
+      #                         gen_bin_op("=",
+      #                                    gen_record_field(  "!", Constants::FIELD_NAME_BALANCE),
+      #                                    gen_bin_op(
+      #                                      "-",
+      #                                      gen_record_field( 'a', Constants::FIELD_NAME_BALANCE),
+      #                                      gasValue
+      #                                    ))),
+      #             gen_plainname('a')),
+      #     gen_set_iterate( "a", g_ethAccounts_exec ))        
+        
+      #   s(
+      #     # eth_gasUsed += intrinsicGas
+      #     gen_traced_stmt(
+      #       g_assignOnStack( g_ethGasUsed_temp, 
+      #                   gen_bin_op(  '+', g_ethGasUsed_exec,  gasValue )),
+      #       s( "SVC-exec@#{interfaceName}: credit  #{TlaElementText::FW_STATE_GAS_USED} with value for #{TlaElementText::ETH_OPEATOR_INTRINSIC_GAS}", gasValue )
+      #     ),
+
+
+      #     # eth_accounts := { IF a.account = i.sender THEN [ a EXCEPT !.balance = a.balance - instrinc ]  ELSE a : a \in eth_accounts }
+      #     gen_traced_stmt(
+      #       g_assignOnStack( g_ethAccounts_temp, accountsUpdated ),
+      #       s( "SVC-exec@#{interfaceName}: debit sender account", sender_account, "with gasValue", gasValue )
+      #     ),
+
+      #     ##
+      #     # make changes perament so that they persist rollback
+
+      #     gen_traced_stmt(
+      #       gen_assign( g_ethGasUsed, g_ethGasUsed_exec ),
+      #       s( "SVC-exec@#{interfaceName}: persist credit  #{TlaElementText::FW_STATE_GAS_USED}", gasValue )
+      #     ),
+
+      #     gen_traced_stmt(
+      #       gen_assign( g_ethAccounts, g_ethAccounts_exec ),
+      #       s( "SVC-exec@#{interfaceName}: persist debit sender account", sender_account  )            
+      #     ),
+          
+      #   )
+      # end
+
+      def g_persist()
+        
+        s(
+          # gen_traced_stmt(
+          #   gen_assign( g_ethGasUsed, g_ethGasUsed_exec ),
+          #   s( "SVC-exec@#{interfaceName}: persist #{TlaElementText::FW_STATE_GAS_USED}" )
+          # ),
+
+          gen_traced_stmt(
+            gen_assign( g_ethAccounts, g_ethAccounts_exec ),
+            s( "SVC-exec@#{interfaceName}: persist #{TlaElementText::FW_STATE_ACCOUNTS}" )
+          ),
+          
+        )
+      end
+      
+      
+
+      # Call servicve procedure
+      def g_serviceExec( interfaceName, service_formal_parameter_name )
+        s(
+          
+          # call procecedure implementing procedule
+          gen_traced_stmt( 
+            gen_procedure_call(gen_specname(:solidity_contract_function, interfaceName  ), s(gen_identifier(service_formal_parameter_name))),
+            s( "TX-start@#{interfaceName}: call call service implementation", gen_str(gen_specname(:solidity_contract_function, interfaceName )) )
+          ),
+        )
+      end
+
+      ##
+      # Allways true i.e. TRUE
+      def g_TRUE
+        gen_TRUE
+      end
+
+      ## 
+      # Operator call to check that recipient account non nil. NOTICE
+      # called from entry macro, and must use 'g_ethAccounts'
+      def g_RecipientAccountExists( service_formal_parameter_name )
+        gen_bin_op(
+          "#",
+          gen_record_field(  gen_identifier(service_formal_parameter_name), Constants::FIELD_NAME_RECIPIENT),
+          gen_nilElement
+        )
+        
+      end
+
+      ##
+      # Operator call to check that recipient contract exists
+      def g_RecipientContractExists( bindAddress )
+        bindAddress = gen_record_field( gen_identifier(service_formal_parameter_name), Constants::FIELD_NAME_RECIPIENT) if bindAddress.nil?
+        gen_operator_call(
+          TlaElementText::FW_OP_ELEMENT_EXISTS,
+          s( g_storageRoot_exec,
+             gen_str( Constants::FIELD_NAME_ADDRESS ),
+             bindAddress,
+           ))
+      end
+
+
+      # Possible to start transaction?
+      #
+      # - if non constror we require that g_RecipientAccountExists
+      # - in any case
+      #     -- sender must account must exist
+      #     -- senaer account holds enough balance
+
+      def g_serviceExecValidity( service_formal_parameter_name, isConstructor )
+        
+        condition =
+            gen_and(
+              # Check account for sender exists
+              gen_operator_call(
+                TlaElementText::FW_OP_ELEMENT_EXISTS,
+                s( g_ethAccounts,
+                   gen_str( Constants::FIELD_NAME_ADDRESS ),
+                   gen_record_field(  gen_identifier(service_formal_parameter_name), Constants::FIELD_NAME_SENDER),
+                 )),
+              # Sender has enough balance in eth_account
+              gen_bin_op(
+                ">=",
+                gen_record_field(
+                  gen_operator_call(
+                    TlaElementText::FW_OP_GET_ELEMENT,
+                    s(
+                      g_ethAccounts, 
+                      gen_str( Constants::FIELD_NAME_ADDRESS ),
+                      gen_record_field(  gen_identifier(service_formal_parameter_name), Constants::FIELD_NAME_SENDER)
+                    )),
+                  Constants::FIELD_NAME_BALANCE
+                ),
+                # to cover upfront cost
+                gen_operator_call( TlaElementText::ETH_OPEATOR_UP_FRONT_COST, gen_identifier(service_formal_parameter_name))
+              )
+            )
+            
+            
+
+        # # additional check to ensure that recipent not nil - if non constructor
+        if !isConstructor then
+          condition = gen_and( g_RecipientAccountExists(service_formal_parameter_name), condition )
+        end
+        
+        condition
+      end
+
+
+      # If 'codeHash' of account entry in 'g_ethAccounts_exec'
+      # identified by 'parameterName.recipient' is among
+      # 'contracts.typeName'.
+      #
+      # @param [ContractDefinition:Array] contracts
+      # @param [String] paramterName
+      def g_dispatcherCondition( contracts, parameterName )
+        
+        # if_condition:
+        list_of_contracts = contracts.inject( s() ) do |s,contractDefinition|
+          s << gen_str(contractDefinition.typeName)
+          s
+        end
+        
+        if_confidition = gen_set_iterate(
+          gen_record_field(
+            gen_operator_call(
+              TlaElementText::FW_OP_GET_ELEMENT,
+              s( g_ethAccounts_exec,
+                 gen_str( Constants::FIELD_NAME_ADDRESS ),
+                 gen_record_field( parameterName, Constants::FIELD_NAME_RECIPIENT)
+               )),
+            Constants::FIELD_NAME_CODE_HASH
+          ),
+          gen_set( gen_list( list_of_contracts ))
+        )
+
+        if_confidition          
+
+      end
+        
+        
+
+      ##
+      # Populate address fields for external call
+      def g_procCallAddresses( g_current_formal_input )
+          s(
+            gen_record_field_definition(
+              Constants::FIELD_NAME_SENDER, 
+              gen_record_field(  g_current_formal_input, Constants::FIELD_NAME_SENDER)),
+            gen_record_field_definition(
+              Constants::FIELD_NAME_ORIGINATOR, 
+              gen_record_field(  g_current_formal_input, Constants::FIELD_NAME_ORIGINATOR)),
+          )
+      end
+
+      def g_procCallValue( constantValue=0 )
+        s(gen_record_field_definition(
+            Constants::FIELD_NAME_VALUE,
+            gen_constant( constantValue )))
+      end
+      ##
+      # create new entry to 'ethStorageRoot'
+      def g_newEntryToStorageRoot( interfaceName, contractFields )
+        s( 
+          gen_traced_stmt(
+            gen_assignOnTop(
+              g_storageRoot_temp, 
+              gen_bin_op( '\union', gen_set(gen_record_definition(contractFields)), g_storageRoot_exec )
+            ),
+            s("SVC-exec@#{interfaceName}: create contract entry to #{TlaElementText::FW_STATE_STORAGE_ROOT_TEMP}")
+          )
+        )
+      end
+
+      # @return [s(record_field_definition)] record field defintion
+      # bind for common message parameters (recipient, sender,
+      # originator)
+      def g_commonMsgParameters( specname_input_variable, recipientTla )
+        s(
+          gen_record_field_definition( Constants::FIELD_NAME_RECIPIENT,
+                                       recipientTla ),
+          gen_record_field_definition( Constants::FIELD_NAME_SENDER,
+                                       g_localCurrentAccountId ),
+          gen_record_field_definition( Constants::FIELD_NAME_ORIGINATOR,
+                                       gen_record_field( specname_input_variable, Constants::FIELD_NAME_ORIGINATOR )),
+        )
+      end
+
+      ##
+      # @return InfrastructureServiceGetResponse( "personal_newAccount()" )
+      def g_readNewAccountId
+        gen_operator_call(
+          TlaElementText::OP_INFRA_GET_RESPONSE,
+          gen_str( gen_service_name(TlaElementText::SERVICE_ACCOUNT_NEW))
+        )
+      end
+
+      ##
+      # @param [stla] newAddress Nil|address of recipient to create
+      #
+      # @return call 'eth_personal_newAccount( [ codeHash |-> "Demo2", address |-> Nil|address ])'
+      def g_createNewAccount( interfaceName, contractName, newAddress )
+        # s(
+        # gen_procedure_call(
+        #   gen_specname( setMetatype(:eth), TlaElementText::INTERFACE_ACCOUNT_NEW),
+        #   gen_record_definition(
+        #     gen_record_field_definition(
+        #       TlaElementText::TLA_RECORD_FIELD_FOR_SINGLE_VALUE,
+        #       # use quotes around contractName
+        #       gen_str(contractName) ))
+        # )
+        # )
+        s( 
+          gen_traced_stmt( 
+            gen_procedure_call(
+              gen_specname( setMetatype(:eth), TlaElementText::INTERFACE_ACCOUNT_NEW),
+              gen_record_definition(
+                s(
+                  gen_record_field_definition( Constants::FIELD_NAME_CODE_HASH, contractName ),
+                  gen_record_field_definition( Constants::FIELD_NAME_ADDRESS, newAddress )
+                ))),
+            s("SVC-exec@#{interfaceName}: call '#{TlaElementText::INTERFACE_ACCOUNT_NEW}' to create new account entry")
+          )
+        )
+      end
+
+      ##
+      # Put sender address to a well known place stored in stack
+      # locals := 'g_IdRval'
+      def g_copyCurrentAccountIdToLocals( g_IdRval )
+        s( 
+          gen_assign( TlaElementText::TLA_LOCALS_VARIABLE, g_IdRval ),
+        )
+      end
+
+      #
+      # @param [String] appLocalName in in application domain
+      # @return [sTla] tlaName for 'appLocalName'
+      def g_locaVariableName( appLocalName )
+        gen_identifier( appLocalName )
+      end
+
+      ##
+      # It is in 'locals' variable
+      #
+      # @see g_copyCurrentAccountIdToLocals
+      #
+      def g_localCurrentAccountId
+        # gen_record_field(gen_interface_input_variable_name( interfaceName ), Constants::FIELD_NAME_RECIPIENT )
+        # gen_identifier( TlaElementText::TLA_LOCALS_VARIABLE )
+        g_locaVariableName( TlaElementText::TLA_LOCALS_VARIABLE )
+      end
+
+      # Constant to set to 'responses.status'      
+      def g_statusOk
+        gen_operator_call(TlaElementText::TLA_SERVICE_STATUS_OK)
+      end
+
+      # Initial value to set to 'responses.status', something wrong,
+      # if abort seen on return
+      def g_statusAbort
+        gen_operator_call(TlaElementText::TLA_SERVICE_STATUS_ABORT)
+      end
+      
+      # Constant to set to 'responses.status'
+      def g_statusFail
+        gen_operator_call(TlaElementText::TLA_SERVICE_STATUS_FAIL)
+      end
+
+      ##
+      # SvcReturn( "interfaceName()", status, getRespons("interfaceName()"))
+      def g_updateReturnStatus( interfaceName, status )
+        gen_operator_call(
+            TlaElementText::OP_INFRA_RETURN,
+            s(gen_str(interfaceName ),
+              status,
+              gen_operator_call( TlaElementText::OP_INFRA_GET_RESPONSE, gen_str(interfaceName ))))
+      end
+
+      ##
+      # last step in service procesure, just sets status, withoun modifying response value.
+      #
+      # infraReturn( "Demo()", OK, infraRespons( "Demo"))
+      def g_ServiceReturn( interfaceName, status=g_statusOk  )
+        s( 
+          gen_traced_stmt(
+            g_updateReturnStatus( interfaceName, status ),
+            s( "SVC-exec@#{interfaceName}: set return status", status )
+          )
+        )
+      end
+
+      ##
+      # Service procedure starting - push stack
+      def g_svcStackEnter( interfaceName, serviceName )
+        s(
+          gen_label,
+          gen_traced_stmt( 
+            # gen_labeled_stmt(
+              gen_macro_call( TlaElementText::TLA_SERVICE_PUSH ),
+            #   serviceName, "_push"
+            # ),
+            s( "SVC-exec@#{interfaceName}: init return status", g_statusAbort )))
+      end
+
+      # # E.g. infraReturn( "Demo()", Nil, Nil )
+      # def g_ServiceReturnInit( interfaceName )
+      #   s( gen_traced_stmt( 
+      #        gen_operator_call(
+      #          TlaElementText::OP_INFRA_RETURN,
+      #          s( gen_str(interfaceName ), g_statusAbort, gen_nilElement )),
+      #        s( "SVC-exec@#{interfaceName}: init return status", g_statusAbort )))
+      # end
+
+      ##
+      # last step - returs account id created && set status OK
+      def g_constructorReturn( interfaceName )
+        s(
+          # ServiceReturn( "Demo()", 0, new-account-id )
+          gen_traced_stmt(
+            gen_operator_call(
+              TlaElementText::OP_INFRA_RETURN,
+              s(gen_str(interfaceName ), g_statusOk, g_localCurrentAccountId )),
+            s( "SVC-exec@#{interfaceName}: set return status", g_statusOk,  "return account id created", g_localCurrentAccountId )
+          )
+            
+        )
+      end
+
+      # def g_procedureCall( g_procedure, g_params )
+      #   gen_procedure_call(
+      #     g_procedure,
+      #     gen_record_definition( g_params )
+      #   )
+      # end
+
+      # Goto abort label in 'interfaceName' procedure
+      def g_abort( interfaceName, serviceName )
+        gen_goto( gen_interface_abort_label( interfaceName, serviceName ))
+      end
+
+      ##
+      # Goto fail label (afte) user code should check for errors
+      def g_fail( interfaceName, serviceName )
+        gen_goto( gen_interface_fail_label( interfaceName ) )
+      end
+      
+      def g_end( interfaceName, serviceName, status )
+        s(
+          gen_labeled_stmt(
+            g_updateReturnStatus( interfaceName, status ),
+            gen_specname(:solidity_contract_function, interfaceName ),
+            "call_construct"
+          ),
+          gen_goto( gen_interface_end_label( interfaceName )),
+        )
+      end
+
+      # Geneate code to dispatch a call to 'functionCalled' with
+      # 'parameters'. After the call, a jump to abort label in
+      # 'interfaceName'/'serviceName' is called function resulted to
+      # abort.
+      #
+      # Use direct call to 'functionCalled.interfaceName', if
+      # 'findMethodsToDispatch' returns a singleton method, else call
+      # dispatcher macro, also returned by 'findMethodsToDispatch'.
+      def g_dispatch_call( functionCalled, parameters, interfaceName, serviceName )
+
+        dispatcherName, methodsToDispatch = findMethodsToDispatch( functionCalled )
+
+        if methodsToDispatch.length == 1 then
+          # only one function to consider
+          called = gen_specname( :solidity_contract_function, functionCalled.interfaceName )
+          s(
+            gen_procedure_call( called, parameters  ),
+            g_abortCheckIncall( interfaceName, serviceName, functionCalled.interfaceName)
+          )
+        else
+          
+          # multiple functions - check status of all of the function
+          # (assumes that dispatcher macro resets statuses )
+          if_condition = gen_FALSE
+          
+          methodsToDispatch.map do |methodToDispatch|
+            methodToDispatch[:function].interfaceName
+          end.uniq.each do |interfaceName|
+            if_condition =
+              gen_bin_op( '\\/',
+                          if_condition,
+                          g_abortedInCall( interfaceName )
+                        )
+          end
+          if_block = s( g_abort(  interfaceName, serviceName ))
+          
+          s(
+            gen_label_it(gen_macro_call( g_dispatcher(dispatcherName), parameters )),
+            gen_if( if_condition, if_block )
+
+           )
+        end
+      end
+
+      # Geneate code to read response from 'functionCalled'.
+      #
+      # If 'functionCalled' is implemented by just one contract, the
+      # is done using a simple 'InfrastructureServiceGetResponse' call
+      # for functionCalled.interfaceName. If 'functionCalled' is
+      # implemented in serveral contracts, we take the result from
+      # where 'InfrastructureServiceGetStatus' is not Nil.
+
+      
+      def g_dispatch_read_return( functionCalled )
+        logger.debug  "#{__method__}: functionCall:#{functionCalled}" if logger.debug?
+
+        dispatcherName, methodsToDispatch = findMethodsToDispatch( functionCalled )
+        if methodsToDispatch.length == 1 then
+          
+          readReturn = gen_operator_call( TlaElementText::OP_INFRA_GET_RESPONSE, gen_str( functionCalled.interfaceName ))
+        else
+          
+          actions = methodsToDispatch.map do |methodToDispatch|
+            methodToDispatch[:function].interfaceName
+          end.uniq.map do |interfaceName|
+            {
+              :condition => gen_bin_op( '#', gen_operator_call( TlaElementText::OP_INFRA_GET_STATUS, gen_str(interfaceName)), gen_nilElement ),
+              :action => gen_operator_call( TlaElementText::OP_INFRA_GET_RESPONSE, gen_str(interfaceName )),
+            }
+          end
+
+          # reverse array - last 
+          readReturn = actions.reverse.inject( actions.last[:action] ) do |m,a|
+            r = gen_IF( a[:condition], a[:action], m )
+            r
+          end
+
+          # raise "Not yet implemeteded"
+        end
+        readReturn 
+
+      end
+
+      def g_abortedInCall( called_interfaceName )
+        gen_bin_op("=",g_statusAbort, gen_operator_call( TlaElementText::OP_INFRA_GET_STATUS, gen_str(called_interfaceName)))
+      end
+
+      ## 
+      # Jump to 'g_abort('interfaceName', 'serviceName' )' -label if
+      # 'g_abortedInCall( called_interfaceName )'
+      def g_abortCheckIncall( interfaceName, serviceName, called_interfaceName )
+        gen_if( g_abortedInCall( called_interfaceName ), g_abort(interfaceName, serviceName ))
+      end
+
+      ##
+      # @param [stla] newAddress Nil|address of recipient to create
+      #
+      # consrructo - user in constructor and for message call to
+      # undefined recipient
+      def g_construct( interfaceName, contractName, contractExp, newAddress )
+        # call personal_newAccounts(  [ dummy |-> 'Demo' ] )
+        g_createNewAccount(interfaceName, contractName, newAddress) +
+          
+          # locals := ReadResponse('Demo') 
+          g_copyCurrentAccountIdToLocals(g_readNewAccountId) + 
+          
+          # eth_storageRoot := storage \union [ f1 |-> val1, ...]
+          g_newEntryToStorageRoot( interfaceName, u_initContractFields(contractExp)) 
+        
+      end
+
+      ## 
+      # Common code for constructor and normal method call
+      #
+      def g_serviceProcedurePreamble( interfaceName, serviceName, specname_input_variable, isContract )
+
+        # specname_input_variable = gen_interface_input_variable_name( interfaceName )
+        
+        # ether balance of sender - on block stack
+        sender_balance = gen_record_field(
+          gen_operator_call(
+            TlaElementText::FW_OP_GET_ELEMENT,
+            s( g_ethAccounts_exec, 
+               gen_str( Constants::FIELD_NAME_ADDRESS ),
+               gen_record_field( specname_input_variable, Constants::FIELD_NAME_SENDER )
+             )),
+          Constants::FIELD_NAME_BALANCE)
+
+        # needed value == tx-gas*gas-price + msg.value
+        value_needed_expr =
+          gen_parenthesis(gen_bin_op(
+            '+',
+            g_gasToValue( gen_operator_call( TlaElementText::ETH_OPEATOR_TRANSACTION_GAS)),
+            gen_record_field( specname_input_variable, Constants::FIELD_NAME_VALUE)))
+
+        request_value_expr = gen_record_field( specname_input_variable, Constants::FIELD_NAME_VALUE)
+
+        account_id_sending   =  gen_record_field( specname_input_variable, Constants::FIELD_NAME_SENDER )
+
+
+        # Return( "Demo()", Nil, Nil )
+        # TODO remove - unecassary
+        # g_ServiceReturnInit( interfaceName ) + 
+          
+          # ( isContract ? g_useIntrinsicGas( interfaceName, specname_input_variable  ) : s()) +
+          ( isContract ? g_persist() : s() ) + 
+          
+          g_svcStackEnter( interfaceName, serviceName ) +
+
+          # model non-deterministic choice of out of gas 
+          s(
+            gen_traced_stmt(
+              gen_either( gen_skip, g_abort( interfaceName, serviceName )),
+              s( "SVC-exec@#{interfaceName}: non-deterministic out-of-gas-check" )
+            )
+          ) + 
+
+          ( isContract ?
+              s(                      
+                # if eth_account[send].balance < transactionGas goto abort
+                gen_traced_stmt( 
+                  gen_if(
+                    gen_bin_op(  "<", sender_balance, value_needed_expr ),
+                    gen_traced_stmt(
+                      g_abort( interfaceName, serviceName ),
+                      s( "SVC-EXEC#{interfaceName}: abort" ) # then 
+                    )),
+                  s(
+                    "SVC-exec@#{interfaceName}: check sender balance >= #{TlaElementText::ETH_OPEATOR_GAS_VALUE}(#{TlaElementText::ETH_OPEATOR_TRANSACTION_GAS}) + #{Constants::FIELD_NAME_VALUE}",
+                    gen_record_field( specname_input_variable, Constants::FIELD_NAME_SENDER ),
+                    "balance", sender_balance,
+                    "value needed", value_needed_expr,
+                  ) # trace message
+                ),
+
+                # goto requires a label here
+                # gen_labeled_stmt( gen_skip, specname_functionName, "_value_checked" ),
+                gen_skip,
+            
+              ) # s
+            : s()
+          ) # isContract?
+      end
+
+
+      ##
+      # Move value to 'account_receiving_value' (new account in
+      # constructor, recipient in normal call) from
+      # 'account_id_sending' (=sender).
+      #
+      # Implementation notice: no need to do anything if
+      # 'account_receiving' == 'account_sending'. As a matter of fact,
+      # the code used to do the actual move would result to
+      # duplicating the balance.
+      #
+      # @param [SexpTla] account_id_receiving_value defines account recveiving value
+      # 
+      # @return [Sexp:Array] statements to start for the procedure
+      def g_serviceProcedureMoveValue( interfaceName, specname_input_variable, account_id_receiving_value )
+        
+        request_value_expr = gen_record_field( specname_input_variable, Constants::FIELD_NAME_VALUE)
+        account_id_sending   =  gen_record_field( specname_input_variable, Constants::FIELD_NAME_SENDER )
+        
+        s(
+          # eth_accounts[receiver].balance += request.value
+          # eth_accounts[sender].balance -= request.value
+          # move 'value' from account 'input.send' to new account ()
+          gen_if(
+            gen_bin_op( "#", account_id_sending, account_id_receiving_value), 
+            # gen_traced_stmt(           
+              gen_assignOnTop(
+                g_ethAccounts_temp, 
+                gen_set_map(
+                  gen_IF(
+                    gen_bin_op(
+                      "=",
+                      gen_record_field(  'a', Constants::FIELD_NAME_ADDRESS),
+                      account_id_receiving_value
+                    ),
+                    gen_EXCEPT( "a",
+                                gen_bin_op("=",
+                                           gen_record_field(  "!", Constants::FIELD_NAME_BALANCE),
+                                           gen_bin_op(
+                                             "+",
+                                             gen_record_field( "a", Constants::FIELD_NAME_BALANCE),
+                                             request_value_expr
+                                           ))),
+                    gen_IF(
+                      gen_bin_op(  "=",
+                                   gen_record_field(  'a', Constants::FIELD_NAME_ADDRESS),
+                                   account_id_sending) ,
+                      gen_EXCEPT( "a",
+                                  gen_bin_op(
+                                    "=",
+                                    gen_record_field(  "!", Constants::FIELD_NAME_BALANCE),
+                                    gen_bin_op(
+                                      '-',
+                                      gen_record_field( "a", Constants::FIELD_NAME_BALANCE),
+                                      request_value_expr 
+                                    )
+                                  )),
+                      'a')),
+                  gen_set_iterate( "a", g_ethAccounts_exec ))
+              ),
+            #   s( "SVC-exec@#{interfaceName}: move value", request_value_expr, "from sender", account_id_sending, "to receiving", account_id_receiving_value ),
+            # ),
+          ),
+          gen_traced_stmt(
+            gen_skip, s("SVC-exec@#{interfaceName}: moved value" )
+          )
+        )
+      end
+
+      ##
+      # 
+      def g_gasToValue( gas )
+        gen_operator_call(TlaElementText::ETH_OPEATOR_GAS_VALUE, gas )
+      end
+      
+
+      ##
+      # @return [Sexp:Array] statements to end the procedure
+      def g_serviceProcedureEpilogue( interfaceName, serviceName, specname_input_variable )
+        s(
+          # Skip with label so that state changes generated here do
+          # not interfere with rest of the code
+          gen_label,
+        )
+
+        # expr_transaction_gasValue = g_gasToValue(gen_operator_call( TlaElementText::ETH_OPEATOR_TRANSACTION_GAS))
+        
+        # # specname_accounts = gen_specname(:eth, TlaElementText::FW_STATE_ACCOUNTS)
+        
+        # s(
+        #   # Skip with label so that state changes generated here do
+        #   # not interfere with rest of the code
+        #   gen_label,
+          
+        #   # increment 'eth_gasUsed' for running the transaction
+        #   gen_traced_stmt(
+        #     gen_assignOnTop(g_ethGasUsed_temp,  gen_bin_op( '+', g_ethGasUsed_exec, expr_transaction_gasValue )),
+        #     s( "SVC-exec@#{interfaceName}: credit '#{TlaElementText::ETH_OPEATOR_TRANSACTION_GAS}' for transaction gas value",  expr_transaction_gasValue )
+        #   ),
+          
+        #   # decreas gasUsed from sender account
+        #   gen_traced_stmt( 
+        #     gen_assignOnTop(
+        #       g_ethAccounts_temp, 
+        #       gen_set_map(
+        #         gen_IF(
+        #           gen_bin_op( "=", gen_record_field(specname_input_variable, Constants::FIELD_NAME_SENDER), gen_record_field( "a", Constants::FIELD_NAME_ADDRESS ) ),
+        #           gen_EXCEPT(
+        #             'a',
+        #             gen_bin_op( "=",
+        #                         gen_record_field("!", Constants::FIELD_NAME_BALANCE),
+        #                         gen_bin_op( "-", gen_record_field( "a", Constants::FIELD_NAME_BALANCE ), expr_transaction_gasValue ) )),
+        #           'a'),
+        #         gen_set_iterate("a", g_ethAccounts_exec ))
+        #     ),
+        #     s( "SVC-exec@#{interfaceName}: debit sender", gen_record_field(specname_input_variable, Constants::FIELD_NAME_SENDER), "for transaction gas value", expr_transaction_gasValue )
+        #   ),
+        # )
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Utilities
+
+      def g_zero
+        gen_plainname('0')
+      end
+
+      #
+      # @return [Hash:Array] params
+      # @option params [:Symbol] :name
+      def u_functionParameters( functionDecl )
+        functionDecl.parameterList.parameters.map { |param|   { :name => param.name } }
+      end
+
+      def u_initValue( typeName )
+        TlaElementText.solIsNumericType(typeName) ? g_zero : gen_nilElement
+      end
+
+      def u_initContractFields( contractExp )
+        contractExp.contractVariables.map do |v|
+          logger.debug "#{__method__}: contract variable=#{v}" if logger.debug?
+                        
+          # process VariableDeclaration
+          if v.name == Constants::FIELD_NAME_ADDRESS
+            # access return from 'newAccount'
+            { :name => v.name, :value=> g_readNewAccountId }
+          else
+            if v.isMapping then
+              
+              # mapping variable input domain name e.g. d_eth_address
+              inputDomainName = v.typeSexp.mapFrom.domainReference.domainName
+              # numeric solidity types init with  0, default to use Nil
+              # initialValue = TlaElementText.solIsNumericType(v.typeSexp.mapTo.typeName) ? gen_plainname('0') : gen_nilElement
+              initialValue = u_initValue( v.typeSexp.mapTo.typeName )
+              
+              
+              #  e.g. [ i \in d_eth_address |-> Nil ] or  [ i \in d_eth_address |-> 0 ]
+              initMapping = gen_record_definition(
+                gen_record_field_definition(
+                  gen_set_iterate( 'a',
+                                   gen_specname( setMetatype(Sbuilder::Facade::META_MODEL_DOMAINS), inputDomainName )),
+                  initialValue )
+              )
+              {
+                :name => v.name,
+                :value => initMapping,
+              }
+            else
+              { :name => v.name, :value => u_initValue( v.typeSexp.typeName ) }
+            end
+          end
+        end.inject( s() ) do |memo,nv|
+          memo << gen_name_op_operand( nv[:name], "|->", nv[:value] )
+          memo
+        end
+      end
+
+
+      
+          
+        
+      
+      # @!endgroup      
+
+    end
+
+    # This created in plugin
+    class SexpProcessorTla < SexpProcessorTlaRoot
+
+
+      # Constant to initialize partials hash. Particularly, add
+      # mapping for :Snippet TLA generate element sexp_type, because
+      # snippets are not processed by #elementGenerator, which is
+      # responsible for adding mapping entries.
+      PARTIALS = {
+        
+        :Snippet => <<-EOS.unindent, 
+        (* {|metatype|}:{|appName|}{|# comment |} - {|{ comment }|}{|/ comment |} *)
+        {|#snippet|}{|#EVAL|}.{|/EVAL|}{|/snippet|}
+        EOS
+      }
+
+      # @attr [Hash] baseMetatypes implement in 'sbuilder' framework
+      # can be referenced in TLA translation
+      attr_reader :baseMetatypes
+
+      # ------------------------------------------------------------------
+      # @!group Recusion parameters
+
+      # @attr [STla] specname_input_variable
+      attr_accessor :specname_input_variable
+
+      # @attr [String] interfaceName
+      attr_accessor :interfaceName
+
+      # @attr [String] serviceName
+      attr_accessor :serviceName
+
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group Construct & configure
+      
+      def initialize( metatypes, options={} )
+        super( options )
+        
+        # Init partial for snippets , which are not found in SexpAst
+        @partials = PARTIALS
+        @collectedSnippetNames = []
+        @collectedSnippets = []
+        @collectedInterfaces = []
+        @collectedDefintions = []
+
+        logger.info "#{__method__} init-metatypes #{metatypes}"
+        # allow access to  frame work metatypesa
+        setBaseMetatypes( metatypes )
+
+        # gen_x method + adds partials 
+        initElementGenerator
+
+        # load only once
+        loadFixedSnippets
+        loadEthereumSnippets
+        
+      end
+
+      # configure +baseMetatypes+ in sbuilder immediatelly after constructuor
+      #
+      # @param [Hash] baseMetatypes
+      # @option baseMetatypes [:Symbol] :name
+      # @option baseMetatypes [:Symbol] :desc      
+      private def setBaseMetatypes( metatypes )
+        @baseMetatypes = metatypes
+        logger.debug( "#{__method__}: baseMetatypes=#{baseMetatypes}" ) if logger.debug?        
+      end
+
+      private def initElementGenerator
+
+        # gen_* methods delegated here
+        @elementGenerator = TlaElementGenerator.new( options )
+        @elementGenerator.setPartials( partials )
+        @elementGenerator.setValidMetatypes( validMetatypes )        
+        
+      end
+      
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Scoped
+
+      # @attr [Contract] currentContract which currently processing
+      attr_accessor :currentContract
+
+      def contracted( expContract )
+
+        self.currentContract = expContract
+        begin
+          yield
+        ensure
+          self.currentContract = nil
+        end
+      end
+
+      # @!endgroup      
+      
+
+      # ------------------------------------------------------------------
+      # @!group Routines to build module result
+
+      # @attr [Hash] partials mapping tla generate sexp to mustache
+      # template, created in this module
+      attr_reader :partials
+
+      ##
+      # Return partials created in #process -method.
+      #
+      # @return [Hash] partials mapping TLA generate element sexp:s to
+      # mustache partial strings for rendering TLA generate element.
+      def getPartials
+        logger.info "#{__method__}: partials.keys=#{partials.keys.join(',')}"
+        partials
+      end
+
+      # Add 'snippet' to '@collectedSnippets' unless it is already defined in '@collectedSnippetNames'
+      def addSnippet( snippet )
+        logger.debug "#{__method__}: snippet=#{snippet}" if logger.debug?
+        if ! @collectedSnippetNames.include?( snippet.snippetId )
+          logger.info "#{__method__}: added metatype='#{snippet.metatype}' appName='#{snippet.name}', specName '#{snippet.specName}': #{snippet.comment}"
+          @collectedSnippets << snippet
+          @collectedSnippetNames << snippet.snippetId
+        else
+          logger.info "#{__method__}: duplitac snippet ='#{snippet.snippetId} - not added"
+        end
+      end
+
+      
+      # @return [Snippets] snippets to pass to snippet loader plugin
+      def snippets
+        Snippets.new( @collectedSnippets )
+      end
+      
+      def addInterface( interface )
+        logger.info "#{__method__}: interfaceDefinition=#{interface.interfaceDefinition}"
+        @collectedInterfaces << interface
+      end
+
+      # @return [Interface:Array] interfaces to pass to api loader plugin
+      def interfaces
+        Interfaces.new( @collectedInterfaces )
+      end
+      
+
+      def addDefinition( definition )
+        logger.info "#{__method__}: definition=#{definition}"
+        @collectedDefintions << definition
+      end
+      
+      # @return [Definition:Array] definitiosn to pass to api loader plugin
+      def definitions
+        Definitions.new( @collectedDefintions )
+      end
+
+
+      ## 
+      # Include +domainName+ to TLA specicification code
+      def addDomainName( domainName )
+        logger.info "#{__method__}: domainName=#{domainName}"
+        @domainNames ||= []
+        @domainNames << Domain.s(domainName)
+      end
+
+      ##
+      # Add 'domainValue' to 'domainName'
+      def addDomainValue( domainName, domainValue )
+        logger.info  "#{__method__}: #{domainName} value= #{domainValue}" 
+        domain = domainNames.find { |d| d.domainName == domainName }
+        raise "Unknow domain #{domainName} - known domains #{domainNames.join(',')}" if domain.nil?
+        # Just add it to list
+        domain << domainValue
+      end
+
+      ##
+      # @return [String:Array] domainNames to define in TLA specification code
+      def domainNames
+        @domainNames ||= []
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------      
+      # @!group Access specialized sexp processor
+      
+      def getFunctionBodyProcessor
+        proc = FunctionBodyProcessor.new( self, elementGenerator, options )
+        # Move context to processeos
+        proc.interfaceName = interfaceName
+        proc.serviceName = serviceName
+        proc.currentContract = currentContract
+        proc.specname_input_variable = specname_input_variable
+        proc
+      end
+
+      def getFunctionLocalsProcessor
+        proc = FunctionLocalsProcessor.new( elementGenerator, options )
+        # Move context to processeos
+        # proc.interfaceName = interfaceName
+        # proc.serviceName = serviceName
+        # proc.specname_input_variable = specname_input_variable
+        proc
+      end
+      
+
+      # @!endgroup      
+
+      # ------------------------------------------------------------------
+      # @!group Metatype management and utilities
+
+      ##
+      # @return [Hash] metatypes for ethreum loader
+      def metatypes
+        TlaElementText::METATYPES
+      end
+
+      ##
+      # Return cached valid metatypes, whica are +baseMetatypes+ and
+      # +metatypes+ for ethereum loader plugin
+      # 
+      # @return [Hash] validMetatypes
+      # @option [Symbol] :name metatype name
+      # @option [Symbol] :desc metatype description
+      def validMetatypes
+        # baseMetatypes :name/:desc array mapped to a hash
+        raise "Should have called setBaseMetatypes earlier" if baseMetatypes.nil?
+        @validMetatypes ||= baseMetatypes.inject( metatypes.clone ) {|memo,mt| memo[mt[:name]] = mt[:desc]; memo }
+      end
+
+
+      ##
+      # This method needs to sync with the name created when api
+      # loader plugin loads interface for the +function+.
+      #
+      # @param [String] function appName (in application domain)
+      #
+      # @return [String] intrefaceName +function+ postfixed with '()'
+      #
+      ##
+      # Pass +metatype+ trough, and ensure that it exists in
+      # +validMetatypes+ i.e. in +metatypes+ defined in this module, and
+      # in +baseMetatypes+ defined by sbuilder framework
+     
+      def setMetatype( metatype )
+        raise SbuilderEtherumException, <<-EOS unless validMetatypes.key?( metatype )
+        Unknown metatype '#{metatype}' type '#{metatype.class}'
+
+        Known metatypes: #{validMetatypes.keys.join(',')}
+
+        EOS
+                                          
+        metatype                                          
+      end
+      
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Load once
+      
+      # Create constant (technical) base snippets, which do not have
+      # any connection to TLA translation
+      def loadFixedSnippets
+        logger.debug "#{__method__}: starts" if logger.debug?        
+        TlaElementText.fixedSnippetSpecs.each do |snippetDef|
+
+          # :metatype, :appName, :specName, :body|:file
+          
+          metatype = snippetDef[:metatype]
+          appName = snippetDef[:appName]
+          # nil --> allow sbuilder to generate name
+          specName = snippetDef[:specName]
+          logger.debug "#{__method__}: metatype=#{metatype}, appName=#{appName}" if logger.debug?
+          raise "Must give :body, :file, :specName #{snippetDef}" unless snippetDef[:body] || snippetDef[:file] || snippetDef[:specName]
+          text = snippetDef[:body] ? snippetDef[:body] : snippetDef[:file] ? File.read( File.join( File.dirname(__FILE__), "../../resources/", snippetDef[:file] )) : nil
+          bodySpec =  gen_free_text( text ) if text
+          logger.debug "#{__method__}: text=#{text}" if logger.debug?
+          addSnippet(
+            Snippet.new( metatype, appName, bodySpec, specName, snippetDef[:comment] )
+          )
+
+        end
+      end
+
+      ##
+      # Load Ethreum environment domains,snippet, and interfaces into
+      # sbuilder context.
+      def loadEthereumSnippets
+        logger.debug "#{__method__}: starts" if logger.debug?        
+        
+        TlaElementText.ethereumSnippetSpecs.each do |spec|
+          # run lamdba ':snipetType' and pass parameters ':definition'
+          # instance_exec( spec[:definition], &SNIPPETLOADERS[spec[:snipetType]] )
+          instance_exec( spec, &TlaElementText.getLoaderLamdba( spec ))
+        end
+      end
+
+      # ------------------------------------------------------------------
+      # @!group Entry point & return the generated snippets
+
+
+      # @return [Domains] domains Sexp, with domain -property
+      def process_SourceUnit( exp )
+        logger.info "#{__method__}: starting with '#{exp}"
+
+        # # gen_* methods delegated here
+        # @elementGenerator = TlaElementGenerator.new( options )
+        # @elementGenerator.setPartials( partials )
+        # @elementGenerator.setValidMetatypes( validMetatypes )        
+        
+        # traverse tree and create  Sexps for snippets & interfaces
+        results = process_rest( exp  )
+        logger.debug "#{__method__}, results=#{results}" if logger.debug?
+
+        # add snippets to framework
+        # loadFixedSnippets
+        # loadEthereumSnippets
+
+        results
+      end
+
+      def process_GlobalScope( exp )
+        logger.debug "#{__method__}: starting with '#{exp}" if logger.debug?
+
+        # # Create snippets and interfaces for all ':FunctionDefinition' in top-scope
+        # exp.globalScope.symbolDefinitions.
+        #   select { |globalExp| globalExp.sexp_type == :FunctionDefinition }.
+        #   each { |expFunction| loadGlobalFunction( expFunction ) }
+        process_rest( exp )
+
+        s()
+      end
+      
+
+      def process_ContractDefinition( exp )
+        logger.debug "#{__method__}: exp=#{exp}" if logger.debug?
+
+        # Need to know contract names in 'eth_code_hash'. Used for
+        # example to define type invariant for valid contract types
+        addDomainValue( Constants::DOMAIN_CODE_HASH, exp.name )
+
+        # add a (function) type definition for mapping variables
+        exp.contractVariables.each do |variable|
+          if variable.isMapping
+            name = TlaElementText.compositeDefinitionName( exp, variable )
+            mappings = variable.typeSexp.maps.inject( s() ) do |memo, elementaryType|
+              memo << s( :parameter, elementaryType.typeName, elementaryType.domainReference.domainName )
+              memo
+            end
+            addDefinition( Definition.define( name, mappings, :function ) )
+          end
+        end
+        
+        # contract type definition with record fields corresponding contract variables
+        contractVariableFields =
+          exp.contractVariables.inject( s() ) do |memo,variable|
+          if variable.isMapping
+            # mapping variables refer function type definition created separately
+            compositeName = TlaElementText.compositeDefinitionName( exp, variable )            
+            memo << s( :reference, variable.name, compositeName )            
+          else
+            memo << s( :parameter, variable.name, variable.domainReference.domainName )
+          end
+          memo
+        end
+        addDefinition( Definition.define( exp.name, contractVariableFields) )
+
+        # wrap & recurse
+        contracted( exp ) do
+          process_rest( exp  )
+        end
+
+      end
+
+
+      # Dummy operation - needed because default `process_skip` expect
+      # that each 'process_' -function return either valid data or
+      # empty array.
+      def process_Mapping( exp )
+        s()
+      end
+
+      
+      def process_FunctionDefinition( exp )
+        logger.debug "#{__method__}: start=#{exp}" if logger.debug?        
+
+        # should set 'constructor'/'method-call'
+        messageType = "unknow-function-definition"
+
+        # extract context
+        contractExp = exp.enclosing_scope
+        contractName = contractExp.name
+        functionName = exp.name
+        logger.info "#{__method__}: contractExp=#{contractExp}, contractName=#{contractName}, functionName=#{functionName}"
+
+        # context helpers
+        isContract  = contractExp.sexp_type == :ContractDefinition
+        isConstructor = functionName == contractName ? true : false
+
+
+        # processor context
+        self.interfaceName = exp.interfaceName
+        self.serviceName = gen_specname(:solidity_contract_function, interfaceName )        
+        # genenerator defined constants
+        specname_serviceName  = gen_service_name( contractName )
+        self.specname_input_variable = gen_interface_input_variable_name( interfaceName )
+
+        # --------------------
+        # Body block statements
+
+        # Contructor & normal function differ 
+        if isConstructor
+          # constructor: default constructor + any user specific code
+          messageType = true # 'constructor'
+
+          account_id_receiving_value =  g_readNewAccountId
+          
+          stmts =
+            g_serviceProcedurePreamble( interfaceName, serviceName, specname_input_variable, isContract) +
+            
+            g_construct( interfaceName, gen_str(contractName), contractExp, gen_nilElement ) + 
+
+            g_serviceProcedureMoveValue( interfaceName, specname_input_variable, account_id_receiving_value ) +
+            s(
+              gen_traced_stmt(
+                gen_labeled_stmt( gen_skip, gen_specname(:solidity_contract_function, interfaceName ), "_body"),
+                s("SVC-exec@#{interfaceName}: process constructor body" )
+              )
+            ) + 
+            getFunctionBodyProcessor.process( exp.block ) +
+            g_constructorReturn( interfaceName ) + 
+            g_serviceProcedureEpilogue( interfaceName, serviceName, specname_input_variable )
+          content = "Constructor for contract #{interfaceName}'"
+        else
+          # 'normal' public method-call 
+          messageType = false # 'method-call'
+          account_id_receiving_value = gen_record_field( specname_input_variable, Constants::FIELD_NAME_RECIPIENT )
+          stmts =
+            g_serviceProcedurePreamble( interfaceName, serviceName, specname_input_variable, isContract ) +
+            # locals := x3_demo_input.recipient 
+            g_copyCurrentAccountIdToLocals(gen_record_field(specname_input_variable, Constants::FIELD_NAME_RECIPIENT )) +
+            (
+              isContract ?
+              s(
+                # conctract function called for non existing contract
+                gen_if(
+                  gen_not( gen_operator_call(
+                             TlaElementText::FW_OP_ELEMENT_EXISTS,
+                             s(
+                               g_ethAccounts,
+                               gen_str( Constants::FIELD_NAME_ADDRESS), 
+                               gen_record_field( specname_input_variable, Constants::FIELD_NAME_RECIPIENT ))
+                           )),
+                  g_construct( interfaceName, gen_nilElement, contractExp, account_id_receiving_value ) +
+                  g_serviceProcedureMoveValue(interfaceName, specname_input_variable, account_id_receiving_value )+
+                  g_end( interfaceName, serviceName, g_statusOk )
+                )
+              )  :
+              # non contract ie. GlobalScope function called - no need to create contract
+                s()
+            ) + 
+            ( isContract ?
+                s(
+                  # correct type
+                  gen_if(
+                    gen_bin_op(
+                      '\/',
+                      gen_not(g_RecipientContractExists(g_localCurrentAccountId)),
+                      gen_bin_op(
+                        "#",
+                        gen_str(contractName), 
+                        gen_record_field(
+                          gen_operator_call(
+                            TlaElementText::FW_OP_GET_ELEMENT,
+                            s(
+                              g_ethAccounts_exec, 
+                              gen_str( Constants::FIELD_NAME_ADDRESS ),
+                              g_localCurrentAccountId
+                            )
+                          ),
+                          Constants::FIELD_NAME_CODE_HASH),
+                      )),                                  
+                    gen_traced_stmt( g_abort( interfaceName, serviceName ), "SVC-exec@#{interfaceName}: wrong type")
+                  )
+                ) :
+                s(gen_label)
+            ) + 
+            g_serviceProcedureMoveValue( interfaceName, specname_input_variable, account_id_receiving_value ) +
+            getFunctionBodyProcessor.process( exp.block ) + 
+            # s(process_rest( exp.statements )) +
+            ( isContract ? g_serviceProcedureEpilogue( interfaceName, serviceName, specname_input_variable ) : s( gen_label )) +
+            g_ServiceReturn( interfaceName )
+          
+          
+          content = "Service procedure for #{interfaceName}"
+        end
+
+        logger.debug "#{__method__} stmts=#{stmts}" if logger.debug?
+
+        # --------------------
+        # Local variables
+
+        localVariablesExps = getFunctionLocalsProcessor.process( exp.block )
+        localVariables =
+          s(g_localCurrentAccountId) +
+          localVariablesExps.map do |varDecl|
+          g_locaVariableName( varDecl.name )
+        end 
+        logger.info "#{__method__}: localVariables=#{localVariables} in in function #{exp.name}, localVariablesExps=#{localVariablesExps} "
+        
+        
+        # --------------------
+        # Create snippet for function procedure
+
+        addSnippet(
+          Snippet.new(
+          setMetatype(:solidity_contract_function), interfaceName,
+          gen_service_procedure(
+            gen_specname( :solidity_contract_function, interfaceName),
+            interfaceName,
+            localVariables, 
+            gen_stmts(serviceProcedureLabelStatements(
+                        stmts,
+                        gen_specname(:solidity_contract_function, interfaceName )
+                      )) # gen_stmts
+          ), nil, content )
+        )
+
+        # --------------------
+        # Service entry macro for contract function (only if contract function)
+
+        if isContract 
+          # Create service entry macro for Solidity contract function  (not for global scope)
+          #
+          # macro call 'contract_function' procedure if 'serviceExecValidity'
+          service_formal_parameter_name = 'par'        
+          addSnippet(
+            Snippet.new(
+            setMetatype(Sbuilder::Facade::META_MODEL_SERVICE_IMPLEMENTATION), interfaceName,
+            gen_macro(
+              gen_specname( Sbuilder::Facade::META_MODEL_SERVICE_IMPLEMENTATION, interfaceName ),
+              s(gen_plainname( service_formal_parameter_name )),
+              gen_stmts(
+                s(
+                  gen_traced_stmt(
+                    
+                    # X_temp := <<X>>;
+                    gen_macro_call(
+                      TlaElementText::TLA_SERVICE_START,
+                    ),
+                    s( "TX-start@#{interfaceName}: push block state to stack" )
+                  ),
+                  
+                  gen_traced_stmt(
+                    gen_if(
+                      g_serviceExecValidity(service_formal_parameter_name, isConstructor),
+                      g_serviceExec(interfaceName, service_formal_parameter_name),
+                    ),
+                    s( "TX-start@#{interfaceName}: check pre-conditions",
+                       "1) sender account exists",
+                       "2) sender balance>= #{TlaElementText::ETH_OPEATOR_UP_FRONT_COST}",
+                       !isConstructor ? "3) receive account non nil" : ""
+                     )
+                  )
+                ) # s
+              )
+            ),
+            nil, # specname
+            "Service entry for #{interfaceName}"
+          ))
+
+          # Map 'service-completion' on interface to fixed specName
+          # 'TLA_SERVICE_COMPLETION', which implements transaction
+          # semantics in TLA code.
+          addSnippet(
+            Snippet.new(
+            setMetatype(Sbuilder::Facade::META_MODEL_SERVICE_COMPLETION), interfaceName, nil,
+            TlaElementText::TLA_SERVICE_COMPLETION, # specname
+            "Macro called when #{interfaceName} completes"
+          ))
+
+        end # if contract
+
+        # --------------------
+        # Function dispatcher
+          
+        # check inheritance hierarchy && create dispatcher macro 
+        dispatcherName, methodsToDispatch = findMethodsToDispatch( exp  )
+        addDispatcherSnippet( dispatcherName, methodsToDispatch )
+
+        # --------------------
+        # Interface
+        
+        # Define an interface for a function +functionName+ in
+        # contract +contractName+.  Contructor name f(+contractName+),
+        # non constructor name f(+contractName+, +functionName+)
+        #
+        #
+        addInterface(
+          Interface.define(
+          contractName,              
+          isConstructor ? "" : functionName, 
+          # request parameters + common parameters
+          exp.parameterList.parameters.map do |param|
+            raise "Domain reference not resolved on #{param}" unless param.domainReference
+            s( :parameter, param.name, param.domainReference.name )
+          end,  # + TlaElementText.commonMsgProperties( 'request', messageType ),
+          #  response paremeters + common parameters
+          exp.returnList.parameters.map do |param|
+            raise "Domain reference not resolved on #{param}" unless param.domainReference
+            s( :parameter, param.name, param.domainReference.name )
+          end  + TlaElementText.commonMsgProperties( 'response', messageType ), 
+        )) # addInterface
+
+        # clear processor context
+        self.specname_input_variable = nil
+        self.interfaceName = nil
+        self.serviceName = nil
+        s()
+      end
+
+      # @!endgroup
+      # ------------------------------------------------------------------
+      # @!group Helpers to create service procesure
+
+
+      # Create snippet with 'dispatcherName'. Uses addSnippet method
+      # in top level tla processor
+      #
+      #
+      # @param [Hash:Array] methodsToDispatch
+      # @option methodsToDispatch [:Symbol] :contracts array of ContractDefinition
+      # @option methodsToDispatch [:Symbol] :function FunctionDefinition       
+
+      private def createDispatcherSnippet( dispatcherName, methodsToDispatch )
+
+      end
+
+      # Find data structure to manage dispatching of 'funtionSexp'.
+      #
+      # @param [FunctionDefinition] funtionSexp
+      #
+      # @return [String], [Hash:Array] dispatcherName, methodNameImplementations
+      # 
+      # @option methodNameImplementations [:Symbol] :contracts array
+      # of ContractDefinition serviced by :function
+      #
+      # @option methodNameImplementations [:Symbol] :function
+      # FunctionDefinition
+      def findMethodsToDispatch( funtionSexp  )
+        logger.debug "#{__method__}: funtionSexp=#{funtionSexp}" if logger.debug?
+        raise "Invalid type #{funtionSexp.sexp_type} in #{funtionSexp}" unless funtionSexp.sexp_type == :FunctionDefinition
+        
+        methodName = funtionSexp.name
+        currentContract = funtionSexp.contractDefinition
+        
+        logger.info  "#{__method__}: create dispatcher data structure for #{currentContract.name}.#{methodName}" 
+        
+        # inhertitanceHierarchy is a hash mapping typeName ->
+        # [ContractDefinition:Array] for each contract in inherintance
+        # hierarhcy of 'currentContract'
+        inhertitanceHierarchy  = currentContract.rootSymbol.allDerivedTypes( InheritanceSort.new )
+        logger.debug  "#{__method__}: inhertitanceHierarchy=#{inhertitanceHierarchy.inject({}) { |m,(k,v)| m[k] = v.map { |a| a.typeName}; m }}" if logger.debug?                    
+
+        # topologically sorted functionNames in inhertitance hierarchy 
+        sortedInheritanceHierarchy = inhertitanceHierarchy.tsort
+        logger.debug  "#{__method__}: sortedInheritanceHierarchy=#{sortedInheritanceHierarchy.join(',')}" if logger.debug?          
+        
+        dispatcherName = "#{currentContract.rootSymbol.name}_#{methodName}"
+
+        seenContracts = {}
+        # iterate 'contractNames' in inhiritance order
+        methodNameImplementations = sortedInheritanceHierarchy.map do |contractName|
+          # contract for 'contractName' from 'inhertitanceHierarchy'
+          contract = inhertitanceHierarchy[contractName].select { |inheritsContractDefintition| inheritsContractDefintition.typeName == contractName }.first
+          {
+            :contract => contract,
+            :contracts => inhertitanceHierarchy[contractName],
+            :function => contract.resolve( methodName ),
+          }
+        end.select do |methodNameImplementation|
+          # accept only contracts, which implementing 'methodName'
+          methodNameImplementation[:contract].getSymbol( methodName )
+        end.map do |methodNameImplementation|
+          # use first entry for a contract
+          methodNameImplementation[:contracts] = methodNameImplementation[:contracts].reject { |c| seenContracts.key?( c.name )  }
+          seenContracts[methodNameImplementation[:contract].name] = true
+          methodNameImplementation
+        end
+
+        raise "Could not find any implementation for '#{methodName}' in #{sortedInheritanceHierarchy.join(',')}"  unless methodNameImplementations.any?
+
+        # logger.debug  "#{__method__}: methodNameImplementations=#{methodNameImplementations.join(',')}" if logger.debug?                    
+        
+        logger.info "#{__method__}: implementing dispatcherName=#{dispatcherName}, methodName '#{methodName}' =#{methodNameImplementations.map { |i| i[:function].interfaceName + '(' + i[:contracts].map{|c| c.name }.join(',')+ ')'  }.join('; ')}" if logger.debug?
+        return dispatcherName, methodNameImplementations
+      end
+
+      # Create macro 'dispatcherName' to dispatch 'methodsToDispatch',
+      # and pass it to 'addSnippets'. Optimization: if array
+      # 'methodsToDispatch' length is 0, no need dispatcher macro is
+      # made (method dispatching is replaced with direct method call,
+      # and accessing response status/data can are simple calls.
+      #
+      # @param [Hash:Array] methodsToDispatch
+      # @option methodsToDispatch [:Symbol] :contracts array ContractDefinition
+      # @option methodsToDispatch [:Symbol] :function FunctionDefinition
+      
+      def addDispatcherSnippet( dispatcherName, methodsToDispatch )
+
+        # optimization
+        return if methodsToDispatch.length == 1
+
+        parameterName = 'rec'
+        
+        
+        bodyStmts =
+          s(
+            # init all responses
+            gen_assign( TlaElementText::OP_INFRA_RESPONSES, TlaElementText::OP_INFRA_STATUS_INIT ),
+            generateMethodDispatch( methodsToDispatch, parameterName ),
+          )
+        
+        body =
+          gen_macro(
+            g_dispatcher(dispatcherName), parameterName,
+            gen_stmts( bodyStmts )
+          )
+
+        # define snippet, and add it main tla processor
+        snippet = Snippet.new( g_dispatcherMeta, dispatcherName, body )
+        addSnippet( snippet )
+      end
+
+      #
+      # @param [Hash:Array] methodsToDispatch
+      # @option methodsToDispatch [:Symbol] :contracts array ContractDefinition
+      # @option methodsToDispatch [:Symbol] :function FunctionDefinition       
+      #
+      # @param [sTla] parameterName name of input parameter to the snippet
+      #
+      # @return [sTla:Array] dispatch statement if the
+      #
+      private def generateMethodDispatch( methodsToDispatch, parameterName )
+
+        # process first here, tail recursion on rest
+        contracts = methodsToDispatch.first[:contracts]
+        function = methodsToDispatch.first[:function]          
+
+        if_condition = g_dispatcherCondition( contracts, parameterName )
+
+        if_block = s(
+          gen_procedure_call( gen_specname( :solidity_contract_function, function.interfaceName ), parameterName )
+        )
+
+        # tail recursion on 'methodsToDispatch'
+        if methodsToDispatch.length == 1
+          gen_if( if_condition, if_block, gen_assert( "FALSE", "Unkwon interface" ))
+        else
+          gen_if( if_condition, if_block,  generateMethodDispatch( methodsToDispatch[1..-1], parameterName))
+        end
+      end
+        
+
+      ##
+      # Add label #{labelPrefix}_#{index} to statements in 'stmts' array
+      # recursively in 'labelBlockStatements'
+      #
+      # Add label when:
+      # - for the first statement in the list (start a procedure)
+      # - previous statement (sexp_type) requires a label
+      # - recurse down to :labelBlockStatements  statements
+      #
+      private def serviceProcedureLabelStatements( stmts, labelPrefix )
+        stmts, index = serviceProcedureLabelStatementsWorker( stmts, labelPrefix, 0, 0, true )
+        stmts
+      end
+
+      ##
+      # @return [Array, index] stmts as passed as input, index incremented
+      private def serviceProcedureLabelStatementsWorker( stmts, labelPrefix, index, level, labelFirst )
+        stmts.each_with_index do |stmt,i|
+
+          # prev stamement in current block
+          prevStmt = stmts[i-1] if i > 0 
+          # puts "#{' ' * level } - #{level}: #{labelPrefix[1][:specname][:appName]}-#{index} #{stmts[i][0]}"
+          if labelFirst || !prevStmt.nil? && requiresLabelAfter( prevStmt )
+            stmts[i] = gen_labeled_stmt( stmt, labelPrefix, index )
+            # puts "#{' ' * level } - #{level}: --> label #{labelPrefix[1][:specname][:appName]}-#{index} #{stmt[0]}"            
+            index += 1
+          end
+          labelFirst = false
+
+          # then & while>?
+          if stmt.respond_to?( :labelBlockStatements )
+            # recursion 
+            s, index = serviceProcedureLabelStatementsWorker( stmt.labelBlockStatements, labelPrefix, index, level+1, false )
+          end
+
+          # else block
+          if stmt.respond_to?( :labelBlockStatementsElse )
+            # recursion 
+            s, index = serviceProcedureLabelStatementsWorker( stmt.labelBlockStatementsElse, labelPrefix, index, level+1, false )
+          end
+          
+          
+        end
+        return stmts, index
+      end
+
+      # @!endgroup      
+
+
+      # ------------------------------------------------------------------
+      # @!group Specialized processeros
+
+      #
+      #
+      class FunctionBodyProcessor < SexpProcessorTlaRoot
+
+        def initialize( tlaProcessor, elementGenerator, options )
+          super( options )
+          @tlaProcessor = tlaProcessor
+          @elementGenerator = elementGenerator
+
+          # initially no variables assigned within this body
+          self.variablesAssigned = {}
+        end
+
+        # @attr [SexpProcessorTla] tlaProcessor collecting snippets
+        attr_accessor :tlaProcessor
+
+        # @attr [Contract] currentContract which currently processing
+        attr_accessor :currentContract
+
+        # @attr [STla] specname_input_variable
+        attr_accessor :specname_input_variable
+
+        # @attr [String] interfaceName e.g. Demo(send)
+        attr_accessor :interfaceName
+
+        # @attr [String] serviceName
+        attr_accessor :serviceName
+
+
+        # ------------------------------------------------------------------
+        # @!group Access specialized sexp processor
+
+        def getFunctionBodyProcessor
+          proc = FunctionBodyProcessor.new( tlaProcessor, elementGenerator, options )
+          # Move context to processor
+          proc.interfaceName = interfaceName
+          proc.serviceName = serviceName
+          proc.currentContract = currentContract
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+
+        def getRvalProcessor
+          proc = RvalExprProcessor.new( tlaProcessor, elementGenerator,options)
+          proc.interfaceName = interfaceName
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+
+        def getFunctionCallProcessor( actualParameters )
+          proc = FunctionCallProcessor.new( tlaProcessor, elementGenerator, options )
+          # Move context to processeos
+          proc.interfaceName = interfaceName
+          proc.serviceName = serviceName
+          proc.currentContract = currentContract
+          proc.actualParameters = actualParameters
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+        
+        def getLvalProcessor( rval )
+          proc = LvalExprProcessor.new( tlaProcessor, elementGenerator, options )
+          proc.rval = rval
+          proc.bodyProcessor  = self
+          proc.interfaceName = interfaceName
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group Lval interface
+
+        # @attr [Hash] variablesAssigned
+        attr_accessor :variablesAssigned
+        
+        # Maintain list of variables assigned in lval processes. If
+        # assigining twice to same variable instruct to create a
+        # label, and reset variables being assigned
+        #
+        # @return [Boolean] true if lval processor should label
+        # assigment statement
+        def shouldUseLabelToAssignTo( variableName )
+          if variablesAssigned.key?( variableName )
+            self.variablesAssigned = {
+              variableName => true
+            }
+            ret = true
+          else
+            self.variablesAssigned[variableName] = true
+            ret = false
+          end
+          logger.debug "#{__method__}: variableName: #{variableName} should have label=#{ret}" if logger.debug?
+          ret
+        end
+        
+        # @!endgroup
+        # ------------------------------------------------------------------
+        # @!group Process sexp nodes
+
+        ##
+        # Concatenate statements together
+        def process_Block( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?          
+
+          # s( s(for statement) s())
+          stmsArra = process_rest( exp )
+          stmsArra.flatten(1)
+          
+        end
+
+        def process_IfStatement( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          
+          stmts = s()
+
+          # condition
+          condition = getRvalProcessor.process( exp.condition )
+          logger.debug  "#{__method__}: condition=#{condition}" if logger.debug?          
+          thenBlock = getFunctionBodyProcessor.process( exp.then_branch )
+          logger.debug  "#{__method__}: thenBlock=#{thenBlock}" if logger.debug?                    
+          elseBlock = getFunctionBodyProcessor.process( exp.else_branch ) if exp.else_branch
+
+          stmts << gen_if( condition, thenBlock, elseBlock )
+          logger.debug  "#{__method__}: stmts=#{stmts}" if logger.debug?
+          stmts          
+        end
+
+
+        def process_Throw( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          stmts = s()
+
+          logger.info "#{__method__}: abort-interfaceName=#{interfaceName}"
+          # stmts << gen_traced_stmt(
+          #     g_updateReturnStatus( interfaceName, g_statusFail ),
+          #     s( "SVC-exec@#{interfaceName}: return status", g_statusFail )
+          # )
+
+          stmts << g_fail( interfaceName, serviceName )
+          # stmts << gen_traced_stmt(
+          #   g_fail( interfaceName, serviceName ),
+          #   s( "SVC-exec@#{interfaceName}: throw goes to fail label which set FALSE return" )
+          # )
+          stmts
+        end
+
+        # Within Block  inteprete 'VariableDefinitionStatement' like 'Assignment'
+        def process_VariableDefinitionStatement( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          rval =  getRvalProcessor.process(exp.rval)
+          logger.debug "#{__method__}: assigning-rval=#{rval}" if logger.debug?
+
+          stmts = getLvalProcessor(rval).process( exp.lval )
+
+          logger.debug  "#{__method__}: stmts=#{stmts}" if logger.debug?          
+          stmts
+          
+        end
+
+        # @return [Sexp] s() wrapping statements for assignments
+        def process_Assignment( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          raise "Operator '#{exp.operator}' not supported in #{exp}" unless exp.operator == '='
+
+          # find rval
+          rval =  getRvalProcessor.process(exp.rval)
+          logger.debug "#{__method__}: assigning-rval=#{rval}" if logger.debug?
+
+
+          stmts = getLvalProcessor(rval).process( exp.lval )
+          # stmts << LvalExprProcessor.new(elementGenerator, options).process( exp.rval )          
+
+          logger.debug  "#{__method__}: stmts=#{stmts}" if logger.debug?          
+          stmts
+        end
+
+        ##
+        # In :Functioncall 'functionExpression' is either
+        # ':NewExpression' or ':MemberAccess'. tla-statemts for these
+        # two cases created using FunctionCallProcessor.
+        def process_FunctionCall( exp )
+          logger.debug  "#{__method__}: start #{exp}" if logger.debug?
+
+          # find acual parameters
+          
+          logger.debug  "#{__method__}: exp.actualParameters=#{exp.actualParameters}" if logger.debug?
+          actualParameters = exp.actualParameters.map.with_index do |expression,i|
+            # returnVariableDecl = exp.functionReturnParameter( i )
+            # retExpr = getRvalProcessor.process( expression )
+            # gen_bin_op( "|->", returnVariableDecl.name, retExpr )
+            getRvalProcessor.process( expression )
+          end
+          logger.debug  "#{__method__}: rval-actualParameters=#{actualParameters}" if logger.debug?          
+          
+
+          # create call
+          
+          logger.debug  "#{__method__}: exp.functionExpression=#{exp.functionExpression}" if logger.debug?          
+          # callStmts = self.process( exp.functionExpression )
+          callStmts = getFunctionCallProcessor(actualParameters).process( exp.functionExpression )
+          logger.info "#{__method__}, callStmts=#{callStmts}"
+          callStmts
+        end
+
+        def process_FunctionCallReadReturn( exp )
+          logger.debug  "#{__method__}: start #{exp}" if logger.debug?
+          # no operation because return wraps in return statment &&
+          # expression original function call, which is split up in
+          # canonization phase
+          s()
+        end
+
+        # Return 'status' and 'return.expressions' from procedure modeling 'inferfaceName'
+        def process_Return( exp )
+          stmts = s()
+          retRvals = exp.expressions.map.with_index do |expression,i|
+            # returnVariableDecl = exp.functionReturnParameter( i )
+            # retExpr = getRvalProcessor.process( expression )
+            # gen_bin_op( "|->", returnVariableDecl.name, retExpr )
+            getRvalProcessor.process( expression )
+          end
+          # using 'g_statusFail' here because success is flagged only
+          # after all statements processed successfully
+          stmts << gen_operator_call(
+            TlaElementText::OP_INFRA_RETURN,
+            s( gen_str(interfaceName), g_statusFail,  retRvals.first ) )
+          # assign to function return list 
+          # stmts << gen_debug_msg( "JUST from getter" )
+          stmts          
+        end
+
+        # @!endgroup
+
+        
+      end # FunctionBody
+
+      # Resolve local variable in function
+      #
+      class FunctionLocalsProcessor < SexpProcessorTlaRoot
+
+        # @attr [VariableDeclaration:Array] localVariables
+        attr_accessor :localVariables
+
+        # ------------------------------------------------------------------
+        # @!group Construct & configure
+
+        def initialize( elementGenerator, options )
+          super( options )
+          @elementGenerator = elementGenerator
+          
+          # ignore unknown nodes
+          self.default_method = :process_none
+
+          self.localVariables = s()
+        end
+
+        # @!endgroup
+        
+
+        # ------------------------------------------------------------------
+        # @!group Wrap scopes
+
+        # @attr [VariableDefinitionStatement] currentDeffi
+        attr_accessor :currentDeffi
+
+        def deffed( expDeffi )
+          prevDeffi = currentDeffi
+          self.currentDeffi = expDeffi
+          begin
+            yield
+          ensure
+            self.currentDeffi = prevDeffi
+          end
+
+        end
+
+        # @!endgroup        
+
+        # ------------------------------------------------------------------
+        # @!group Process nodes
+        
+        def process_Block( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          process_rest( exp )
+          localVariables
+        end
+
+        def process_VariableDefinitionStatement( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          deffed( exp ) do
+            process_rest( exp )
+          end
+          s()
+        end
+
+        def process_VariableDeclaration( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+
+          # localVariable declaration if within VariableDefinitionStatement
+          localVariables << exp if currentDeffi
+
+          s()
+        end
+
+        # @!endgroup                
+        
+      end # FunctionLocalsProcessor
+
+      class FunctionCallProcessor < SexpProcessorTlaRoot
+
+        # ----------
+        # set during initialize -phase
+
+        # @attr [SexpProcessorTla] tlaProcessor collecting snippets
+        attr_accessor :tlaProcessor
+        
+        # @attr [Contract] currentContract which currently processing
+        attr_accessor :currentContract
+
+        # @attr [STla] specname_input_variable
+        attr_accessor :specname_input_variable
+
+        # @attr [String] interfaceName
+        attr_accessor :interfaceName
+
+        # @attr [String] serviceName
+        attr_accessor :serviceName
+
+        # @attr [s(rval, rval)] actualParameters
+        attr_accessor :actualParameters
+
+        # ----------
+        # properties set process -method in this class 
+
+        # @attr [String:Array] functionOnFunctionMembers
+        attr_accessor :functionOnFunctionMembers
+        
+        # @attr [String:Array] functionOnFunctionMembers
+        attr_accessor :functionOnFunctionValues
+
+        def initialize( tlaProcessor, elementGenerator, options )
+          super( options )
+          @tlaProcessor = tlaProcessor
+          @elementGenerator = elementGenerator
+          self.functionOnFunctionMembers = []
+          self.functionOnFunctionValues = []
+        end
+
+        def_delegators :tlaProcessor,          # top level tla -processes
+                       :setMetatype,
+                       :findMethodsToDispatch
+
+        # ------------------------------------------------------------------
+        # @!group Access specialized sexp processor
+        
+        def getRvalProcessor
+          proc = RvalExprProcessor.new(tlaProcessor, elementGenerator,options)
+          proc.interfaceName = interfaceName
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+
+        # @!endgroup
+        
+        # ------------------------------------------------------------------
+        # @!group Process sexp nodes
+
+        # functionOnFunction case here
+        def process_FunctionCall( exp )
+          logger.debug  "#{__method__}: #{exp} in functionOnFunction" if logger.debug?
+          
+          actualParameters = exp.actualParameters.map.with_index do |expression,i|
+            # returnVariableDecl = exp.functionReturnParameter( i )
+            # retExpr = getRvalProcessor.process( expression )
+            # gen_bin_op( "|->", returnVariableDecl.name, retExpr )
+            getRvalProcessor.process( expression )
+          end
+          raise "Expect function on function actual parameters to equal 1, was #{actualParameters.length} in #{actualParameters.join(',')}" unless actualParameters.length == 1
+          self.functionOnFunctionValues << actualParameters.first
+          logger.debug  "#{__method__}: func-on-func-rval-actualParameters=#{actualParameters}" if logger.debug?          
+          
+          process( exp.functionExpression )
+          
+        end
+
+        ##
+        # We ended here to process the first 'MemberAccess' sexp in
+        # s(:FunctionCall, "bool", s(:MemberAccess, "send",
+        # s(:MemberAccess, "sender", s(:Identifier, "msg", "msg"))),
+        # s(:Literal, "int_const 1", "1"))))
+        #
+        # @see process_NewExpression
+        def process_MemberAccess( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+
+          ret = nil
+          if exp.isFunctionOnFunction
+            # AST in 'function on function' case, e.g. demo1.set.value(20)(
+            # 6 ) like s(:MemberAccess, "value", s(:MemberAccess, "set",
+            # s(:Identifier, "contract Demo1", "demo1")))
+            #
+            # we are processing s(:MemberAccess, "value", collect
+            # names so that we can consume actualParameters before
+            # binding formal parameters
+            self.functionOnFunctionMembers << exp.member_name
+            logger.info "#{__method__}: collected functionOnFunctionMembers=#{functionOnFunctionMembers.join(',')}"
+            ret = process( exp.memberStruct )
+          else
+            # implement function calll
+            ret = memberAccessAsFunctionCall( exp )
+          end
+          ret
+        end
+
+        # called by process_MemberAccess to create statements to make
+        # a function call
+        #
+        # @param [MemberAccess] exp in process_MemberAccess
+        private def memberAccessAsFunctionCall( exp )
+          
+          # context
+          functionCalled = exp.declationRef
+          called_interfaceName = functionCalled.interfaceName
+          # send gets message 'value' as actual parameter
+          valueAsActualParameter = [Constants::SOL_SEND].include?( functionCalled.name )
+          
+          recipientSexp = exp.memberStruct
+          logger.debug  "#{__method__}: dispatch a call to called=#{called_interfaceName}->#{functionCalled}/ recipient #{recipientSexp}}" if logger.debug?
+          logger.debug  "#{__method__}: functionOnFunctionMembers=#{functionOnFunctionMembers}" if logger.debug?            
+
+          # bind formal parameters with actual parameters in
+          # '@actualParameters'. 1) find [VariableDeclation] of formal
+          # parameters 2) bind actual parmeters in '@actualParameters'
+          formalParameters = functionFormalParameters( functionCalled, false, valueAsActualParameter )
+
+          # bind formal parameters with '@actualParameters'
+          formalParameterBinds = formalParameters.any? && formalParameters.map.with_index do |parameter,i|
+            gen_record_field_definition( parameter.name, actualParameters[i] )
+          end
+          formalParameterBinds = s() unless formalParameterBinds
+          logger.info "#{__method__}: functionCalled: #{functionCalled.name} formal parameters=#{ formalParameters.map.with_index{ |p,i| p.name + '->' + actualParameters[i].inspect } }"
+          
+
+          # generate code to access recipient
+          recipientTla = getRvalProcessor.process( recipientSexp )
+          logger.debug  "#{__method__}: recipientTla=#{recipientTla}" if logger.debug?          
+          
+          # find 'callValue' i.e. what is assigned to 'value' field 1)
+          # send function gets initial value as actual parameter 2) in
+          # functionOnFunction e.g. f.gas(2).value(20)() search
+          # 'functionOnFunctionMembers' and 'functionOnFunctionValues'
+          # to find value 3) use g_zero
+
+          if valueAsActualParameter
+            # send function
+            callValue = s()
+          else
+            # 3) default g_zero
+            callValueInit = g_zero 
+            functionOnFunctionMembers.each_with_index do |functionOnFunctionMember,i|
+              # 2) functionOnFunction case
+              callValueInit = functionOnFunctionValues[i] if functionOnFunctionMember == Constants::FIELD_NAME_VALUE
+            end
+            callValue = s( gen_record_field_definition( Constants::FIELD_NAME_VALUE, callValueInit ))
+          end
+
+          # actual call
+          logger.debug "#{__method__}: callValue=#{callValue.join(',')}, formalParameterBinds=#{formalParameterBinds.join(',')}" if logger.debug?
+
+          # call procedure with formal paremeters bound + common msg parameters set
+          parameters = gen_record_definition(
+            formalParameterBinds + 
+            g_commonMsgParameters( specname_input_variable, recipientTla ) +
+            callValue
+          )
+          
+
+          
+          stmts = s()
+            # goto abort unless called recipientTla address  exist
+          stmts << gen_if(
+            gen_not( g_RecipientContractExists( recipientTla )),
+            gen_traced_stmt(
+              g_abort(interfaceName, serviceName),
+                "SVC-exec@#{interfaceName}: abort because called address of contract does not exist" )
+            
+          )
+
+          g_dispatch_call( exp.declationRef, parameters, interfaceName, serviceName ).each { |s| stmts << s }
+          logger.debug  "#{__method__}: stmts=#{stmts}" if logger.debug?
+          
+          stmts
+          
+        end
+
+        ## 
+        # We ended here to process 'NewExpression' in s(:FunctionCall,
+        # "contract Demo1", s(:NewExpression, "function () returns
+        # (contract Demo1)", s(:UserDefinedTypeName, "Demo1")))'
+        #
+        # @see process_MemberAccess
+        def process_NewExpression( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          contructorFunctionDeclaration = exp.declationRef
+          logger.debug  "#{__method__}: contructorFunctionDeclaration=#{contructorFunctionDeclaration} for #{exp.type}" if logger.debug?          
+          
+          called_interfaceName = contructorFunctionDeclaration.interfaceName
+          called = gen_specname( :solidity_contract_function, called_interfaceName )
+          logger.debug  "#{__method__}: called= #{called}" if logger.debug?
+          s( 
+            gen_procedure_call(
+              called,
+              gen_record_definition(
+                g_procCallAddresses( specname_input_variable ) +
+                g_procCallValue)
+            ),
+            # abort checked without solidity dispatcher
+            g_abortCheckIncall( interfaceName, serviceName, called_interfaceName )
+          )
+        end
+        
+        # @!endgroup
+
+        # ------------------------------------------------------------------
+        # @!group FunctionCallProcessor utilities
+
+
+
+        # Abort 'interfaceName'/'serviceName' for if any of
+        # 'methodsToDispatch' aborts. Actually only one dispatched.
+        # TODO remove
+        # def addDispatcherStatusCheck( methodsToDispatch, interfaceName, serviceName  )
+        #   if_condition = gen_FALSE
+          
+        #   methodsToDispatch.map do |methodToDispatch|
+        #     methodToDispatch[:function].interfaceName
+        #   end.uniq.each do |interfaceName|
+        #     if_condition =
+        #       gen_bin_op( '\\/',
+        #                   if_condition,
+        #                   g_abortedInCall( interfaceName )
+        #                 )
+        #   end
+        #   if_block = s( g_abort(  interfaceName, serviceName ))
+        #   gen_if( if_condition, if_block )
+        # end
+
+        ##
+        # Formal parameters are all request parameters expect 'commonMsgproperties'
+        # An expection 'send' operation formal parameter include 'value'.
+        #
+        # @param [Boolean]  isConstructor
+        #
+        # @return [s(:VariableDeclaration)] formal parameters in 'functionSexp'
+        private def functionFormalParameters( functionSexp, isConstructor, valueAsActualParameter=false )
+          logger.debug  "#{__method__}: #{functionSexp}" if logger.debug?
+
+          commonMsgParameters =
+            TlaElementText.commonMsgProperties( 'request', isConstructor ).map { |sexp| sexp[1] }
+          logger.debug  "#{__method__}: commonMsgParameters=#{commonMsgParameters}" if logger.debug?
+          
+          formalParameters =
+            functionSexp.parameterList.parameters.
+            select do |parameter|
+            # accect request parameter if not in common 
+            !commonMsgParameters.include?( parameter.name ) ||
+              # OR 'send( value )'
+              ( valueAsActualParameter && parameter.name == Constants::FIELD_NAME_VALUE  )
+          end
+
+          logger.debug  "#{__method__}: formalParameters=#{formalParameters}" if logger.debug?          
+          formalParameters
+        end
+
+        # @!endgroup        
+
+        
+      end
+
+      class RvalExprProcessor < SexpProcessorTlaRoot
+        
+        def initialize( tlaProcessor, elementGenerator, options )
+          super( options )
+          @tlaProcessor = tlaProcessor
+          @elementGenerator = elementGenerator
+          # alert if new unknown nodes added
+          self.default_method = :process_abort
+          
+        end
+        
+        # @attr [String] interfaceName ie. function of the body:
+        # constructor 'Demo()' or function 'Demo(set)'
+        attr_accessor :interfaceName
+
+        # @attr [STla] specname_input_variable
+        attr_accessor :specname_input_variable
+
+
+        # @attr [SexpProcessorTla] tlaProcessor collecting snippets
+        attr_accessor :tlaProcessor
+
+        def_delegators :tlaProcessor,          # top level tla -processes
+                       :findMethodsToDispatch
+
+        # ------------------------------------------------------------------
+        # @!group Process sexp nodes
+
+
+        ##
+        # Rval which wraps function call - modeled as
+        # 'InfrastructureServiceGetResponse( "function" ) '
+        def process_FunctionCallReadReturn( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          functionCall = exp.functionCalled
+          g_dispatch_read_return( functionCall.functionExpression.declationRef )
+          # interfaceName = functionCall.functionExpression.declationRef.interfaceName
+          # logger.info  "#{__method__}: functionCall:#{functionCall} -> interfaceName=#{interfaceName}" 
+          # gen_operator_call(
+          #   TlaElementText::OP_INFRA_GET_RESPONSE,
+          #   gen_str( interfaceName )
+          # )
+        end
+
+        def process_UnaryOperation( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          tlaExpr = process( exp.expr )
+          opExpr  = TlaElementText.solcOperator2Tla(exp.operator)          
+          gen_unary_op( opExpr, tlaExpr )
+        end
+
+        def process_BinaryOperation( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          opExpr  = TlaElementText.solcOperator2Tla(exp.operator)
+          lhsExpr = process( exp.lhs )
+          rhsExpr = process( exp.rhs )
+          gen_bin_op( opExpr, lhsExpr, rhsExpr )
+        end
+
+        def process_Literal( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          # TODO: map 'Literl.value' to domain.value in 'exp.domainReference'
+          gen_plainname( exp.value )
+        end
+
+        def process_MemberAccess( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          variableDeclaration = exp.declationRef
+          resolvedDeclarationScope = variableDeclaration.scopeDefining
+          accessVariable( resolvedDeclarationScope, variableDeclaration.name )
+        end
+
+
+        def process_Identifier( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+          variableDeclaration = exp.declationRef
+          resolvedDeclarationScope = variableDeclaration.scopeDefining
+          accessVariable( resolvedDeclarationScope, variableDeclaration.name )
+        end
+
+        def process_IndexAccess( exp )
+          logger.debug  "#{__method__}: #{exp}" if logger.debug?
+
+          # variable being indexed
+          variableDeclaration = exp.identifier.declationRef
+          resolvedDeclarationScope = variableDeclaration.scopeDefining
+
+          # access 'normal' variable
+          variableToAccess = accessVariable( resolvedDeclarationScope, variableDeclaration.name )
+          logger.debug "#{__method__}: variableToAccess= #{variableToAccess}" if logger.debug?          
+          
+          # rval indexing the variable
+          indexerRval = process( exp.indexer )
+          logger.debug "#{__method__}: exp.indexer #{exp.indexer} index-rval=#{indexerRval}" if logger.debug?
+
+          # variableToAccess[indexerRval]
+          gen_record_named_field(  variableToAccess, indexerRval )
+          
+        end
+
+        # @!endgroup
+        
+        # ------------------------------------------------------------------
+        # @!group Utilities
+
+        private def accessVariable( resolvedDeclarationScope, variableAccess, accountId=g_localCurrentAccountId )
+          logger.debug "#{__method__}: variableAccess=#{variableAccess}, resolvedDeclarationScope=#{resolvedDeclarationScope[0]}:#{resolvedDeclarationScope[1]}" if logger.debug?
+          case resolvedDeclarationScope.sexp_type
+          when :ContractDefinition
+            # access 'variableAccess' on record in
+            # 'eth_StorageRoot' with using account id in 'locals',
+            # where account id is kept for constructor & normal message call
+            gen_record_field(
+              gen_operator_call(
+                TlaElementText::FW_OP_GET_ELEMENT,
+                s(
+                  g_storageRoot_exec,
+                  gen_str(Constants::FIELD_NAME_ADDRESS),
+                  accountId, 
+                  # gen_record_field(gen_interface_input_variable_name( interfaceName ), Constants::FIELD_NAME_RECIPIENT )
+                )),
+              variableAccess )
+          when :FunctionDefinition
+            # access 'variableAccess' in function local varibales
+            g_locaVariableName( variableAccess )
+          when :ParameterList
+            #   # access 'variableAccess' on input variable for 'interfaceName' procedure            
+            gen_record_field( gen_interface_input_variable_name( interfaceName ), variableAccess )
+          else
+            raise SbuilderEtherumException, "Missing implemtation for sexp_type #{resolvedDeclarationScope.sexp_type} for rValExpression"
+          end
+
+        end
+        # @!endgroup
+        
+      end # RvalExprProcessor
+      
+      class LvalExprProcessor < SexpProcessorTlaRoot
+
+        def initialize( tlaProcessor, elementGenerator, options )
+          super( options )
+          @tlaProcessor = tlaProcessor
+          @elementGenerator = elementGenerator
+        end
+
+        # @attr [SexpProcessorTla] tlaProcessor collecting snippets
+        attr_accessor :tlaProcessor
+
+        # @attr [FunctionBodyProcessor] bodyProcessor keeping tract of variables assigned
+        attr_accessor :bodyProcessor
+
+        # @attr [String] rval generate expression
+        attr_accessor :rval
+
+        # @attr [String] interfaceName ie. function of the body:
+        # constructor 'Demo()' or function 'Demo(set)'
+        attr_accessor :interfaceName
+
+        # @attr [STla] specname_input_variable
+        attr_accessor :specname_input_variable
+        
+
+        def getRvalProcessor
+          proc = RvalExprProcessor.new( tlaProcessor, elementGenerator,options)
+          proc.interfaceName = interfaceName
+          proc.specname_input_variable = specname_input_variable
+          proc
+        end
+        
+
+        # ------------------------------------------------------------------
+        # @!group Process nodes
+
+        #
+        # Assignin to a local variable 
+        def process_VariableDeclaration( exp )
+          logger.debug "#{__method__}: #{exp}" if logger.debug?
+          variableDeclaration = exp
+          stmts = s()
+          stmts << gen_assign( g_locaVariableName( exp.name ), rval )
+          stmts
+        end
+          
+        
+        # Shadows identifier!
+        def process_IndexAccess( exp )
+          logger.debug "#{__method__}: #{exp}" if logger.debug?
+          variableDeclaration = exp.identifier.declationRef
+
+          
+          # using 'local' variable to hold contract address
+
+          indexerRval = getRvalProcessor.process( exp.indexer )
+          logger.debug "#{__method__}: exp.lval-indexer  #{exp.indexer} index-rval=#{indexerRval}" if logger.debug?
+
+          lvalAccess = gen_record_named_field( variableDeclaration.name, indexerRval )
+          setExcept( lvalAccess, rval  )
+        end
+
+        ##
+        # Identifier: find identifier declaration and its scope,
+        # generate code. Generate code to set 'rval' for element
+        # identified by 'key'.
+        #
+        # Currently supports:
+        # - contract member variable: update eth_storageRoot with 
+        #
+        def process_Identifier( exp )
+          logger.debug "#{__method__}: #{exp}" if logger.debug?
+          variableDeclaration = exp.declationRef
+          lvalAccess = gen_identifier(variableDeclaration.name)
+          setExcept( lvalAccess, rval  )
+        end
+
+        # @!endgroup        
+        
+
+        # ------------------------------------------------------------------
+        # @!group Utils
+
+        ## 
+        # Generate code:
+        #
+        # var := { IF a.id = 'idValue' THEN [ a EXCEPT = !.a = 'value']  ELSE a: a \in var }
+        #
+        # @param [String] expectName name of variable to set
+        # @param [String] exceptValue to set
+        private def setExcept( expectName, exceptValue, idKey=g_localCurrentAccountId )
+          logger.debug "#{__method__}: expectName=#{expectName}, exceptValue=#{exceptValue}" if logger.debug?
+          # case resolvedDeclarationScope.sexp_type
+          # when :ContractDefinition
+          stmts = s()
+          variableToAssignTo = TlaElementText::FW_STATE_STORAGE_ROOT_TEMP
+          if bodyProcessor.shouldUseLabelToAssignTo( variableToAssignTo )
+            stmts << gen_label
+          end
+          # Updating contract in process for 'interfaceName'. Access contract address using address in local 'variable '
+          
+          stmts << gen_assignOnTop(
+            g_storageRoot_temp, 
+            gen_set_map(
+              gen_IF( gen_bin_op( "=", gen_record_field( 'a', Constants::FIELD_NAME_ADDRESS), idKey ),
+                      gen_EXCEPT(
+                        'a',
+                        gen_bin_op( '=',
+                                    gen_record_field("!", expectName),
+                                    exceptValue )), 'a' ),
+              gen_set_iterate( 'a', g_storageRoot_exec),
+            ))
+          stmts            
+        end
+
+        # @!endgroup
+        
+      end
+
+      # @!endgroup      
+
+    end # LvalExprProcessor
+
+
+  # ------------------------------------------------------------------
+  # @!group Helper class to implement tsort#strongly_connected_components
+    
+    class InheritanceSort < Hash
+
+      include TSort
+
+      # methods used by tsort
+      alias tsort_each_node each_key
+      def tsort_each_child(node, &block)
+        fetch(node).map { |n| n.typeName }.each(&block)
+      end
+      
+    end
+    # @!endgroup      
+
+  end
+end