sbuilder-ethereum 0.0.6

data/lib/sbuilder/generate/tla_element_text.rb

@@ -0,0 +1,703 @@
+module Sbuilder
+  module Ethereum
+
+
+    class  TlaElementText
+
+      # operator body 
+      OP_INFRASTRUCTURE_SVC_RETURN="TRUE"
+
+      # OP_INFRA_SET_RESPONSE="InfrastructureServiceResponse"
+      OP_INFRA_RETURN="InfrastructureServiceReturn"
+      OP_INFRA_GET_RESPONSE="InfrastructureServiceGetResponse"
+      OP_INFRA_GET_STATUS="InfrastructureServiceGetStatus"
+      OP_INFRA_STATUS_INIT="InfrastructureServiceInit"      
+      OP_INFRA_THROW="schedule_throw"
+      OP_INFRA_UPDATE_TOP='UpdateTop'
+      OP_INFRA_RESPONSES='responses'
+
+      # ------------------------------------------------------------------
+      # Wrap snippets - allow extracting snippets from specification code
+      
+      SNIPPET_HEADER="(* ETH-SNIPPET: {{metatype}}:{{appName}} --> {{specName}} *)\n"
+      SNIPPET_FOOTER="(* ETH-SNIPPET-END *)\n"      
+
+      # ------------------------------------------------------------------
+      # TLA constants
+      
+      TLA_LABEL_ABORT = "_abort"
+      TLA_LABEL_END = "_end"      
+      TLA_LABEL_FAIL = "_fail"      
+      # TLA_STATUS_OK   = "status-200"
+      TLA_RECORD_FIELD_FOR_SINGLE_VALUE = "dummy"
+      TLA_VARIABLE_STEP="step"
+      TLA_VARIABLE_NOW="now"
+      TLA_LOCALS_VARIABLE="locals"
+      TLA_SERVICE_COMPLETION="ethereum_service_done"
+      TLA_SERVICE_START="ethereum_service_start"
+      TLA_SERVICE_PUSH="ethereum_service_push"
+      TLA_SERVICE_POP="ethereum_service_pop"      
+      TLA_SERVICE_STATUS_OK="status_OK"
+      TLA_SERVICE_STATUS_FAIL="status_FAIL"
+      TLA_SERVICE_STATUS_ABORT="Abort"      
+      
+      # ------------------------------------------------------------------
+      # appNames
+      ACCOUNT_TYPE = "Accounts"
+      # https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_newaccount
+      INTERFACE_ACCOUNT_NEW="personal_newAccount"
+      SERVICE_ACCOUNT_NEW="#{INTERFACE_ACCOUNT_NEW}()"
+      SERVICE_ACCOUNT_DONE="#{INTERFACE_ACCOUNT_NEW}_done"            
+      # https://github.com/ethereum/go-ethereum/wiki/Mining#cpu-mining-with-geth
+      INTERFACE_MINE="geth_mine"
+      # INTERFACE_ACCOUNT_SEND_TRANSACTION="sendTransaction"
+      ACCOUNT_STATE = ACCOUNT_TYPE
+
+      # ------------------------------------------------------------------
+      # FRAMEWORK -services
+      FW_SVC_UNIQUE_ELEMENTS='uniqueElements'
+      FW_OP_ELEMENT_EXISTS = 'elementExists'
+      FW_OP_GET_ELEMENT = "getElement"
+
+      FW_STATE_ACCOUNTS = "accounts"
+      FW_STATE_ACCOUNTS_TEMP = "accounts_temp"      
+      # FW_STATE_GAS_USED = "gasUsed"
+      # FW_STATE_GAS_USED_TEMP = "gasUsed_temp"      
+      FW_STATE_STORAGE_ROOT = 'storageRoot'
+      FW_STATE_STORAGE_ROOT_TEMP = 'storageRoot_temp'
+      FW_STATE_MINED = 'mined'
+      
+      ETH_OPEATOR_INTRINSIC_GAS = 'intrinsicGas'
+      ETH_OPEATOR_TRANSACTION_GAS = 'transactionGas'
+      ETH_OPEATOR_UP_FRONT_COST = 'upFrontCost'
+      ETH_OPEATOR_GAS_VALUE = 'gasValue'
+      
+      # ------------------------------------------------------------------
+      # Domains
+
+      # ------------------------------------------------------------------
+      #
+
+      # metatype used to create snippets within this module
+      METATYPES = {
+        :state => { :name => "Solidity contract state" },
+        :state_temp =>  { :name => "Solidity  contract state during transaction" },
+        :solidity_contract_function => { :name => "Procedures implementing interface services" },
+        :service_entry => { :name => "Macros called from process" },
+        :type => { :name => "Type sets" },
+        :op_new => { :name => "Operator to create new types" },
+        :eth => { :name => "Ethereum infrastructure", :prefix => 'eth' },
+        :dispatcher => { :name => "Dispatch contract methods", :prefix => 'dispatch' },
+        :dispatcher_ret => { :name => "Dispatch contract methods return", :prefix => 'dispatch_ret' },        
+      }
+      
+      # ------------------------------------------------------------------
+      # Ethreum base snippet specs, where +:loaderType+ refers to
+      # lambdas defined in +SNIPPETLOADERS+.
+      
+      ETHEREUM_ENVIRONMENT_SNIPPETS = [
+        
+        # ethreum domains
+        {
+          :loaderType => 'addDomains',
+          :definition => [ Constants::DOMAIN_ADDRESS, Constants::DOMAIN_VALUE, Constants::DOMAIN_GAS, Constants::DOMAIN_CODE_HASH, ]
+        },
+        
+        # Interface personal_newAccount:
+        #
+        # Generates a new private key and stores it in the key store
+        # directory. The key file is encrypted with the given
+        # passphrase. Returns the address of the new account.
+        #
+        # @see https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_newaccount
+        # 
+        {
+          :loaderType => 'addInterface',
+          :definition => s( :function, INTERFACE_ACCOUNT_NEW, "", 
+                            s( :input,
+                             ),
+                            s( :output,
+                               s( :parameter, Constants::FIELD_NAME_ADDRESS, Constants::DOMAIN_ADDRESS),  
+                             ),
+                          )
+        },
+
+        # Geth command line geth --mine
+        #
+        #
+        # must have etherbase address set.
+        #
+
+        {
+          :loaderType => 'addInterface',
+          :definition => s( :function, INTERFACE_MINE, "",
+                            s( :input,
+                               s( :parameter, Constants::FIELD_NAME_VALUE, Constants::DOMAIN_VALUE),
+                               s( :parameter, Constants::FIELD_NAME_BENEFICIARY, Constants::DOMAIN_ADDRESS),                                 
+                             ),
+                            s( :output,
+                             ),
+                          )
+        },
+        
+
+        {
+          :loaderType => 'addDefinition',
+          :definition => s( :function, ACCOUNT_TYPE,
+                            s( :properties,
+                               s( :parameter, Constants::FIELD_NAME_ADDRESS, Constants::DOMAIN_ADDRESS),
+                               s( :parameter, Constants::FIELD_NAME_CODE_HASH, Constants::DOMAIN_CODE_HASH),                                 
+                               s( :parameter, Constants::FIELD_NAME_BALANCE, Constants::DOMAIN_VALUE),  
+                             ),
+                          )
+        },
+
+      ]
+
+      # Lambda functions to load loaderSpecs defined in
+      # +ETHEREUM_SNIPPETS+ into sbuilder context.
+      #
+      # Lamda functions are executed in SexpProcessorTla context
+      # (i.e. they may refer to methods in this class,
+      # e.g. 'addSnippet')
+
+      SNIPPETLOADERS = {
+        
+        'addDomains' => ->( spec ) do
+          # iterate string of domain names to add
+          domainNames = spec[:definition]
+          domainNames.each{ |domainName| addDomainName( domainName ) }
+        end,
+        
+        'addInterface' => ->( spec ) do
+          interface = spec[:definition]
+          # define expects input and output to be s( s(:type, name, domain), ... )
+          addInterface( Interface.define( interface[1], interface[2], interface.t(:input), interface.t(:output) ) )
+        end,
+
+        'addDefinition' => ->( spec ) do
+          definition = spec[:definition]
+          # define expects input and output to be s( s(:type, name, domain), ... )
+          addDefinition( Definition.define( definition[1], definition.t(:properties) ))
+        end,
+        
+      }
+
+      # ------------------------------------------------------------------
+      # Constant base snippets
+
+      FIXED_SNIPPETS=
+        [
+
+          # ------------------------------------------------------------------
+          # Base snippets - i.e. no connection to ethreums
+          {
+            :comment => "macro to update existing contract",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'update_existing_contract',
+            :body =>
+            <<-EOS.unindent,
+            macro update_existing_contract() {
+               print <<"update_existing_contract">>;
+            }
+            EOS
+          },
+
+          {
+            :comment => "Add element to sequence head",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'Push',
+            :body =>
+            <<-EOS.unindent,
+            Push( s, e ) == <<e>> \\o s
+            EOS
+          },
+
+          {
+            :comment => "Update element to sequence head",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => OP_INFRA_UPDATE_TOP,
+            :body =>
+            <<-EOS.unindent,
+            UpdateTop( s, e ) == <<e>> \\o Tail(s)
+            EOS
+          },
+
+          {
+            :comment => "Propgate top element to stack & pop",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'PropageTopAndPop',
+            :body =>
+            <<-EOS.unindent,
+            PropageTopAndPop( s ) == [i \\in 1..(Len(s) -1 )|-> s[1] ] 
+            EOS
+          },
+          
+          {
+            :comment => "Propgate top element to stack & pop",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'PropageOnStack',
+            :body =>
+            <<-EOS.unindent,
+            (* PropageOnStack( s, v ) == [i \\in 1..Len(s) |-> v ]  *)
+            PropageOnStack( s, v ) == [i \\in 1..Len(s) |-> IF i = 1 THEN v ELSE s[i] ]
+            EOS
+          },
+          
+
+          {
+            :comment => "macro to create new contract",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'create_new_contract',
+            :body =>
+            <<-EOS.unindent,
+            macro create_new_contract( var, entry, idPool, id ) {
+               print <<"create_new_contract", entry >>;
+               var := var \\union { entry };
+               idPool := idPool \\ {id};
+            }
+            EOS
+          },
+
+          {
+            :comment => "stable when process finished running",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'Stable',
+            :body =>
+            <<-EOS.unindent,
+            Stable == tx_running = FALSE
+            EOS
+          },
+
+          {
+            :comment => "Sum record fields",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'SumRecordField',
+            :body =>
+            <<-EOS.unindent,
+            RECURSIVE SumRecordField(_,_)
+            (* 
+             *  Sum of field 'f' of record elements in set 'S'
+             * 
+             *  @param [Set] S set of records
+             *  @param [String] f name of field 
+             *)
+            SumRecordField(S,f) == 
+               IF S = {} THEN 0
+               ELSE LET x == CHOOSE x \\in S : TRUE
+                    IN x[f] + SumRecordField(S \\ {x}, f)
+            EOS
+          },
+
+          {
+            :comment => "Sum function",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'SumOfFunction',
+            :body =>
+            <<-EOS.unindent,
+            RECURSIVE SumOfFunction(_)
+            (*
+             * Sum of function values
+             *
+             * @param [Sequnce|Function] F to sum over
+             *
+             *)
+            SumOfFunction( F ) ==
+               IF F = <<>> THEN 0
+               ELSE LET x == CHOOSE x \\in DOMAIN F : TRUE
+                    IN F[x] + SumOfFunction( [ v \\in DOMAIN F \\ {x} |-> F[v] ] )
+            EOS
+          },
+
+          {
+            :comment => "operator to check element uniques in a set",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => FW_SVC_UNIQUE_ELEMENTS, 
+            :body =>
+            <<-EOS.unindent,
+            #{FW_SVC_UNIQUE_ELEMENTS}( set, key ) == \\A e1  \\in set:  \\A e2 \\in set:   e1[key] = e2[key] => e1 = e2
+            EOS
+          },
+
+          {
+            :comment => "Take given 'address', or choose any address from pool of 'ids'. Notice (CHOOSE operation is deterministic)",
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => 'NextId',
+            :body =>
+            <<-EOS.unindent,
+            NextId( ids, address ) == CHOOSE x \\in ids: (address = x /\\ address # Nil) \\/ address = Nil
+            EOS
+          },
+
+
+          # ------------------------------------------------------------------
+          # Ethereum related snippets
+
+          # Service: personal_newAccount
+          {
+            :comment  => 'Interface service "createAccount"',
+            :metatype =>  'eth',
+            :appName => INTERFACE_ACCOUNT_NEW,
+            :file => 'personal_newAccount/personal_newAccount_service.tla'
+          },
+
+          {
+            :comment  => 'Interface entry for "createAccount"',           
+            :metatype =>  'service_implementation',
+            :appName => SERVICE_ACCOUNT_NEW,
+            :file => 'personal_newAccount/personal_newAccount_entry.tla',
+          },
+
+          {
+            :comment  => 'Finalize "personal_newAccount"',           
+            :metatype =>  Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => SERVICE_ACCOUNT_DONE,
+            :file => 'personal_newAccount/personal_newAccount_done.tla',
+          },
+
+          {
+            :comment  => "Use completion #{SERVICE_ACCOUNT_DONE} for service #{SERVICE_ACCOUNT_NEW}",          
+            :metatype =>  Sbuilder::Facade::META_MODEL_SERVICE_COMPLETION,
+            :appName => SERVICE_ACCOUNT_NEW,
+            :specName => SERVICE_ACCOUNT_DONE,
+          },
+
+          # Service: mine
+          {
+            :comment  => 'Interface service "mine"',
+            :metatype =>  'eth',
+            :appName => 'mine',
+            :file => 'mine/mine_service.tla'
+          },
+
+          {
+            :comment  => 'Interface entry for "mine"',           
+            :metatype =>  'service_implementation',
+            :appName => 'geth_mine()',
+            :file => 'mine/mine_entry.tla',
+          },
+
+
+          # State:
+
+          {
+            :comment  => 'Accounts created in the system',                        
+            :metatype =>  'eth',
+            :appName => FW_STATE_ACCOUNTS,
+            :file => 'eth/accounts_state.tla',
+          },
+                    
+          {
+            :comment  => 'Account storageRoot (contract state)',                        
+            :metatype => 'eth',
+            :appName => FW_STATE_STORAGE_ROOT,
+            :file => 'eth/storageRoot.tla',
+          },
+
+          {
+            :comment  => 'storageRoot temporary state during service execution',                        
+            :metatype => 'eth',
+            :appName => FW_STATE_STORAGE_ROOT_TEMP,
+            :file => 'eth/storageRoot_temp.tla',
+          },
+
+          
+          {
+            :comment  => 'accounts temporary state during service execution',                        
+            :metatype => 'eth',
+            :appName => FW_STATE_ACCOUNTS_TEMP,
+            :file => 'eth/accounts_temp.tla',
+          },
+
+          
+          {
+            :comment  => 'Set of unassigned addresses',                        
+            :metatype => 'eth',
+            :appName => 'address_free',
+            :file => 'eth/address_free.tla',
+          },
+
+          # {
+          #   :comment  => 'Cumulative amount of gas used',                        
+          #   :metatype => 'eth',
+          #   :appName => FW_STATE_GAS_USED,
+          #   :file => "eth/#{FW_STATE_GAS_USED}.tla",
+          # },
+
+          # {
+          #   :comment  => 'Cumulative amount of gas used during service execution',                        
+          #   :metatype => 'eth',
+          #   :appName => FW_STATE_GAS_USED_TEMP,
+          #   :file => "eth/gasUsed_temp.tla",
+          # },
+
+          {
+            :comment  => 'Return element form a set by id',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC, 
+            :appName => FW_OP_GET_ELEMENT,
+            :file => 'operators/getElement.tla',
+          },
+
+          {
+            :comment  => 'Ensure that element exists',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC, 
+            :appName => FW_OP_ELEMENT_EXISTS,
+            :file => 'operators/elementExists.tla',
+          },
+
+          {
+            :comment  => 'Value mined',                        
+            :metatype => 'eth',
+            :appName => FW_STATE_MINED, 
+            :file => 'eth/mined_state.tla',
+          },
+
+          # transction & status stuff
+          {
+            :comment  => 'Pop ethreum block context from stack',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_COMPLETION, 
+            :file => 'transaction/ethereum_service_done.tla',
+          },
+
+          {
+            :comment  => 'Start ethereum transaction, create stack',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_START, 
+            :file => 'transaction/ethereum_service_start.tla',
+          },
+
+          {
+            :comment  => 'Push ethereum block context to stack',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_PUSH, 
+            :file => 'transaction/ethereum_service_push.tla',
+          },
+
+
+          {
+            :comment  => 'Finish service procedure: propage stack top on succcess && pop',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_POP, 
+            :file => 'transaction/ethereum_service_pop.tla',
+          },
+
+          {
+            :comment  => 'Service ran successfully',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_STATUS_OK, 
+            :file => 'transaction/status_ok.tla',
+          },
+          
+          
+          {
+            :comment  => 'Service execution failed',                        
+            :metatype => Sbuilder::Facade::META_MODEL_FRAMEWORK_SVC,
+            :appName => TLA_SERVICE_STATUS_FAIL, 
+            :file => 'transaction/status_fail.tla',
+          },
+
+          # {
+          #   :comment  => 'Interface entry for "sendTransaction"',
+          #   :metatype =>  'service_implementation',
+          #   :appName => 'sendTransaction()',
+          #   :file => 'sendTransaction_entry.tla',
+          # },
+
+          # {
+          #   :comment  => 'Interface service for "sendTransaction"',
+          #   :metatype =>  'framework-svc',
+          #   :appName => 'sendTransaction',
+          #   :file => 'sendTransaction_service.tla',
+          # },
+
+          {
+            :comment  => 'Operator calculating value of gas (using gasPrice)',
+            :metatype =>  'framework-svc',
+            :appName => ETH_OPEATOR_GAS_VALUE,
+            :file => 'operators/gasValue.tla',
+          },
+
+          {
+            :comment  => 'Price of gas used to calculate value of gas',            
+            :metatype =>  'framework-svc',
+            :appName => 'gasPrice',
+            :file => 'operators/gasPrice.tla',
+          },
+          
+          {
+            :comment  => 'Gas paid prior to execution',            
+            :metatype =>  'framework-svc',
+            :appName => ETH_OPEATOR_INTRINSIC_GAS,
+            :file => "operators/#{ETH_OPEATOR_INTRINSIC_GAS}.tla",
+          },
+
+          {
+            :comment  => 'Amount of gas consumed when running the transaction',            
+            :metatype =>  'framework-svc',
+            :appName => ETH_OPEATOR_TRANSACTION_GAS,
+            :file => 'operators/transactionGas.tla',
+          },
+          
+          {
+            :comment  => 'Acount balance must exceed upFronCost before starting',            
+            :metatype =>  'framework-svc',
+            :appName => ETH_OPEATOR_UP_FRONT_COST, 
+            :file => "operators/#{ETH_OPEATOR_UP_FRONT_COST}.tla",
+          },
+
+
+          # ------------------------------------------------------------------
+          # correctness
+          
+          {
+
+            :metatype =>  'framework-svc',
+            :appName => 'accounts_unique',
+            :file => 'correctness/accounts_unique.tla'
+          },
+
+          {
+
+            :metatype =>  'framework-svc',
+            :appName => 'storageRoot_unique',
+            :file => 'correctness/storage_root_unique.tla'
+          },
+
+          {
+            :comment  => 'Invariant operator to check that accounts are valid',
+            :metatype =>  'framework-svc',
+            appName: 'accounts_valid',
+            :file => 'correctness/accounts_valid.tla',
+          },
+            
+          {
+            :comment  => 'SUM( accounts.balance ) + mined == 0',
+            :metatype =>  'framework-svc',
+            appName: 'total_value',
+            :file => 'correctness/total_value.tla',
+          },
+            
+          {
+            :comment  => 'Invariant operator to account type',
+            :metatype =>  'framework-svc',
+            appName: 'accounts_type',
+            :file => 'correctness/accouns_type.tla',
+          },
+            
+        ]
+
+      def self.fixedSnippetSpecs
+        FIXED_SNIPPETS
+      end
+
+      # @return [Boolean] true if  numeric type name 'uint', ..
+      def self.solIsNumericType( solType )
+        ['uint'].include?( solType )
+      end
+
+      ##
+      # @return [Hash] loaderSpec to feed lamdba returned by
+      # +getLoaderLamdba+
+      def self.ethereumSnippetSpecs
+        ETHEREUM_ENVIRONMENT_SNIPPETS
+      end
+
+      ## 
+      # @return [Lambda] lamda to process +loaderSpec+ hashes returned
+      # by +ethereumSnippetSpecs+. Lamdba is executed in
+      # SexpProcessorTla context.
+      def self.getLoaderLamdba( spec )
+        loaderType = spec[:loaderType]
+        raise SbuilderEtherumException, "Unknwon loaderType '#{loaderType}' in #{spec}" unless SNIPPETLOADERS[loaderType]
+        SNIPPETLOADERS[loaderType]
+      end
+
+      # Map table to map solc (javascript) operator to TLA operator
+      SOLC_OPEATOR_2_TLA = {
+        '<'  => '<',
+        '>'  => '>',
+        '=='  => '=',
+        '<='  => '<=',
+        '>='  => '>=',        
+        '!=' => '#',
+        '!'  => '~',
+        '+'  => '+',        
+        '-'  => '-',
+      }
+
+      ##
+      # @return [String] tlaOperator corresponding to solcOparator
+      def self.solcOperator2Tla( solcOperator )
+        tlaOperator = SOLC_OPEATOR_2_TLA[solcOperator]
+        raise SbuilderEtherumException, "Unknwon solcOparator '#{solcOperator}', known operators #{SOLC_OPEATOR_2_TLA.keys.join(',')}" if tlaOperator.nil?
+        tlaOperator
+      end
+
+      # @return [String] name of composite variable 'expVariableDecl'
+      # definition in contract 'expContract'
+      def self.compositeDefinitionName( expContract, expVariableDecl )
+        name = "#{expContract.name}_#{expVariableDecl.name}"
+      end
+
+      ##
+      # These are added to all contract messages.
+      #
+      #
+      # @param [String] reqOrResponse 'request' or 'response'
+      #
+      # @param [String] messageType true for 'constructor',
+      # false 'method-call' return different fields
+      #
+      # @return [Sexp:Array] msgProperties
+      # @option msgProperties [0] :parameter      
+      # @option msgProperties [1] name
+      # @option msgProperties [2] domain_name      
+      def self.commonMsgProperties( reqOrResponse, messageType )
+        props =
+          {
+            'request' =>  {
+              true  =>
+              # constructor
+              s(
+                s( :parameter, Constants::FIELD_NAME_SENDER, Constants::DOMAIN_ADDRESS),
+                s( :parameter, Constants::FIELD_NAME_ORIGINATOR, Constants::DOMAIN_ADDRESS),            
+                s( :parameter, Constants::FIELD_NAME_VALUE, Constants::DOMAIN_VALUE ),
+                # s( :parameter, Constants::FIELD_NAME_GAS, Constants::DOMAIN_GAS ),
+              ),
+              false =>
+              # contract function
+              s(
+                s( :parameter, Constants::FIELD_NAME_SENDER, Constants::DOMAIN_ADDRESS),
+                s( :parameter, Constants::FIELD_NAME_ORIGINATOR, Constants::DOMAIN_ADDRESS),            
+                s( :parameter, Constants::FIELD_NAME_RECIPIENT, Constants::DOMAIN_ADDRESS),            
+                s( :parameter, Constants::FIELD_NAME_VALUE, Constants::DOMAIN_VALUE ),
+                # s( :parameter, Constants::FIELD_NAME_GAS, Constants::DOMAIN_GAS ),
+              ),
+
+            },
+            'response' =>  {
+              # constructor
+              true  => s(  
+                s( :parameter, Constants::FIELD_NAME_ADDRESS, Constants::DOMAIN_ADDRESS),
+              ),
+              false => s()
+            },
+            'response-bool' =>  {
+              # constructor
+              true  => s(  
+                s( :parameter, Constants::FIELD_NAME_STATUS, Constants::DOMAIN_BOOLEAN),
+              ),
+              false => s(
+                s( :parameter, Constants::FIELD_NAME_STATUS, Constants::DOMAIN_BOOLEAN),
+              )
+            }
+          }
+        raise SbuilderEtherumException, "Unknwon messageType '#{messageType}', expecting #{props[reqOrResponse].keys.join(',')}" unless props[reqOrResponse][messageType]
+        props[reqOrResponse][messageType]
+      end
+
+    end
+    
+  end
+end