sbuilder-eth 0.0.4

data/lib/eth/constants.rb

@@ -0,0 +1,354 @@
+require "sbuilder-al"
+
+module Sbuilder
+  module Eth
+    module Constants
+
+      # @return [String] specName mustache template to generate
+      # 'specName' = name in tla specification code representing
+      # 'appName' in namespace 'meta'
+      def self.templateSpecname( appName, meta=Constants::META_ETH )
+        "{{#SPEC_NAME}}#{strSpecname(appName, meta)}{{/SPEC_NAME}}"
+      end
+
+      # gateway to 'snippetFacadeParamsetDomain'
+      def self.snippetFacadeParamsetDomain( definition, field )
+        Sbuilder::FacadeConstants.snippetFacadeParamsetDomain( definition, field )
+      end
+      
+      # gateway to 'snippetFacadeParamsetDomain'
+      def self.snippetFacadeParamsetDomainInit( definition, field )
+        Sbuilder::FacadeConstants.snippetFacadeParamsetDomainInit( definition, field )
+      end
+
+      def self.snippetFacadeResponseDomainInit( definition, field )
+        Sbuilder::FacadeConstants.snippetFacadeResponseDomainInit( definition, field )
+      end
+      
+
+      def self.strSpecname( appName, meta=Constants::META_ETH )
+        "#{meta}.#{appName}"
+      end
+
+      # Links to sbuilder facade
+      # META_SERVICE_ENTRY = "service_implementation"
+      META_SERVICE_ENTRY = Sbuilder::FacadeConstants::META_MODEL_SERVICE_IMPLEMENTATION
+      META_SERVICE_EXIT = Sbuilder::FacadeConstants::META_MODEL_SERVICE_COMPLETION
+      META_DOMAIN = Sbuilder::FacadeConstants::META_MODEL_DOMAINS
+      META_TLA = Sbuilder::FacadeConstants::META_MODEL_FRAMEWORK_SVC
+      META_DEFINITIONS = Sbuilder::FacadeConstants::META_MODEL_DEFINITIONS
+
+      DOMAIN_BOOLEAN = Sbuilder::FacadeConstants::DOMAIN_BOOLEAN
+
+
+      SBUILDER_GET_RESPONSE = "InfrastructureServiceGetResponse"
+      SBUILDER_GET_STATUS = "InfrastructureServiceGetStatus"
+      SBUILDER_RETURN = "InfrastructureServiceReturn"
+
+      # Ethreum runtime services
+      CONTRACT_INFRA = "geth"
+      SERVICE_NEW_ACCOUNT="newAccount"
+      SERVICE_NEW_STORAGE_ROOT="newStorageRoot"      
+      SERVICE_MINE = "mine"
+
+      
+      # Solidity constants
+      SOL_MSG="msg"
+      SOL_NOW="now"
+      SOL_ADDRESS="address"
+      SOL_UINT="uint"            
+      SOL_SEND="send"
+      SOL_BOOLEAN_TYPE="bool"
+      SOL_SELF_DESTRUCT="selfdestruct"
+      SOL_REVERT="revert"
+      SOL_REQUIRE="require"            
+      SOL_THIS="this"
+      SOL_VISIBILITY_PUBLIC="public"      
+
+
+      # sbuilder-eth constants
+      SYMBOL_RESPONSE_MSG = "rply-"
+      GETTER_RESPONSE_PREFIX="ret_"
+
+      # Solidity & ethereum domains
+      DOMAIN_ADDRESS = "eth_address"
+      DOMAIN_VALUE = "eth_value"
+      # Balance cumulates msg values, if it is not passed
+      # in message balacnce default value could be Int
+      DOMAIN_BALANCE = "eth_balance"      
+      DOMAIN_GAS = "eth_gas"
+      DOMAIN_CODE_HASH = "eth_code_hash"
+      # DOMAIN_DEFAULT = "default" # when no better candidate not found
+      SIMPLE_DOMAINS = [DOMAIN_ADDRESS, DOMAIN_VALUE, DOMAIN_GAS, DOMAIN_BALANCE ]
+      DOMAINS = SIMPLE_DOMAINS + [DOMAIN_CODE_HASH]
+
+      FIELD_NAME_ORIGINATOR = "originator"             # First sender
+      FIELD_NAME_SENDER = "sender"                     # Transaction caller (sender)
+      FIELD_NAME_VALUE = "value"                       # Eth passed on message
+      FIELD_NAME_RECIPIENT = "recipient"               # called
+      FIELD_NAME_ADDRESS = "address"                   # Account ID
+      FIELD_NAME_BENEFICIARY = "beneficiary"           # Beneficiary account (in mining)
+      FIELD_NAME_BALANCE = "balance"                   # Eth VALUE
+      FIELD_NAME_RESULT = "result"                     # Result
+      FIELD_NAME_GAS = "gas"                           #
+      FIELD_NAME_CODE_HASH = "codeHash"                # EVM code (name of class)
+      FIELD_NAME_STATUS = "status"                     #
+
+
+      # Metatypes
+      META_ETH = "eth"
+
+      # prefix: -> sbuilder generates prefix, here use fixed value :eth
+      METADEFS = {
+        META_ETH => { "description" => "Ethereum runtime", "prefix" => "eth" }
+      }
+
+      # State variables Variables
+      VARIABLE_ACCOUNTS = "accounts"
+      VARIABLE_ACCOUNTS_STACK = "accounts_stack"      
+      VARIABLE_STORAGE_ROOT = "storageRoot"
+      VARIABLE_STORAGE_ROOT_STACK = "storageRoot_stack"      
+      VARIABLE_ADDRESS_FREE = "addressPool"
+      VARIABLE_MINED = "mined"
+      VARIABLE_MINED_STACK = "mined_stack"
+
+      # Types 
+      TYPE_VARIABLE_ACCOUNTS = VARIABLE_ACCOUNTS
+
+
+      VARIABLE_LOCAL_CURRENT_CONTRACT="thisCid"
+      
+      VARIABLES = [
+        VARIABLE_ACCOUNTS,
+        VARIABLE_STORAGE_ROOT,
+        # VARIABLE_ADDRESS,
+        # VARIABLE_MINED,
+        # VARIABLE_ACCOUNTS_TEMP,
+        # VARIABLE_STORAGE_ROOT_TEMP,
+        VARIABLE_ADDRESS_FREE,
+      ]
+
+      # Common parameters in types for entries variable
+      # 'VARIABLE_STORAGE_ROOT'
+      COMMON_STORAGE_ROOT_PARAMETERS = [
+        # [ FIELD_NAME_CODE_HASH, DOMAIN_CODE_HASH ],
+        [ FIELD_NAME_ADDRESS, DOMAIN_ADDRESS], 
+      ]
+
+      # Type definition for entries in variable 'VARIABLE_ACCOUNTS'
+      COMMON_ACCOUNTS_PARAMETERS = [
+        [ FIELD_NAME_CODE_HASH, DOMAIN_CODE_HASH ],
+        [ FIELD_NAME_BALANCE, Constants::DOMAIN_BALANCE],
+        [ FIELD_NAME_ADDRESS, DOMAIN_ADDRESS], 
+      ]
+      
+      
+      # Fields (and domains) in normal request messages
+      COMMON_REQ_MSG = [
+        [Constants::FIELD_NAME_SENDER, Constants::DOMAIN_ADDRESS],
+        [Constants::FIELD_NAME_ORIGINATOR, Constants::DOMAIN_ADDRESS],
+        [Constants::FIELD_NAME_RECIPIENT, Constants::DOMAIN_ADDRESS],
+        [Constants::FIELD_NAME_VALUE, Constants::DOMAIN_VALUE],
+      ]
+
+      # common fields in constructor request
+      COMMON_REQ_CONSTRUCTOR = [
+        [Constants::FIELD_NAME_SENDER, Constants::DOMAIN_ADDRESS],
+        [Constants::FIELD_NAME_ORIGINATOR, Constants::DOMAIN_ADDRESS],
+        # [Constants::FIELD_NAME_RECIPIENT, Constants::DOMAIN_ADDRESS],
+        [Constants::FIELD_NAME_VALUE, Constants::DOMAIN_VALUE],
+      ]
+
+      # Fields (and domains) in all response messages
+      COMMON_RPLY = [
+       #         [Constants::FIELD_NAME_ADDRESS, Constants::DOMAIN_ADDRESS]
+      ]
+
+      # Runtime snippets
+      RUNTIME_NEXTID = "NextId"
+      RUNTIME_APPARENT_VALUE = "isApparentValue"
+      RUNTIME_APPARENT_VALUE_FIELD = "isApparentValue"            
+      RUNTIME_GET_ELEMENT = "getElement"
+      RUNTIME_GET_ELEMENT_SAFE = "getElementSafe"      
+      RUNTIME_ELEMENT_EXISTS="elementExists"
+      RUNTIME_PUSH_CONTRACT_STATE="PushState"
+      RUNTIME_POP_CONTRACT_STATE="PopState"
+      RUNTIME_SERVICE_DONE="service_done"
+      RUNTIME_SERVICE_UP_FRONT_COST="upFrontCost"
+
+      
+      RUNTIME_CORRECT_TOTAL_VALUE="total_value"
+      RUNTIME_CORRECT_ACCOUNTS_TYPE="Accounts_type"      
+
+      RUNTIME_SNIPPETS_CORRECTNESS = [
+        {
+          :name => RUNTIME_CORRECT_TOTAL_VALUE,
+          :meta => META_ETH,
+          :txt => <<~HERE
+          (* 
+           * Sum of account balances is equal to value mined.
+           * when not executing a transaction
+           *)
+          #{templateSpecname(RUNTIME_CORRECT_TOTAL_VALUE)} ==
+                 tx_running = FALSE =>  ( #{templateSpecname(VARIABLE_MINED)} = #{templateSpecname('SumRecordField')}( #{templateSpecname(VARIABLE_ACCOUNTS)}, "balance" ) )          
+            HERE
+          },
+          {
+            :name => RUNTIME_CORRECT_ACCOUNTS_TYPE,
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (* 
+             * Sum of account balances is equal to value mined.
+             * when not executing a transaction
+             *)
+            #{templateSpecname(RUNTIME_CORRECT_ACCOUNTS_TYPE)} ==
+                    tx_running = FALSE =>  \\A e \\in #{templateSpecname(VARIABLE_ACCOUNTS)}: e \\in #{templateSpecname(META_ETH + '_' + VARIABLE_ACCOUNTS, META_DEFINITIONS)}
+            HERE
+          },
+      ]
+
+      RUNTIME_SNIPPETS = [
+          {
+            :name=>"elementExists",
+            :meta=>META_ETH,
+            :txt=>  <<~HERE
+             (*
+              * Unique element exists
+             *)
+             #{templateSpecname('elementExists')}( set, key, id ) ==  Cardinality( { e \\in set : e[key] = id } ) = 1
+             HERE
+          },
+          {
+            :name => "gasPrice",
+            :meta => META_ETH,
+            :txt => <<~HERE
+           (* Use integer math, and gasPrice is just 0 *)
+           #{templateSpecname('gasPrice')} == 0
+            HERE
+          },
+          {
+            :name => "gasValue",
+            :meta => META_ETH,
+            :txt => <<~HERE
+           (*  @return [Integer] value of 'gas' *)
+           #{templateSpecname('gasValue')}( gas ) == gas * #{templateSpecname('gasPrice')}
+            HERE
+          },
+          {
+            :name => "intrinsicGas",
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (*
+             *Always consume at least ''intrinsicGas' units of gas, i.e.
+             * account must have balance >= intrinsicGas*gasPrice before execution
+            *)
+            #{templateSpecname('intrinsicGas')} == 1
+            HERE
+          },
+          {
+            :name => RUNTIME_NEXTID,
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (*
+             * Take one 'address'' from set 'ids'.  If 'address' parameter 'Nil' address
+             * is unspecified is bound to an element in 'ids' when NextId called for the
+             * first time in a transition.
+             *)
+             #{templateSpecname(RUNTIME_NEXTID)}( ids, address ) == CHOOSE x \\in ids: (address = x /\\ address # Nil) \\/ address = Nil
+            HERE
+          },
+          {
+            :name => RUNTIME_GET_ELEMENT,
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (*
+             * Return element from 'set' such that element['key'] == 'id'
+             * Assume 'id' unique, and element exists
+             *)
+            #{templateSpecname(RUNTIME_GET_ELEMENT)}( set, key, id ) == ( CHOOSE x \\in { e \\in set : e[key] = id } : TRUE )          
+            HERE
+          },
+          {
+            :name => RUNTIME_ELEMENT_EXISTS,
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (*
+             * Unique element exists
+             *)
+            #{templateSpecname(RUNTIME_ELEMENT_EXISTS)}( set, key, id ) ==  Cardinality( { e \\in set : e[key] = id } ) = 1
+            HERE
+          },
+          {
+            :name => RUNTIME_GET_ELEMENT_SAFE,
+            :meta => META_ETH,
+            :txt => <<~HERE
+            (*
+             * Get property 'prop' from element 'e' in 'set'
+             * where element['key'] == 'id' if such an element exists
+             *)
+            #{templateSpecname(RUNTIME_GET_ELEMENT_SAFE)}( set, key, id, prop ) ==
+                 IF #{templateSpecname(RUNTIME_ELEMENT_EXISTS)}( set, key, id ) 
+                 THEN (#{templateSpecname(RUNTIME_GET_ELEMENT)}( set, key, id ))[prop]
+                 ELSE "_undefined_"
+            HERE
+          },
+          
+          {
+            :name => RUNTIME_SERVICE_UP_FRONT_COST,
+            :meta => META_ETH,
+            :txt => <<~HERE
+           (* 
+            ** Value account must hold before transaction possible to start
+            * 
+            * @return [Integer] request.value  + gasPrice * intrinsicGas
+            *) 
+           #{templateSpecname(RUNTIME_SERVICE_UP_FRONT_COST)}( request ) == request.value + #{templateSpecname('gasPrice')} *  #{templateSpecname('intrinsicGas')}
+            HERE
+          },
+          {
+            :name => "Push",
+            :meta => META_ETH,
+            :txt => <<~HERE
+           (* 
+            ** Add element to sequence head
+            *)
+           #{templateSpecname('Push')}( s, e ) == <<e>> \\o s
+            HERE
+          },
+          {
+            :name => RUNTIME_APPARENT_VALUE,
+            :meta => META_ETH,
+            :txt => <<~HERE
+           (* 
+           ** Check whether 'rec' has NOT field 'delegatecall'.
+           ** Precence means that no value transfer should take
+           ** placee. See EVM machine code 0xf4 DELEGATECALL
+           ** for meaning.
+           *)
+           #{templateSpecname( RUNTIME_APPARENT_VALUE )}( rec ) == ~ "#{RUNTIME_APPARENT_VALUE_FIELD}" \\in DOMAIN rec
+           HERE
+          },
+          
+          {
+            :name => 'SumRecordField',
+            :meta => META_ETH,
+            :txt => <<~HERE
+            RECURSIVE #{templateSpecname('SumRecordField')}(_,_)
+            (* 
+             *  Sum of field 'f' of record elements in set 'S'
+             * 
+             *  @param [Set] S set of records
+             *  @param [String] f name of field 
+             *)
+            #{templateSpecname('SumRecordField')}(S,f) == 
+               IF S = {} THEN 0
+               ELSE LET x == CHOOSE x \\in S : TRUE
+                    IN x[f] + #{templateSpecname('SumRecordField')}(S \\ {x}, f)
+            HERE
+          },
+          ]
+
+                 
+    end
+  end
+end

data/lib/eth/ethereum.rb

@@ -0,0 +1,2054 @@
+# coding: utf-8
+module Sbuilder
+
+  module Eth
+    class Ethereum
+
+      # ------------------------------------------------------------------
+      # Mixins
+      
+      extend Forwardable                         # for easy delegation
+      include Sbuilder::Al::Util::MyLogger       # mix logger
+      include Sbuilder::Eth::EthereumExpression  # methods for building expresion
+      include Sbuilder::Al::Model::Api           # Mix Sbuilder API Language (AL).
+
+      # ------------------------------------------------------------------
+      # @!group Attributes
+      
+      # @!attribute instance the singleton 
+      @@instance = nil
+      
+      # @!attribute [Sbuilder::Al::Model::Api] alApi  
+      attr_accessor :alApi
+      
+      # @!endgroup
+      
+      # ------------------------------------------------------------------
+      # @!group Constructor and singleton pattern
+        
+      private  def initialize( options = {} )
+        self.alApi = AlApi.start( Constants::METADEFS )
+        @logger = getLogger( nil, options )
+        @logger.info( "#{__method__}: singleton instance created")
+      end
+
+      def self.instance( options={} )
+        @@instance = @@instance || Ethereum.new( options )
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Initalization
+
+      # Create runtime AL-obejcts, which should be entered only once
+      #
+      # @return [Array<AlObject>] Runtime environemnt
+      def ethRuntime
+
+        # tla-variables & domains
+        ethRuntimeContractState +
+          ethRuntimeContractTransaction +
+          ethRuntimeAddressPool  +
+          Constants::SIMPLE_DOMAINS.map { |d| ethDomain(d) } +
+
+          # Types
+          [ ethRuntimeAccountsType ] +           
+
+          # tla-code into sbuilder (for runtime support)
+          ethRuntimeTlaSnippets.map do |snippet|
+          ethSnippet( snippet[:name], snippet[:txt], snippet[:meta] )
+        end +
+
+          ethRuntimeNewAccount +        # geth(newAccount)
+          ethRuntimeMine +              # geth(mine)
+          [
+            ethServiceExitCommon,         # macro eth_service_done
+            ethPushContractState,         # macro push state in svc entry
+            # ethMacroPopState,           # macro pop state in svc cmpltion            
+          ]        
+          
+      end
+
+      # @return [Array<Hash>] array of hashes (with properties :name,
+      # :meta, :txt) as Ethereum runtime snippets. This allows us load
+      # tla-code directly into sbuilder.
+      def ethRuntimeTlaSnippets
+        Constants::RUNTIME_SNIPPETS +
+          ethRuntimeTlaSnippetsCorrectness
+        #
+      end
+
+      
+      # @return [Array<Hash>] array of hashes (with properties :name,
+      # :meta, :txt) as Ethereum runtime snippets for checking
+      # correctness criteria.
+      def ethRuntimeTlaSnippetsCorrectness
+        Constants::RUNTIME_SNIPPETS_CORRECTNESS
+      end
+      
+
+      # {#ethRuntimeContractState}: Variables recording Solidity
+      # contract state.
+      #
+      # - eth.accounts : account state includes balance and 'codeHash'
+      #   for contract type, intialized to empty set (=no accounts)
+      # 
+      # - eth_storageRoot: contract state variables, initialized to
+      #   empty set (=no contracts)
+      #
+      # - eth_mined: cumulate 'value' mined, initialize to 0.
+      #
+      def ethRuntimeContractState
+        [
+          ethVariable(Constants::VARIABLE_ACCOUNTS ),
+          ethVariable(nStorageRoot),
+          ethVariable(
+            Constants::VARIABLE_MINED,
+            alApi.constantExpression do
+              value 0
+            end
+          )
+        ]
+      end
+
+      # {#ethRuntimeContractTransaction}: Stack storing contract state
+      # during transaction processing.
+      #
+      #   * eth.accounts_stack: pushed acccount state, initized to
+      #     empty sequence (=empty stack)
+      #
+      #   * eth.storageRoot_stack: pushed contract state, init empty
+      #     sequence (=empty stack)
+      #
+      #   * eth.ethMined_stack: pushed contract state, init empty
+      #     sequence (=empty stack)
+      #
+      def ethRuntimeContractTransaction
+        [
+          ethVariable(Constants::VARIABLE_ACCOUNTS_STACK, alApi.tlaSequence ),
+          ethVariable(Constants::VARIABLE_STORAGE_ROOT_STACK, alApi.tlaSequence ),
+          ethVariable(Constants::VARIABLE_MINED_STACK, alApi.tlaSequence ),                    
+        ] 
+      end
+
+      
+      def ethRuntimeMine
+        [
+          ethTransaction( Constants::CONTRACT_INFRA, Constants::SERVICE_MINE ),
+          ethServiceEntry( Constants::CONTRACT_INFRA, Constants::SERVICE_MINE )
+        ]
+      end
+
+      # Create
+      # - macro to create new entries modeling contract
+      # - service procedure for geth(newAccount)
+      # - service entry function for geth(newAccount)
+      def ethRuntimeNewAccount
+        [
+          ethTransactionNewAccount, # implement service CONTRACT_INFRA.SERVICE_NEW_ACCOUNT
+          ethServiceEntryInfra( Constants::CONTRACT_INFRA, Constants::SERVICE_NEW_ACCOUNT),
+        ]
+      end
+
+      # @return [Array<sTla>] addressPool := d_address \ { Nil }
+      def ethRuntimeAddressPool # 
+        [
+          ethVariable(
+            Constants::VARIABLE_ADDRESS_FREE,
+            alApi.binaryExpression do
+              lval ethDomainReference(Constants::DOMAIN_ADDRESS)
+              op :set_minus
+              rval alApi.tlaSet( alApi.tlaNil)
+            end
+          ),          
+        ]
+      end
+
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------      
+      # @!group Build services
+
+      # @return [Hash] metatype definition used by AlObject created in
+      # this module
+      def ethMetaDefs
+        Constants::METADEFS
+      end
+
+      # @param initRval [AlObject:RVal] Expression to initalize variable with, default nil=empty set
+      def ethVariable( variableName, initRval=nil )
+        # default init empty set
+        initRval = alApi.tlaSet if initRval.nil?
+
+        # construct variable snippet
+        alApi.variable( Constants::META_ETH ) do
+          name variableName
+          init initRval
+        end
+      end
+
+      # Create domain with name 'domainName'
+      #
+      # @param domainName [String] name of domain to create
+      #
+      # @param names [Array<String|Int|true|false>] values to assign
+      # to domain
+      #
+      def ethDomain( domainName, names=[] )
+        @logger.info "#{__method__}: domainName=#{domainName}, names=#{names.join(',')}"
+        alApi.domain do
+          
+          name domainName
+          
+          # Add names as literal values to 'domainConstructor'
+          names.each do |v|
+            literal( v )
+          end
+        end
+      end
+
+      ##
+      # Elements in domain 'eth_code_hash' are names of translated
+      # contract classes passed in parameter 'contracClasses'.  This
+      # domain give type for field 'codeHash' in records in variable
+      # 'eth_accounts'.
+      #
+      # @param contracClasses [Array<String>] names of translated
+      #        Solidity classes
+      #
+      # @return [Al:Domain] 'codeHash' domain definition with values
+      #     for contract class names 'contracClasses'
+      #
+      def ethDomainCodeHash( contracClasses )
+        ethDomain( Constants::DOMAIN_CODE_HASH, contracClasses)
+      end
+
+      
+
+      # @param refVariable [Al:Refrence] reference to variable
+      # @param expression [Al::Expression] Expression to add to set in variable
+      #
+      # variable \union expression
+      def ethVariableUnion( refVariable, expression )
+        alApi.binaryExpression do
+          lval alApi.expression( refVariable )
+          op :union
+          rval expression
+        end
+      end
+
+      # @return [Al::Expression] refVariable \ expression 
+      def ethVariableMinus( refVariable, expression )
+        alApi.binaryExpression do
+          lval alApi.expression( refVariable )
+          op :set_minus
+          rval expression
+        end
+      end
+      
+
+      # [ address |-> NextId( '#SPEC_NAME'eth.address_free'/SPEC_NAME', input.address ), balance |-> value, codeHash |-> "Demo1" ]
+      #
+      # @param contractAst [SexpAst] AST for contract to construct, nil
+      # for human account (geth(newAccount))
+      # 
+      # @param value [Integer] initial value to assing to account
+      #
+      # @return [Al:TlaExpression] tla-expression to initialize account record
+      #
+      def ethNewAccountRecord( contractAst, value=0 )
+        # Array of field names and init -expressions for account record
+        fldInitDefs = [
+          [Constants::FIELD_NAME_ADDRESS, ethNextId ], 
+          [Constants::FIELD_NAME_BALANCE, alApi.expression(value)],
+          # [Constants::FIELD_NAME_CODE_HASH, contractAst.nil? ?  alApi.tlaNil : alApi.constantExpression(contractAst["name"]) ],           
+          [Constants::FIELD_NAME_CODE_HASH, ethContract2CodeHashExpr(contractAst) ], 
+        ]
+        fldInitDefs.map do |fldInitDef|
+          alApi.tlaRecordFieldDef( fldInitDef[0], fldInitDef[1])
+        end
+      end
+
+      # @return [Al::Expression] codeHash AL-expression from contract
+      #         AST 'name' property, tlaNil if contractAst.nil? (=non
+      #         contract account)
+      def ethContract2CodeHashExpr( contractAst )
+        contractAst.nil? ? alApi.tlaNil : alApi.constantExpression(contractAst['name'])
+      end
+
+      # TLA-record modeling initial state of contract 'contractAst'
+      #
+      # [ address |-> NextId, storageRoot |-> .., variable1 |-> .., variable2 |-> ... ]
+      #
+      # @param contractAst [SexpAst] AST for contract to construt, nil
+      #       when contracting non-contract account
+      #
+      # @return [Al::TlaExpression] tla-expression initi contract storageRooot record
+      #
+      def ethNewStorageRootRecord( contractAst )
+
+        # Create initialization for fixed fields (address, ...)
+        constantInits = [
+          [Constants::FIELD_NAME_ADDRESS, ethNextId ],
+          # [Constants::FIELD_NAME_CODE_HASH, ethContract2CodeHashExpr(contractAst) ], 
+        ]
+
+        # Create member inits using {#typeInitDispatcher} - if possible
+        memberVariableInits= (
+          contractAst.nil? ?
+            [] :
+            contractAst.memberVariables
+        ).map do |v|
+          [  v['name'],
+             Ethereum.dispatcher(
+               typeInitDispatcher,
+               v.variableType.sexp_type,
+               { :contractAst => contractAst, :variableAst => v }
+             )
+          ]
+          end
+        
+        @logger.info "#{__method__}: memberVariableInits=#{memberVariableInits.join(',')}"
+
+        # Create tla expression [ fld |-> value ]
+        (constantInits + memberVariableInits).map do |fldInitDef|
+          alApi.tlaRecordFieldDef( fldInitDef[0], fldInitDef[1])
+        end
+      end
+
+      
+      # Create 'Al::Definition' for 'contractName' to give type for
+      # entries in 'storageRoot' variable.  Definition includes fixed
+      # parameters {#ethStorageRootFixedParameters} (e.g. address),
+      # and yields the 'Al::Definition' for caller allowing contract
+      # member variables to be added to the definition.
+      #
+      # @param contractName [String] name of contract for which
+      #        definition is created
+      def ethContractType( contractName )
+
+        ethDefinition(contractName) do |defi|
+          # Add fixed parameters e.g. codeHash && address
+          ethStorageRootFixedParameters.each do |parameterDef|
+            # name and domain, contract defs are not arrays
+            isArray = false
+            defi.parameter parameterDef[0], isArray, parameterDef[1]
+          end
+
+          # Add contract member variables
+          yield defi
+        end
+      end
+
+      # Construct 'Defition' corresponding record entries in
+      # 'eth_accounts' variable. Definition includes fixed parameters
+      # from {#Constants::COMMON_ACCOUNTS_PARAMETERS} such as
+      # 'address', 'balance', 'codeHash'.
+      def ethRuntimeAccountsType
+        alApi.definition do
+          name Constants.strSpecname(Constants::TYPE_VARIABLE_ACCOUNTS)
+
+          # Add fixed parameters e.g. codeHash && address
+          Constants::COMMON_ACCOUNTS_PARAMETERS.each do |parameterDef|
+            # name and domain, not array type
+            isArray = false
+            parameter parameterDef[0], isArray, parameterDef[1]
+          end
+        end
+      end
+
+      # Create 'Al::Defintion' with name 'defName'. Yield definition
+      # to caller allowing parameters/references to be added to the
+      # definition constructed.
+      def ethDefinition( defName )
+        alApi.definition do
+          name defName
+          yield self
+        end
+      end
+      
+
+      # Create 'Al::FunctionDefinition' for contract 'contractAst'
+      # member variable 'variableAst' of sexp_type
+      #
+      # Example Solidity code: mapping(address => uint256 ) balances;
+      #
+      # @param contractAst [SexpASst] contract AST node
+      #
+      # @param variableAst [SexpAst] contract member variable AST node 
+      def ethContractMappingFunction( contractAst, variableAst )
+        mappingAst = variableAst.variableType
+        @logger.info "#{__method__}: mappingAst=#{mappingAst}"
+        alApi.functionDefinition do
+          isArray = false
+          name nContractMappingMemberDefinition( contractAst['name'], variableAst['name'] )
+          inputParameter  isArray, ethWellKnownDomain( mappingAst.children[0] ) # map from
+          outputParameter isArray, ethWellKnownDomain( mappingAst.children[1] ) # map to 
+        end
+      end
+
+      # @return [String, nil] name of well knwon domain, nil if not
+      #      known. currently map "address" -> eth_address, "value" ->
+      #      "eth_value"
+      def ethWellKnownDomain( typeAst )
+        return nil unless typeAst.sexp_type == :ElementaryTypeName
+        case typeAst['name']
+        when Constants::FIELD_NAME_ADDRESS
+          Constants::DOMAIN_ADDRESS
+        when Constants::FIELD_NAME_VALUE
+          Constants::DOMAIN_VALUE
+        when Constants::FIELD_NAME_BALANCE
+          Constants::DOMAIN_BALANCE
+        else
+          return nil
+        end
+      end
+      
+      # @return [Array<Arrays>] Array of parameter definitions ([name,
+      #         domain] -pairs) common for all stroageRoot contract
+      #         entries.
+      def ethStorageRootFixedParameters
+        Constants::COMMON_STORAGE_ROOT_PARAMETERS
+      end
+
+      # Enter transaction 'contractName(functionName)', which models
+      # calling the function 'functionName' in contract
+      # 'contractName'.
+      #
+      # Assume:
+      #  - sbuilder scheduler has initialized 'responses' 'status' to FALSE
+      #    'response' -data to Nil
+      #
+      # Actions:
+      #  - push contract state to stack using {#ethPushContractState}
+      #
+      #  - check if incalling of the contract 'contractName' function
+      #   'functionName' if possible:
+      #
+      #    -- contract creation (constructior function):
+      #
+      #    -- message call (non constructor):
+      #
+      #  - call service procedure 
+      #
+      # @param contractName [String] contract for the function
+      # 'functionName'
+      #
+      # @param functionName [String] name of the function of the
+      #        transaction to invoke
+      #
+      # @return [Al::Macro] macro invoking transaction
+      #      'contractName.functionName'
+      #
+      def ethServiceEntry( contractName, functionName )
+        
+        localParameterName = "input"
+
+        alApi.macro( Constants::META_SERVICE_ENTRY ) do
+          name nInterfaceOperation( contractName, functionName )
+          parameter localParameterName
+          block {
+            
+            # push contract state to stack
+            callMacro( Constants::META_ETH, Constants::RUNTIME_PUSH_CONTRACT_STATE )
+
+            operationName = nContractFunctionOperation(contractName, functionName)
+            
+            if isConstructor( contractName, functionName ) then
+              # contract creation in a constructor
+              
+              # call to constructor allowed ? 
+              ifThen( ethServiceConstructorCanStart( localParameterName ) ) do
+                callService(
+                  Constants::META_ETH,
+                  contractName,
+                  operationName ) { |call|  call.parameter( alApi.reference( localParameterName )) }
+              end
+              
+            else
+              # message call to a non constructor function
+
+              # if call service procedure allowed?
+              ifThen(
+                ethServiceMsgCallCanStart( localParameterName )
+              ) do
+                callService(
+                  Constants::META_ETH, contractName, operationName
+                ) { |call| call.parameter( alApi.reference( localParameterName ) ) }
+              end
+            end
+            
+          }
+        end
+      end
+
+
+      # Service Entry macro for infra services, particularly
+      # geth(newAccount).
+      #
+      # NB: Infra service are used to bootstrap block chain state
+      #
+      # - geth(newAccount): create account entry && mine value to the
+      # - account
+      #
+      # Actions:
+      #
+      # - push contract state to stack
+      # - call service procedure contarac(functionName)
+      #
+      # @return [Al::Macro] Macro to start infrastructure service
+      # transaction
+      
+      def ethServiceEntryInfra( contractName, functionName )
+        
+        localParameterName = "input"
+        
+        alApi.macro( Constants::META_SERVICE_ENTRY ) do
+          name nInterfaceOperation( contractName, functionName )
+          parameter localParameterName
+          block {
+            
+            # PushState: push contract state to stack
+            callMacro( Constants::META_ETH, Constants::RUNTIME_PUSH_CONTRACT_STATE )
+            
+            # Call service for interface operation 'contractName(functionName)'
+            operationName = nContractFunctionOperation(contractName, functionName)
+            callService( Constants::META_ETH, contractName, operationName ) { |call|
+              call.parameter( alApi.reference( localParameterName ) )
+            }
+          }
+        end
+      end
+
+
+      # Map 'contractName, functionName' service completion operation
+      # to a common macro {#ethServiceExitCommon}
+      def ethServiceExit( contractName, functionName )
+
+        alApi.aliased( Constants::META_SERVICE_EXIT ) do
+          name nInterfaceOperation( contractName, functionName )
+          specName Constants.strSpecname(Constants::RUNTIME_SERVICE_DONE)
+        end
+      end
+
+      # Push constract state variables into stack.
+      #
+      # Actions:
+      #
+      # - eth_accounts_stack := eth_Push( eth_accounts_stack,eth_accounts )
+      #
+      # - eth_storageRoot_stack := eth_Push( eth_storageRoot_stack,
+      #                               eth_storageRoot )
+      #
+      # - eth_mined_stack := eth_Push( eth_mined_stack, eth_mined)
+      #
+      def ethPushContractState
+          alApi.macro( Constants::META_ETH ) do
+            name Constants::RUNTIME_PUSH_CONTRACT_STATE
+            block {
+              # eth-accounts
+              assignTo do
+                variable ethVariableReference( Constants::VARIABLE_ACCOUNTS_STACK )
+                rval alApi.tlaOperatorCall(
+                       Constants.templateSpecname("Push"),
+                       [ethVariableReferenceExpression( Constants::VARIABLE_ACCOUNTS_STACK ),
+                        ethVariableReferenceExpression( Constants::VARIABLE_ACCOUNTS )])
+              end
+
+              # eth-storage-root
+              assignTo do
+                variable ethVariableReference( Constants::VARIABLE_STORAGE_ROOT_STACK )
+                rval alApi.tlaOperatorCall(
+                       Constants.templateSpecname("Push"),
+                       [ ethVariableReferenceExpression( Constants::VARIABLE_STORAGE_ROOT_STACK ),
+                         ethVariableReferenceExpression( Constants::VARIABLE_STORAGE_ROOT )])
+              end
+
+              # eth-mined
+              assignTo do
+                variable ethVariableReference( Constants::VARIABLE_MINED_STACK )
+                rval alApi.tlaOperatorCall(
+                       Constants.templateSpecname("Push"),
+                       [ ethVariableReferenceExpression( Constants::VARIABLE_MINED_STACK ),
+                         ethVariableReferenceExpression( Constants::VARIABLE_MINED ) ])
+              end
+            } # block
+          end
+      end
+
+
+
+      # {#ethServiceMsgCallCanStart}: Expression, which should
+      # evaluate to TRUE allowing service procedure for a message call
+      # to a contract function to execute.
+      #
+      # Evalutate TRUE when the following conditions are TRUE:
+      #
+      # * elemement 'accounts[msg.sender]' exists
+      #
+      # * accounts[msg.sender].balance >= upFrontConst(msg.value)
+      #
+      # @param parameterName [String] name of parameterholding 'msg' 
+      #
+      # @return [Al::Expression] expression to evaluate allowing
+      #        service of a msg call to be executed
+      def ethServiceMsgCallCanStart( parameterName  )
+
+        # Expressions used below
+        exprSender = alApi.expression(alApi.reference( parameterName, Constants::FIELD_NAME_SENDER ))
+        exprParameter = alApi.expression( alApi.reference( parameterName ))
+
+        ethBinaryExpression(
+          
+          # 'accounts[msg.sender]' exists?          
+          alApi.tlaOperatorCall(
+            Constants.templateSpecname(Constants::RUNTIME_ELEMENT_EXISTS),
+            [ # set, key, id
+              alApi.expression(refAccount),
+              alApi.expression(Constants::FIELD_NAME_ADDRESS),    # constant string expression
+              exprSender,
+            ] ),
+          binaryOperator( "&&" ),
+
+          # accounts[msg.sender].balance >= upFrontConst(msg.value)
+          ethBinaryExpression(
+            alApi.tlaRecordField(
+            alApi.tlaOperatorCall(
+            Constants.templateSpecname(Constants::RUNTIME_GET_ELEMENT),
+            [
+              alApi.expression(refAccount),
+              alApi.expression(Constants::FIELD_NAME_ADDRESS),
+              exprSender,
+            ]
+          ), Constants::FIELD_NAME_BALANCE
+          ),
+            binaryOperator( ">=" ),
+            alApi.tlaOperatorCall(
+              Constants.templateSpecname(Constants::RUNTIME_SERVICE_UP_FRONT_COST),
+              [exprParameter] )
+          ) 
+        ) # AND
+      end
+      # {#ethServiceExitCommon} Macro to finish the transaction after
+      # executing the service procedure for 'interfaceOperation', the
+      # name of which is passed to the macro in a formal parameter.
+      #
+      # Actions:
+      #
+      # - restore contract state from top from transaction stack if
+      #   'interfaceOperation' has failed
+      #      
+      #  - remove contract state from transaction stack
+      #
+      # @return [Al::Macro] macro implmenting service exit actions
+      def ethServiceExitCommon  # 
+        
+        interfaceOperation = "input"
+        
+        alApi.macro( Constants::META_ETH ) do
+          name Constants::RUNTIME_SERVICE_DONE      # service_done
+          parameter interfaceOperation
+          block do
+            
+            ifThen( ethServiceFail(ethLocalReference(interfaceOperation)) ) do
+
+              # Restore state from stack
+              # - eth_accounts := Head( eth_accounts_stack );
+              # - eth_storageRoot := Head( eth_storageRoot_stack );
+              # - eth_mined := Head( eth_mined_stack );              
+              assignTo do
+                variable ethVariableReference( nAccount )
+                rval ethStackTop( Constants::VARIABLE_ACCOUNTS_STACK )
+              end
+
+              
+              assignTo do
+                variable ethVariableReference( nStorageRoot )
+                rval ethStackTop( Constants::VARIABLE_STORAGE_ROOT_STACK )
+              end
+              
+              assignTo do
+                variable ethVariableReference( nMined )
+                rval ethStackTop( Constants::VARIABLE_MINED_STACK )
+              end
+              
+            end # if then  block
+
+            # Remove contract state from stack
+            assignTo do
+              variable ethVariableReference( Constants::VARIABLE_ACCOUNTS_STACK )
+              rval ethStackRest(Constants::VARIABLE_ACCOUNTS_STACK )
+            end
+            assignTo do
+              variable ethVariableReference( Constants::VARIABLE_STORAGE_ROOT_STACK )
+              rval ethStackRest(Constants::VARIABLE_STORAGE_ROOT_STACK )
+            end
+            assignTo do
+              variable ethVariableReference( Constants::VARIABLE_MINED_STACK )
+              rval ethStackRest(Constants::VARIABLE_MINED_STACK )
+            end
+
+            
+          end # block
+        end # macro
+      end # ethServiceExitCommon
+      
+
+      # Crerate AL object for free text tla-snippets.
+      #
+      # @return [Al:Snippet] Snippet object with name 'snippetName' and txt 'snippetTxt' 
+      def ethSnippet( snippetName, snippetTxt, snippetMeta=Constants::META_ETH)
+        alApi.snippet( snippetMeta ) {
+          name snippetName
+          txt snippetTxt
+        }
+      end
+
+      # @param contractName [String] name of Solidity contract of 'functionName'
+      # @param functionName [String] name of function modeled as a transaction
+      # @param requestParameters [lambda] lambda function returning function input parameters
+      #
+      # @param responseParameters [lambda] lambda function returning
+      # function return parameters
+      #
+      # @param sourceLink [Hash] link to solidity implementation with
+      # :sourceModule, and :sourceLine
+      #
+      # @return [Al::Transaction] transaction object for operation
+      # 'functionName' in contract 'contractName'
+      #
+      # @yield [Al::Block] yield block which should be filled with AlObject for statemens
+      def ethTransaction( contractName, functionName, requestParameters: nil, responseParameters: nil, sourceLink: nil )
+        @logger.info( "#{__method__}: contractName=#{contractName}, functionName=#{functionName},  sourceLink=#{sourceLink}")
+        @logger.debug( "#{__method__}: contractName=#{contractName}/#{functionName}, requestParameters=#{requestParameters}, responseParameters=#{responseParameters}") if @logger.debug?
+
+        # Common lambda to add parameters for request/response using a
+        # hash with :type, :name and optional :domain -properties
+        lMessageParameters = ->(paramSetBuilder, parameterHash) do
+          case parameterHash[:type]
+          when :ElementaryTypeName, :VariableDeclarationWithDomain
+            paramSetBuilder.parameter parameterHash[:name], parameterHash[:isArray], parameterHash[:domain]
+          else
+            raise MissingImplementation, "Unkwon type #{parameterHash[:type]} in parameterHash #{parameterHash}"
+          end
+        end
+        
+        alApi.transaction( Constants::META_ETH ) do
+          
+          name contractName
+          # Empty operation name for constructor
+          operation nContractFunctionOperation( contractName, functionName)
+          # Keep address of currently running contract in local variable
+          local nRunningContractAddress
+
+          returnOption true           # infrastructureService --> generate response slot
+
+          interfaceOption true        # interfaceService --> generate interface process && t_req, r_response
+
+          # Add link to source code - if possible
+          if ( sourceLink ) then
+            sourceModule sourceLink[:sourceModule]
+            sourceLine sourceLink[:sourceLine]
+          end
+
+          # Define request message
+          request alApi.request {
+            
+            requestParameters.each{ |parameterHash| lMessageParameters[self, parameterHash] } if requestParameters
+          } 
+          
+          # Define response message
+          response alApi.response {
+            
+            Constants::COMMON_RPLY.each do |fldDomPair|
+              parameter(fldDomPair[0], fldDomPair[1] )
+            end
+            if (contractName == functionName  ) then
+              # Solidity Contructor returns address created
+              isArray = false
+              parameter Constants::FIELD_NAME_ADDRESS, isArray, Constants::DOMAIN_ADDRESS
+            end
+            
+            responseParameters.each{ |parameterHash|  lMessageParameters[self, parameterHash] } if responseParameters
+          } 
+
+          # yield txBlock (to be populated with AlObjects for stmts)
+          block {
+            yield self
+
+            
+          } if block_given? # block
+            
+        end # alApi.transaction( Constants::META_ETH ) do
+      end # def ethTransaction
+
+      # # @return [Array<Array>] array common request parameters,
+      # #   where each element defines field-name, and domain-name
+      # #
+      # # @param contractName [String] f
+      # #
+      # # @param functionName [String] for constructor return differnt
+      # #       request message
+      # #
+      # def ethTransactionCommonRequestParameter( contractName, functionName )
+      #   isConstructor( contractName, functionName ) ? 
+      #     Constants::COMMON_REQ_CONSTRUCTOR :  Constants::COMMON_REQ_MSG
+      # end
+
+      # {#ethTransactionNewAccount}: Service procedure for
+      # infrastructure service 'geth(newAccount).
+      #
+      #
+      # We need to have a way to create initial account because
+      # 'normal' solidity transactions require that sender account
+      # exists.
+      #
+      # Actions:
+      #
+      #  - reserve NextId  address from 'addressPool'
+      #  - create entry into 'accounts' variable'
+      #  - create entry into 'storageRoot' variable
+      #  - cumulate value in 'mined'
+      #
+      def ethTransactionNewAccount
+
+        valueMined = ethFunctionParameterReference( Constants::CONTRACT_INFRA, Constants::SERVICE_NEW_ACCOUNT, Constants::FIELD_NAME_VALUE )
+
+        # No contracts for an account
+        contractAst = nil
+
+        # only COMMON_REQ_MSG -parameters
+        requestParameters =  ->() do
+          Constants::COMMON_REQ_MSG.map do |name_domain|
+            ethVariableDeclaration( VariableDeclarationWithDomain.create(name_domain) )
+          end
+        end
+        
+        ethTransaction(Constants::CONTRACT_INFRA, Constants::SERVICE_NEW_ACCOUNT, requestParameters: requestParameters.call ) do |txBlock|
+
+          # accouts := accounts \union [ address |-> NextId, balance |-> input.value ]
+          ethActionNewAddress(txBlock, contractAst,  valueMined )
+
+          # storage root
+          ethActionNewStorageRoot( txBlock, contractAst )
+
+          # mined := mined + value
+          ethActionMine( txBlock, valueMined )
+          
+          # eth_AddressPool := eth_AddressPool \ { NextId() }
+          ethActionConsumeAddress( txBlock )
+          
+        end
+
+      end
+
+      # Delete from 'address' and 'storageRoot' entry pointed by
+      # 'refRunningContractAddress' (=addess of currently running
+      # contract).  Move balance on delete account 'astRecipient'
+      # 
+      # @param astRecipient [SexpAst] recient to receive balance from
+      #        the deleted contract
+      #
+      #
+      def ethDeleteAccount( txBlock, astRecipient )
+        @logger.debug( "#{__method__}: astRecipient=#{astRecipient}") if @logger.debug?
+
+        # Delete account of currently running contract
+        exprAccountToDelete = refRunningContractAddress
+
+        # Account entries to process
+        setIteratorVariable = "accountEntry"
+        noAction = setIteratorVariable
+
+        # Identifiy account to receive balance of deleted account
+        exprRecipient = exprRecipient = dispatchExpression( astRecipient )
+        shouldAddToRecipient =
+          alApi.equal(tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_ADDRESS), exprRecipient )
+
+        # expression to move balace
+        exprValueToMove = alApi.tlaRecordField( 
+          alApi.tlaOperatorCall( Constants.templateSpecname(Constants::RUNTIME_GET_ELEMENT),
+                                 [
+                                   alApi.expression(refAccount),
+                                   alApi.expression(Constants::FIELD_NAME_ADDRESS),
+                                   exprAccountToDelete,
+                                 ]),
+          Constants::FIELD_NAME_BALANCE
+        )
+        exprMoveToRecipient = alApi.tlaEXCEPT(
+          setIteratorVariable,
+          [ alApi.equal(tlaRecordField("!", Constants::FIELD_NAME_BALANCE ),
+                        alApi.plus( tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_BALANCE ), exprValueToMove ))])
+        
+        # Expression for move balanace
+        moveExpr =
+          alApi.tlaSetGenerate(
+          alApi.tlaIF( shouldAddToRecipient,
+                       exprMoveToRecipient,
+                       noAction
+	             ),
+          setIteratorVariable,
+          alApi.expression(refAccount)
+        )
+
+        entryWithBalanceMoved = 'b'
+        # Access all expect except entry from currently running contract
+        exprAccepEntries = ethBinaryExpression(alApi.tlaRecordField(
+                                        entryWithBalanceMoved, Constants::FIELD_NAME_ADDRESS),
+                                       binaryOperator( "!="),
+                                       exprAccountToDelete )
+        exprAccountsAfterDelete = alApi.tlaSetSelect( entryWithBalanceMoved, moveExpr, exprAccepEntries )
+ 
+
+        # eth_account := 'exprAccountsAfterDelete'
+        txBlock.assignTo do
+          variable refAccount
+          rval exprAccountsAfterDelete
+        end
+
+        # eth_storageRoot := storageRoot :setMinus {exprAccountToDelete}
+        # ethActionDeleteEntry( txBlock, refStorageRoot, exprAccountToDelete )
+        txBlock.assignTo do
+          variable refStorageRoot
+          rval ethVariableMinus(
+                 refStorageRoot,
+                 alApi.tlaSetSelect(
+                   "var", alApi.expression(refStorageRoot),
+                   alApi.equal( alApi.tlaRecordField("var", "address"),  exprAccountToDelete )
+                 )
+               )
+        end
+
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Actions
+
+      # Action in 'txBlock' to create new entry into 'accounts' variable.
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractAst [SexpAst] AST for contract to construct, nil
+      # for human account (geth(newAccount))
+      #
+      # @param value [Integer] initial value to assign to account, default 0 
+      #
+      #  eth_accounts  := eth_accounts,
+      #                 { [ address |-> NextId( eth_address_free, input.address ), balance |-> 'value', codeHash |-> input.codeHash ]}
+
+      def ethActionNewAddress(txBlock, contractAst=nil, value=0)
+        # accounts := accounts \union [ address |-> xx, balance |-> 0, codeHash |-> Nil ]
+        # codeHash = contractAst.nil? ? nil : contractAst['name']
+        @logger.info "#{__method__}: contractAst=#{contractAst.nil? ? 'contractAst was nil' : contractAst['name']}"
+        txBlock.assignTo do
+          variable refAccount
+          rval ethVariableUnion(
+                 refAccount,
+                 alApi.tlaSet(alApi.tlaRecord( ethNewAccountRecord( contractAst, value) )) )
+        end
+      end
+
+
+
+      # Action in 'txBlock' to cumulate 'value' to total value mined.
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param value [Al::Expression] value to cumulate to 'mined' 
+      def ethActionMine( txBlock, value )
+
+        txBlock.assignTo do
+          variable ethVariableReference(Constants::VARIABLE_MINED)
+          rval ethBinaryExpression(
+                 alApi.expression(ethVariableReference(Constants::VARIABLE_MINED)),
+                 binaryOperator( '+'),
+                 value
+               )
+        end
+        
+      end
+
+
+      # Action 'txBlock' to create new entry into 'storageRoot' variable
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractAst [SexpAst] AST for contract to construt
+      def ethActionNewStorageRoot(txBlock, contractAst=nil)
+        txBlock.assignTo do
+          variable refStorageRoot
+          rval ethVariableUnion(
+                 refStorageRoot,
+                 alApi.tlaSet(alApi.tlaRecord( ethNewStorageRootRecord(contractAst) )) )
+        end
+      end
+
+      # Add actions to check that currently contract for currently
+      # executing transaction exists. For a constructor that account
+      # has been created before reaching this point, but for a message
+      # call a situation of non-existing contract code may take place.
+      #
+      # TODO: add implementation to create empty account && move value
+      #
+      def ethActionCheckContractExists( txBlock, contractAst, functionAst )
+
+        getCurrentAccountExists =         
+          alApi.not(
+          alApi.tlaOperatorCall(
+          Constants.templateSpecname(Constants::RUNTIME_ELEMENT_EXISTS),
+          [
+            alApi.expression(refAccount),
+            alApi.expression(Constants::FIELD_NAME_ADDRESS),
+            refRunningContractAddress,
+          ]
+        )
+        )
+
+        warn "Implementation missing for action ethActionCheckContractExists"
+        
+        txBlock.ifThen( getCurrentAccountExists ) {
+          # if block 
+          ifError = self
+          # jump to failure
+          ifError.done( nEthnInterfaceOperation(contractAst['name'], functionAst['name'] ))
+        } # ifThen
+        
+      end
+
+      # Add action to call procedure contractCalled(functionCalled)
+      # with parameters.
+      #
+      # @param functionCalled [String] name of called function
+      #      
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      
+      def ethCallStatement( txBlock, contractCalled, functionCalled, parameters )
+        @logger.info "#{__method__}: call to #{contractCalled}(#{functionCalled})"
+        txBlock.callService( Constants::META_ETH,  contractCalled, nContractFunctionOperation(contractCalled, functionCalled) ) do |call|
+          call.parameter( parameters )
+        end
+        
+      end
+
+      # Call 'contractCalled(functionCalled)' within transaction with
+      # 'paramters'. After the call use
+      # {Constants::RUNTIME_SERVICE_DONE} to check tx status pop
+      # tx-stack.
+      #
+      # Implementation make a macro call to
+      # 'nContractFunctionOperation' within namespace
+      # META_SERVICE_ENTRY
+      
+      def ethCallTransaction( txBlock, contractCalled, functionCalled, parameters )
+        @logger.info "#{__method__}: call to #{nInterfaceOperation(contractCalled, functionCalled)} )"
+        txBlock.callMacro( Constants::META_SERVICE_ENTRY,  nInterfaceOperation(contractCalled, functionCalled) ) do |call|
+          call.parameter( parameters )
+        end
+
+        # macro makes a function call --> need to label
+        txBlock.label
+
+        # restore state if error - pop stack
+        txBlock.callMacro( Constants::META_ETH, Constants::RUNTIME_SERVICE_DONE) do |call|
+          call.parameter nInterfaceOperation(contractCalled, functionCalled)
+        end
+
+        # macro makes uses if --> need to label
+        txBlock.label
+        
+      end
+
+      # @param callType [:normal, :constructor] Normal call and
+      #        constructor call have different paramatere
+      #
+      #
+      # @param parameters [Array<[String, Al::Expression]>]
+      #        parameters to pass to function
+      #      
+      # @return [TlaRecord] record with fiel mappings
+      def ethCallParameters( callType, callerContract, callerFunction, commonRequest, parameters )
+        alApi.tlaRecord(
+          commonRequest + 
+          parameters.map do |name_expression|
+            raise "Name was nil in #{name_expression} " unless name_expression[0]
+            alApi.tlaRecordFieldDef( ethLocalReference(name_expression[0]), name_expression[1] )
+          end
+        )
+      end
+
+      # Create array of parameter mappings for common request
+      # parameters (value, sender, recipient, originator) based on
+      # callType.
+      #
+      # @param callType [:call, :create, :callcode, :delegatecall]
+      #        Controls parameter mapping
+      #
+      # @param callerContract [String] name of contract making the call
+      #
+      # @param callerFunction [String] name of tx-function where call
+      #        is invoked
+      #
+      # @param functionCallStmt [:FunctionCall] sexp AST for function call, to
+      #        evaluate for recipient
+      #
+      # @param valueModifierExpression [tlaExpresssion] value to
+      #        transfer, default to 0 if no value modifier in call
+      #
+      #
+      # @return [Array<tlaRecorField>] field mappings created by
+      #          tlaRecordFieldDef (name |-> tlaExpression ) for
+      #          common parameters
+      def ethCallCommonRequestParameters( callType, callerContract, callerFunction, functionCallStmt, valueModifierExpression )
+
+        # Iterate ':map_fields', map fields to [name, expression] pair
+        # using ':mapper' (with default parameter expression), convert
+        # to 'tlaRecordFieldDef'.
+
+        mapper = getParameterMapper(callType)
+
+        # map_fields mapped + add_fieds added
+        (
+        mapper[:map_fields].map do |name_domain|
+          # pair [ name, expression ]
+          [
+            name_domain[0],
+            (
+              mapper[:mapper][name_domain[0]] ||
+              ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression ) { ethFunctionParameterExpression(callerContract, callerFunction, name ) }
+            ).call(self, callerContract, callerFunction, functionCallStmt, name_domain[0], valueModifierExpression )
+          ]
+        end +
+          
+        mapper[:add_fields].map do |addfield|
+          # pair [field, lambda.call]
+          [
+            addfield[0],
+            addfield[1].call( self, callerContract, callerFunction, functionCallStmt, addfield[0], valueModifierExpression )
+          ]
+        end
+        
+        ).
+
+
+          # Create tlaRecordFieldDef
+          
+          map do  |name_init|
+          # name |-> contract_function_input.name
+          alApi.tlaRecordFieldDef( name_init[0], name_init[1] )
+        end
+      end
+    
+
+      # Maps 'callType' to hash defining how to set common paramerters
+      # sender, originator, value, recipient for the 'callType'.
+      # Hash defines
+      #
+      # :map_fields : array of field_names (actually [name,domain] pairs)
+      #
+      # :mapper : to act upon :map_fields to create [name,tla-expr] pairs
+      #
+      # :add_fields: array of [name, tla-expr] -pairs to add to common
+      # request
+      
+      def getParameterMapper( callType )
+        
+        parameter_mapper = {
+          
+          # local call
+          :delegatecall => {
+            #  - sender=Is (no change),
+            #  - origin:Io(no change),
+            #  - recipient=no change(=current contact=thisCid),
+            #  - value : no change
+            #  - add field APPARENT_VALUE_FIELD to flag that no value transferred
+            :map_fields => Constants::COMMON_REQ_MSG,
+            :mapper => {
+              # Constants::FIELD_NAME_VALUE => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { valueExpression },
+              Constants::FIELD_NAME_SENDER => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { api.exprRunningContractAddress },
+            },
+            :add_fields => [
+              [
+                Constants::RUNTIME_APPARENT_VALUE_FIELD,
+                ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression ) { api.expression(true) },
+              ]],
+          },
+          
+          # remote call:
+          :call => {
+            # - sender: Ia = account exectuting
+            # - origin:Io (no change),
+            # - recipient: eval call
+            # - value=value expression
+            :map_fields => Constants::COMMON_REQ_MSG,
+            :mapper => {
+              Constants::FIELD_NAME_VALUE => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { valueExpression },
+              Constants::FIELD_NAME_SENDER => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { api.exprRunningContractAddress },
+              Constants::FIELD_NAME_RECIPIENT =>
+              ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression ) do
+                
+                # remote calls either var.func() or this.func(), where
+                # 'var' and 'this' in :MemberAccess AST node eval
+                # struct of MemberAccess expression msg.recipient
+                
+                api.dispatchExpression(functionCallStmt.callExpression)
+                
+              end,
+            },
+            :add_fields => [],
+          },
+
+          # constructor
+          :create => {
+            # - sender: Ia = account exectuting
+            # - origin:Io (no change),
+            # - value=value expression
+            :map_fields => Constants::COMMON_REQ_CONSTRUCTOR,
+            :mapper => {
+              Constants::FIELD_NAME_SENDER => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { api.exprRunningContractAddress },
+              Constants::FIELD_NAME_VALUE => ->(api, callerContract, callerFunction, functionCallStmt, name, valueExpression) { valueExpression },
+            },
+            :add_fields => [],
+          }
+        }
+
+        # TODO: add :callcode, libary?
+        raise "Unknown callType #{callType}, expect one of #{parameter_mapper.keys.join(",")}" if parameter_mapper[callType].nil?
+        parameter_mapper[callType]
+
+      end
+
+      # Add actions moving value from sender to recipient. Expect that
+      # both sender and recipient exist.
+      #
+      # Must check that sender # recipent and make no balance move 
+      #
+      # Creates something like this:
+      # { IF addR THEN bal = bal + msg.value ELSE IF minusS THEN bal =
+      #        bal -msg.value ELSE a : a \in eth_account }
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractAst [AstSexp] contract to construct
+      #
+      # @param functionAst [AstSexp] ast of contract constructor
+      def ethActionMovevalue( txBlock, contractAst, functionAst)
+        
+        setIteratorVariable = "a"
+
+        # Value to move
+        msgValue = ethFunctionParameterReference( contractAst['name'], functionAst['name'], Constants::FIELD_NAME_VALUE )
+
+        # Recipient and sender of the value move
+        recipient = refRunningContractAddress
+        sender = ethFunctionParameterReference( contractAst['name'], functionAst['name'], Constants::FIELD_NAME_SENDER )
+
+        isNotApparentValue = alApi.tlaOperatorCall( Constants.templateSpecname(Constants::RUNTIME_APPARENT_VALUE),
+                                                    [ethFunctionParameterExpression( contractAst['name'], functionAst['name'] )])
+        
+        senderNotEqualRecipient = ethBinaryExpression( sender, binaryOperator( "!="), recipient )
+
+        # Conditions for the move
+        shouldAddToRecipient = alApi.and(
+          isNotApparentValue,          
+          alApi.and(
+            senderNotEqualRecipient,
+            alApi.equal(tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_ADDRESS), recipient )
+          ))
+        
+        shouldRemoveFromSender = alApi.and(
+          isNotApparentValue,
+          alApi.and(
+            senderNotEqualRecipient,
+            alApi.equal(tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_ADDRESS), sender )          
+          ))
+
+        # Expression for updating balance 
+        exprAddToRecipient = alApi.tlaEXCEPT(
+          setIteratorVariable,[
+            alApi.equal( tlaRecordField("!", Constants::FIELD_NAME_BALANCE ),
+                         alApi.plus( tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_BALANCE ), msgValue ))]
+        )
+        
+        exprRemoveFromSender = alApi.tlaEXCEPT(
+          setIteratorVariable,[
+            alApi.equal( tlaRecordField("!", Constants::FIELD_NAME_BALANCE ),
+                         alApi.minus(tlaRecordField( setIteratorVariable, Constants::FIELD_NAME_BALANCE ), msgValue)) ,
+          ])
+        
+        noAction = setIteratorVariable
+
+
+        # Put it all together
+        moveExpr = alApi.tlaSetGenerate(
+          alApi.tlaIF( shouldAddToRecipient,
+                       exprAddToRecipient,
+                       alApi.tlaIF(
+                         shouldRemoveFromSender,
+                         exprRemoveFromSender,
+                         noAction
+                       )
+                     ),
+          setIteratorVariable,
+          alApi.expression(refAccount)
+        )
+        
+        # Change variable 'eth_accounts'
+        txBlock.assignTo do
+          variable refAccount
+          rval moveExpr
+        end
+
+      end
+      
+      # Add action to check that codeHash of the currenly executing
+      # transaction matches code being executed (=check added in this
+      # method). In error failure.
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractAst [AstSexp] contract to construct
+      #
+      # @param functionAst [AstSexp] ast of contract constructor
+      def ethActionCheckContractType( txBlock, contractAst, functionAst )
+
+        getCurrentAccountCodeHash =
+          alApi.tlaRecordField(
+          alApi.tlaOperatorCall(
+          Constants.templateSpecname(Constants::RUNTIME_GET_ELEMENT),
+          [ alApi.expression(refAccount),
+            alApi.expression(Constants::FIELD_NAME_ADDRESS),
+            refRunningContractAddress, ]
+        ), Constants::FIELD_NAME_CODE_HASH
+        )        
+
+        txBlock.ifThen(
+          ethBinaryExpression(
+            getCurrentAccountCodeHash,
+            binaryOperator( "!=" ),
+            contractAst['name'] )
+        ) {
+          # block represent error
+          ifError = self
+          # jump to failure
+          ifError.done( nEthnInterfaceOperation(contractAst['name'], functionAst['name'] ))
+        } # ifThen
+        
+      end
+
+      # eth_AddressPool := eth_AddressPool \ { NextId() }
+      def ethActionConsumeAddress(txBlock)
+        txBlock.assignTo do
+          variable refFreeAddressPool
+          rval ethVariableMinus( refFreeAddressPool, alApi.tlaSet( ethNextId ) )
+        end
+      end
+
+      # Action to initialize pointer to currently running contract
+      # 'this' in local variable of contract service
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param thisExpression [Al::Expression] expression to set this
+      # to. NB: nextId or msg.sender
+      #
+      def ethActionInitThis( txBlock, thisExpression )
+        txBlock.assignTo do
+          variable refRunningContractAddress
+          rval thisExpression
+        end
+      end
+
+      # Create an action to initiaze SBUILDER_RETURN status and
+      # reponse values.
+      #
+      # Init value for response is a record, which assings domain init
+      # value for each 'parameter' in 'responseParameters' of
+      # 'functionAst'.  Reponse value Nil no 'responseParameters'.
+      #
+      
+      def ethActioInitReturnValue( txBlock,  contractAst, functionAst )
+        @logger.debug "#{__method__}: functionAst=#{functionAst}" if @logger.debug?
+
+        # Type name of  function response
+        functionResponseTypeName =
+          
+        
+        responseInit =
+          
+          if functionAst.responseParameters.parameters.length == 0
+            
+            # No return parametes - Nil
+            alApi.tlaNil
+            
+          else
+
+            # Create init record, which initialized 'parameter' with domain initial value
+            # in 'functionResponseType'
+            alApi.tlaRecord(
+              functionAst.responseParameters.parameters.map do |parameter|
+                alApi.tlaRecordFieldDef(
+                  parameter["name"],
+                  Constants.snippetFacadeResponseDomainInit(
+                    nInterfaceOperation(contractAst["name"], functionAst["name"]), parameter["name"] )
+                )
+              end
+            )
+          end
+
+        @logger.debug "#{__method__}: responseInit=#{responseInit.strOutput}" if @logger.debug?
+        
+        txBlock.callMacro( Constants::SBUILDER_RETURN )  do |call|
+          call.parameter nInterfaceOperation( contractAst["name"], functionAst["name"] )
+          call.parameter true
+          call.parameter responseInit 
+        end
+        
+      end
+
+
+      # Action sets set status 'true', data value nil
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractName [String] contract for the function
+      #       'functionName'
+      #
+      # @param functionName [String] name of the function to return
+      #      from
+      #
+      
+      #
+      def ethActionFinalReturn( txBlock, contractName, functionName  )
+
+        retExpression = if isConstructor( contractName, functionName  )
+                          alApi.tlaRecord(
+                            alApi.tlaRecordFieldDef(
+                            Constants::FIELD_NAME_ADDRESS,
+                            alApi.expression(refRunningContractAddress)
+                          ))
+                        else
+                          alApi.tlaNil
+                        end
+        txBlock.ret true, retExpression
+        
+      end
+
+      # Call txBlock.done (=to jump to end label) in function
+      # 'functionName' of contract 'contractName'.
+      #
+      # @param txBlock [Al::BlockBuilder] block to add action into
+      #
+      # @param contractName [String] contract for the function
+      #       'functionName'
+      #
+      # @param functionName [String] name of the function to return
+      #      from
+      #
+      def ethActionGotoEnd( txBlock,  contractName, functionName )
+        txBlock.done( nEthnInterfaceOperation(contractName, functionName))
+      end
+      
+      # Set field 'variableAst' in contact 'contractAst' to
+      # 'expressionAst'.
+      #
+      # For example:
+      # { IF a.address = contractId THEN [a EXCEPT !.variable[indexExpession] = a.field + 1]  ELSE a: a \in eth_storageRoot }
+      #
+      # @param contractAst [AstSexp] :ContractDefinition
+      #
+      # @param identifierAst [AstSexp] lval to update
+      #
+      # @param expressionAst [AstSexp] rval expression for update
+      #
+      # @return [Al::Expression] result of translatating
+      #     'expressionAst' to update contract state variable
+      #     'identifierAst' in contract 'contractAst'
+      # 
+      def ethAssignStatement(contractAst, identifierAst, expressionAst)
+        @logger.debug "#{__method__}: identifierAst=#{identifierAst}" if @logger.debug?
+        
+        setIteratorVariable = "a"
+        # create context allowing contract to be found in variable 'a'
+        expressionContext = ExpressionContext.createExpressionContext( expressionAst )
+        expressionContext.setContextContract( setIteratorVariable )
+
+        # tranlate expresion within context
+        expr = Ethereum.dispatcher( expressionDispatcher, expressionContext.sexp_type, expressionContext )
+
+        # translate IF THEN EXCEPT tla-expression
+        alApi.tlaSetGenerate(
+          alApi.tlaIF(
+          ethBindToRecipient(setIteratorVariable),
+          alApi.tlaEXCEPT(
+            setIteratorVariable,
+            alApi.equal(
+              tlaRecordField(
+                "!",
+                Ethereum.dispatcher( lvalAccessDistpatcher,identifierAst.sexp_type, identifierAst )),
+              expr )),
+          setIteratorVariable),
+          setIteratorVariable,
+          alApi.expression(refStorageRoot) )
+      end
+
+
+      # Implement actions for EMV 0xf0, CREATE
+      def ethActionCall_create( txBlock, contractAst, functionAst, functionCallStmt, parameters, contractCalled, functionCalled  )
+        @logger.debug "#{__method__}: functionCallStmt=#{functionCallStmt}" if @logger.debug?
+        
+        # procedure call for local calls
+        ethCallStatement(
+          txBlock,
+          contractCalled['name'], functionCalled['name'], parameters
+        ) # ethCallStatement
+
+        # if call failed? then fail caller
+        txBlock.ifThen(
+          ethServiceFail(
+            exprInterfaceOperation(
+              contractCalled['name'],
+              functionCalled['name'] )
+          )) do
+          failure nEthnInterfaceOperation(contractAst['name'], functionAst['name'] )
+        end
+      end
+
+      # Implement actions for EMV 0xf1 CALL
+      def ethActionCall_call( txBlock, contractAst, functionAst, functionCallStmt, parameters, contractCalled, functionCalled  )
+        @logger.debug "#{__method__}: functionCallStmt=#{functionCallStmt}" if @logger.debug?
+        # procedure call tx
+        ethCallTransaction(
+          txBlock,
+          contractCalled['name'], functionCalled['name'], parameters
+        )
+
+        # if call failed? then fail caller
+        txBlock.ifThen(
+          ethServiceFail(
+            exprInterfaceOperation(
+              contractCalled['name'],
+              functionCalled['name'] )
+          )) do
+          failure nEthnInterfaceOperation(contractAst['name'], functionAst['name'] )
+        end
+          
+      end
+
+      # Implement actions for EMV 0xf2 CALLCODE
+      def ethActionCall_callcode( txBlock, contractAst, functionAst, functionCallStmt, parameters, contractCalled, functionCalled  )
+        raise ":callcode not yet implemented for, used in #{functionCallStmt}"
+      end
+
+      # Implement actions for EMV 0xf4 DELEGATECALL. It is local call
+      # 
+      #
+      #
+      def ethActionCall_delegatecall( txBlock, contractAst, functionAst, functionCallStmt, parameters, contractCalled, functionCalled  )
+        ethCallStatement(
+          txBlock,
+          contractCalled['name'], functionCalled['name'], parameters
+        ) # ethCallStatement
+
+        # if call failed? then fail caller
+        txBlock.ifThen(
+          ethServiceFail(
+            exprInterfaceOperation(
+              contractCalled['name'],
+              functionCalled['name']
+            )
+          )) do
+          failure nEthnInterfaceOperation(contractAst['name'], functionAst['name'] )
+        end
+      end
+
+      
+      
+      # @!endgroup
+
+
+
+      # ------------------------------------------------------------------
+      # @!group Expressions
+
+      # Create AL language binary expression using AL language
+      # 'lExpr', 'rExpr' and AL language 'operator'.
+      #
+      # @return [Al:BinaryExpression] binary expression 'lExpr' <<operator>> 'rExpr'
+      def ethBinaryExpression( lExpr, operator, rExpr )
+        @logger.debug "#{__method__}: lExpr=#{lExpr}operator=#{operator} rExpr=#{rExpr}" if @logger.debug?
+        alApi.binaryExpression do
+          lval lExpr
+          op operator
+          rval rExpr
+        end
+      end
+      
+      # @return [Al::Expression] expression referencing a variable
+      def ethVariableReferenceExpression( strVariable )
+        alApi.expression(ethVariableReference(strVariable))
+      end
+
+      # @return [Al::Expression] interface operation wrapped to expression
+      def exprInterfaceOperation( contractName, functionName )
+        alApi.expression nInterfaceOperation( contractName, functionName )
+      end
+
+      # @return [AL::Expression] expression for thisCid (=currently
+      #         running contract)
+      def exprRunningContractAddress
+        alApi.expression(refRunningContractAddress)
+      end
+
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Init expressions
+
+      # Map contract member variable type to method, which initializes
+      # member variable.
+      def typeInitDispatcher
+        @typeInitDispatcher ||= {
+          :ElementaryTypeName => method(:initElementaryTypeName),
+          :UserDefinedTypeName => method(:initUserDefinedTypeName),
+          :ArrayTypeName => method(:initArrayTypeName),          
+          :Mapping => method(:initMappingTypeName),
+        }
+      end
+
+      # Create expression to initialize contract member variabable
+      # 'variableAst' (where variableAst sexp_type is known to equal
+      # :ElementaryTypeName).
+      #
+      # Sbuilder domain resolvers map domains to contract member
+      # variables, and domain setup extensions determine actual domain
+      # values in formal model state. This means that translator
+      # cannot determine initial values at tranlation time, instead we
+      # use a template call 'snippetFacadeParamsetDomainInit', which
+      # to identify applicable domain nil value for the contract
+      # member variable.  
+      #
+      # @param hash [Hash] Hash with properties :contractAst and
+      #       :variableAst
+      #
+      # @return [String] mustache template expression to access domain
+      #         assigned for 'variableAst' in currently running setup
+      def initElementaryTypeName( hash )
+
+        contractAst = hash[:contractAst]
+        variableAst = hash[:variableAst]
+        initValue = Constants.snippetFacadeParamsetDomainInit(contractAst['name'], variableAst['name'] )
+        return initValue
+
+      end
+
+      # Create expression to initiali contract member variable for
+      # :ArrayTypeName -type. Init as empty set
+      #
+      # @param hash [Hash] Hash with properties :contractAst and
+      #       :variableAst
+      def initArrayTypeName( hash )
+        initValue =  alApi.tlaSet( )
+        return initValue
+      end
+
+      # Create expresion to initialize contract member variable for
+      # :UserDefinedTypeName -type (=contract)
+      #
+      # @param hash [Hash] Hash with properties :contractAst and
+      #       :variableAst
+      #
+      # @return [TlaNil] Nil expression
+      def initUserDefinedTypeName( hash )
+
+        contractAst = hash[:contractAst]
+        variableAst = hash[:variableAst]
+        
+        initValue = alApi.tlaNil
+        return initValue
+
+      end
+      
+
+      # Create expression to inialize contract member variable
+      # 'variableAst', where variableAst sexp_type is known to be
+      # :Mapping.
+      #
+      # The expression interates a variable over the domain assigned
+      # to 'variableAst' (found using snippet facade template
+      # 'snippetFacadeParamsetDomain' ), and creates a mapping to an
+      # initial value for the domain (found using snippet facade
+      # template 'snippetFacadeParamsetDomainInit').
+      #
+      # That is
+      #
+      #  [ p1 \in {{snippetFacadeParamsetDomain}} : {{snippetFacadeParamsetDomainInit}} ]
+      #
+      # gets translated to smtng line [ a \in d_eth_address |->  0 ]
+      #
+      # @param hash [Hash] Hash with properties :contractAst and
+      #       :variableAst
+      #
+      # @return [Al::TlaRecord] tlaRecord expression initializing all
+      #          mapping source domain values to initial value in the
+      #          domain.
+      def initMappingTypeName( hash )
+        # Retrieve data from hash
+        contractAst = hash[:contractAst]        
+        variableAst = hash[:variableAst]
+        
+        typeAst = variableAst.variableType
+
+        # Type name for mapping variable
+        typeDefName = nContractMappingMemberDefinition( contractAst['name'], variableAst['name'] )
+
+        # p1
+        inputParameter = alApi.inputParameterName
+
+        # mustache template for access inital val in the domain
+        initValue = Constants.snippetFacadeParamsetDomainInit(typeDefName, alApi.outputParameterName)
+        @logger.debug( "#{__method__}: typeDefName#{typeDefName}, alApi.outputParameterName=#{alApi.outputParameterName}=initValue=#{initValue}") if @logger.debug?
+
+        # Translate smthng like: [ p1 \in Set : {{initValue}} ]
+        alApi.tlaRecord(
+          [ alApi.tlaRecordFieldDef(
+            alApi.tlaSetIterate( inputParameter,
+                                 Constants.templateSpecname(
+                                   Constants.snippetFacadeParamsetDomain(typeDefName, inputParameter),
+                                   Constants::META_DOMAIN)
+                               ),
+            initValue            
+          )])
+      end
+      
+      # @!endgroup Init expressions
+
+
+      # ------------------------------------------------------------------
+      # @!group Short handy idioms
+
+      # Check whether service execution status for interface operation
+      # for 'refInterfaceOperation' has failed.
+      #
+      # @param refInterfaceOperation [Al::Reference] reference to
+      #         variable of interface operation
+      #
+      # @return [Al::Expression] InfrastructureServiceGetStatus(
+      #          refInterfaceOperation ) <> TRUE
+      def ethServiceFail( refInterfaceOperation )
+        alApi.unequal( ethGetServiceStatus(refInterfaceOperation), true)
+      end
+
+      # {#ethServiceConstructorCanStart}: Expression, which should
+      # evaluate TRUE to allow service procedure for a contract
+      # constructor to execute.
+      #
+      # Implemation calls directly {#ethServiceMsgCallCanStart} i.e
+      # rule enabling service execution of contract creation and
+      # 'normal' message calls are identical.
+      #
+      # @return [Al::Expression] expression to evaluate allowing
+      #          constructor service to be called
+      def ethServiceConstructorCanStart( parameterName)
+        ethServiceMsgCallCanStart( parameterName )
+      end
+      
+      # @return [Al:TlaExpression] tla-expression NextId( free_address, Nil) 
+      def ethNextId
+        alApi.tlaOperatorCall( specNextId, [alApi.expression(refFreeAddressPool), alApi.tlaNil ] )
+      end
+      
+      # @param contractReference [String,tlaSexp] Reference to bind with 
+      #
+      # @return [Al::Expression] expression to bind
+      # 'contractReference'.address to running contract found in
+      # variable 'nRunningContractAddress'
+      def ethBindToRecipient( contractReference )
+        alApi.equal( alApi.tlaRecordField(contractReference, Constants::SOL_ADDRESS), refRunningContractAddress )
+      end
+
+      # Read execution status of service pointed by
+      # 'interfaceOperation' paramater.
+      #
+      # @param refInterfaceOperation [Al::Reference] reference to
+      #        interface operation to read
+      #      
+      # @return [Al::OperatorExpression] expression to access status
+      def ethGetServiceStatus( refInterfaceOperation )
+        alApi.tlaOperatorCall(alApi.tlaPlainname(Constants::SBUILDER_GET_STATUS), [refInterfaceOperation])
+      end
+
+
+      # Canonize :VariableDeclaration and
+      # VariableDeclarationWithDomain to a hash structure. Exception
+      # for unhandled data types.
+      #
+      # @param variableDef [SexpAst] sexp AST node variable declration
+      #
+      # @return [Hash] hash with :name, :type, :typeName, :domain,
+      #        :isArray -properties. Property :domain is set for
+      #        :VariableDeclarationWithDomain 'variableDef' and for
+      #        'bool' :ElementaryTypeName.
+      #
+      def ethVariableDeclaration( variableDef )
+        case variableDef.sexp_type
+        when :VariableDeclarationWithDomain
+          decl = {
+            :name => variableDef["name"],
+            :type => :VariableDeclarationWithDomain,
+            :domain => variableDef["domain"],
+            :isArray => false,            
+          }
+                      
+        when :VariableDeclaration
+
+          typeDecl =variableDef.nodes_with_match( :ElementaryTypeName )
+          raise TranslatorException, "TODO: add more type support #{variableDef}" if typeDecl.nil? or typeDecl.length != 1
+          typeDecl = typeDecl.first
+          domain = Constants::DOMAIN_BOOLEAN if typeDecl["name"] == Constants::SOL_BOOLEAN_TYPE            
+          decl = {
+            :name => variableDef["name"],
+            :type => typeDecl.sexp_type,
+            :typeName => typeDecl["name"],
+            :domain => domain,
+            :isArray => variableDef.children[0].sexp_type == :ArrayTypeName ? true : false
+          }
+        else
+          raise TranslatorException, "TODO: unknown sexp_type  #{variableDef.sexp_type} for #{variableDef}"
+        end
+        @logger.info "#{__method__}: varaible=#{variableDef["name"]} -> decl=#{decl}"
+        decl
+      end
+      
+
+      # @return [Al::Expression] Expression accessing first element in
+      # sequence modeling a stack
+      def ethStackTop( variableName )
+        alApi.tlaOperatorCall(
+          alApi.tlaPlainname("Head"),
+          [
+            ethVariableReferenceExpression( variableName )
+          ])
+      end
+
+      # @return [Al:Expression] Expression for tail of stack modeling
+      # popping an top element from stack
+      def ethStackRest( variableName )
+        alApi.tlaOperatorCall(
+          alApi.tlaPlainname("Tail"),
+          [
+            ethVariableReferenceExpression( variableName )
+          ])        
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Helpers
+
+      # @param mapper [Hash] key=symbol to choose, value = lamba
+      # @param ast [AstSext] AST node to dispatch 
+      def self.dispatcher( mapper, key, ast )
+        # Error checks
+        raise TranslatorException, "Missing dispatcher key to dispatch one #{mapper.keys.join(',')}. Error dispatching ast node: #{ast}"  if key.nil?
+        raise TranslatorException, "Dispatch key '#{key}' not found in known keys:#{mapper.keys.join(',')}. Error dispatching ast node: #{ast}" if mapper[key].nil?
+
+        # invoke lamba
+        mapper[key][ast]
+
+      end
+
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group Create names
+      
+
+      # @return [String] wrap {nInterfaceOperation} to an eth template
+      def nEthnInterfaceOperation( contractName, functionName )
+        Constants.templateSpecname(nInterfaceOperation( contractName, functionName ))
+      end
+
+
+      # @return [String] type name for contract e.g. for contract
+      #         'Simple' this gets eventually translated to t_Simple
+      def nContractType( contractName )
+        contractName
+      end
+
+      # @return [String] name mapping definition of member variable
+      #      'memberName' in contract 'contracName'
+      def nContractMappingMemberDefinition( contractName, memberName )
+        "#{contractName}_#{memberName}"
+      end
+
+      # @return [String] combine 'contractName' and 'functionName' to
+      #      name of intefaceOperation (i.e. string
+      #      'contractName(operationName)' where operationName is emtpy
+      #      for constructors)
+      def nInterfaceOperation( contractName, functionName )
+        "#{contractName}(#{nContractFunctionOperation(contractName, functionName)})"
+      end
+
+      # @return [String] name of contract response type 
+      def nContractFunctionResponseType( contractName, functionName )
+        nInterfaceOperation( contractName, functionName )
+      end
+
+      # @return [String] empty string for constructor, else functionName
+      def nContractFunctionOperation( contractName, functionName )
+        isConstructor(contractName, functionName)  ? "" : functionName
+      end
+
+      # @return [Boollean] true for constructors where contractName == functionName
+      def isConstructor( contractName, functionName )
+        contractName == functionName
+      end
+
+      def nPopState
+        "popState"
+      end
+      
+      # @return [String] name account variable
+      def nAccount
+        Constants::VARIABLE_ACCOUNTS
+      end
+
+      # @return [String] name of storage root
+      def nStorageRoot
+        Constants::VARIABLE_STORAGE_ROOT
+      end
+
+      # @return [String] name of total value mined
+      def nMined
+        Constants::VARIABLE_MINED
+      end
+
+      def specNextId
+        Constants.templateSpecname( Constants::RUNTIME_NEXTID)
+      end
+
+      def specFreeAddress
+        Constants.templateSpecname( Constants::VARIABLE_ADDRESS_FREE)
+      end
+      
+      # @return [Al::Expression] expression msg.recipient
+      def ethMsgRecipient( contractName, functionName )
+        alApi.expression( refMsgRecipient(contractName, functionName ))
+      end
+
+      # @return [String] Name of local variable holding contract
+      # 'this'
+      def nRunningContractAddress # 
+        Constants::VARIABLE_LOCAL_CURRENT_CONTRACT
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group References
+
+      def ethFunctionParameterExpression( contractName, functionName, parameterName=nil )
+        alApi.expression( ethFunctionParameterReference(contractName, functionName, parameterName))
+      end
+
+      # Create a 'Reference' to input variable of contract
+      # 'contractName' function 'functionName', (and to
+      # 'parameterName' if given).
+      #
+      # @param contractName [String] name contract
+      #
+      # @param functionName [String] name function
+      #
+      # @param parameterName [String] name of parameter to refer to,
+      #        nil refere to variable
+      #
+      # @return [Al:ReferenceExpression] expression to access
+      # 'parameter' in 'transaction', 'operator' or 'macro'
+
+      def ethFunctionParameterReference( contractName, functionName, parameterName=nil )
+        operationName = nContractFunctionOperation(contractName, functionName )
+        alApi.reference( [Constants::META_ETH, contractName, operationName], parameterName )
+      end
+      
+
+      # @return [Al::ReferenceExpression] reference to 'parameterName'
+      # in 'contractName'. Use 'RUNTIME_GET_ELEMENT_SAFE' to access
+      # correct entry from 'storageRoot' (also in case when entry is
+      # not found)
+      #
+      # @param variableRef [Al::Reference] refAccount or
+      # refStorageroot specification code variable to access
+      #
+      # @param parameterName [String] field name of contract entry to access
+      #
+      # @param refAddress [Al::Reference] address idenfifying contract
+      # to access
+      #
+      def ethContractVariableReference( variableRef, refAddress, parameterName )
+        alApi.tlaOperatorCall(
+          Constants.templateSpecname(Constants::RUNTIME_GET_ELEMENT_SAFE),
+          [
+            alApi.expression(variableRef),
+            alApi.expression(Constants::FIELD_NAME_ADDRESS),
+            refAddress,
+            alApi.constantExpression(parameterName ),
+
+          ]
+        )
+        # alApi.reference( [Constants::META_ETH, Constants::VARIABLE_STORAGE_ROOT], parameterName )
+      end
+
+      # Referencing local variable 'nameLocal'
+      #
+      # @param nameLocal [String] name of local variable to create a
+      # reference to
+      def ethLocalReference( nameLocal, parameterName=nil )
+        alApi.reference( nameLocal )
+      end
+
+      # @param domain [String] name domain to reference to 
+      def ethDomainReference( domain )
+        alApi.reference( [Constants::META_DOMAIN, domain] )
+      end
+
+      # @param strVariable [String] name of tla variable to reference
+      def ethVariableReference( strVariable )
+        alApi.reference( [Constants::META_ETH, strVariable] )
+      end
+
+      def refStorageRoot
+        ethVariableReference(nStorageRoot)
+      end
+
+      # @return [Al::Reference] refence to currently running contract
+      # (through local variable with the name 'nRunningContractAddress')
+      def refRunningContractAddress
+        ethLocalReference(nRunningContractAddress)
+      end
+
+
+      def refAccount
+        ethVariableReference(nAccount)
+      end
+
+      def refFreeAddressPool
+        ethVariableReference(Constants::VARIABLE_ADDRESS_FREE)
+      end
+
+      def refMsgRecipient( contractName, functionName )
+        ethFunctionParameterReference( contractName, functionName, Constants::FIELD_NAME_RECIPIENT )
+      end
+
+      # @!endgroup
+      
+      
+    end
+  end
+end
+