tla-trace-filter 0.0.3

data/mustache/api-call.mustache

@@ -0,0 +1,34 @@
+{{!
+
+  Root Mustache template
+
+  Can access to following data:
+  
+  :options   : options passed from command line
+
+  :interface_started : 'true' when transition represents interface
+                       invocation, 'false' when transition represents
+                       service execution
+
+  :interface : interface definition for transition step interface with
+               properties :source.sourceModule and :source.sourceLine
+               pointing to solidity source of the transition
+
+  :parsed:   data parsed from TLC trace file with properties:
+	    - :line= string which triggers state space dump to parse state space
+	    - :actionLine=  line number (parser from ':line')
+            - :state_space = state variables as parsed from the dump, particularly
+	      variable :step, which is used as a key to 'interfaces.yaml'
+	      to create :source reference
+
+  API call releated stuff
+  
+  :inputState : state space parsed before making API-call
+  :outputState : state space parsed after making API-call
+  :now : time when making :interface -call
+
+}}{{>api-call-main}}{{!
+Local Variables:
+require-final-newline: nil
+End:
+}}

data/spec/cli/cli_spec.rb

@@ -0,0 +1,73 @@
+require_relative "../../lib/cli/cli.rb"
+
+describe TlaTraceFilter::Cli do
+
+  # Found in namapce
+  it { expect( described_class ).to be_a Class }
+
+  let( :cli ) { described_class.new  }
+
+  it { expect( cli ).to be_a( Thor ) }
+
+  let( :cli ) { described_class.new  }
+
+  # ------------------------------------------------------------------
+  # Helpers
+
+  # Captures the output for analysis later
+  #
+  # @example Capture `$stderr`
+  #
+  #     output = capture(:stderr) { $stderr.puts "this is captured" }
+  #
+  # @param [Symbol] stream `:stdout` or `:stderr`
+  # @yield The block to capture stdout/stderr for.
+  # @return [String] The contents of $stdout or $stderr
+
+  # # https://github.com/docwhat/homedir/blob/homedir3/spec/spec_helper.rb
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+
+
+  # ------------------------------------------------------------------
+  describe "module interface" do
+    describe "class-methods" do
+      subject { described_class }
+      %i[ help ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+
+    describe "instance-methods" do
+      subject { described_class.new }
+      %i[ add_links api_calls  ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+  end
+
+
+  # ------------------------------------------------------------------
+  # commands
+  
+  describe ".help" do
+    let( :help ) { capture(:stdout) { cli.help } }
+    %w[ help version ].each do |cmd|
+      describe "Help documents command #{cmd}" do
+        it { expect( help ).to match /#{cmd}.*#/ }
+      end 
+    end
+  end 
+
+end 

data/spec/filter/filter_spec.rb

@@ -0,0 +1,53 @@
+require_relative "../spec_helper.rb"
+
+describe TlaTraceFilter::Filter do
+
+  # FOund in namespace
+  it { expect( described_class ).to be_a Class }
+
+  # ------------------------------------------------------------------
+  # @!group Interfae
+
+  describe "module interface" do
+    describe "class-methods" do
+      subject { described_class }
+      %i[  ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+
+    describe "instance-methods" do
+      subject { described_class.new }
+      %i[ filter ].each do |op|
+        specify { is_expected.to respond_to(op) }
+      end
+    end
+  end
+  
+  # @!endgroup
+
+  describe ".start" do
+    let( :start ) { described_class.new  }
+    it { expect( start ).to be_a described_class }
+
+    let ( :filter ) do
+      filterLines.map do |line|
+        start.filter( line)
+      end
+    end
+
+    describe "emptylines" do
+      let( :filterLines ) { []  }
+      it { expect( filter ).to eql  filterLines } 
+    end
+
+    describe "no changes" do
+      let( :filterLines ) { [ "aa", "bb"]  }
+      it { expect( filter ).to eql  filterLines } 
+    end
+    
+    
+  end 
+
+  
+end 

data/spec/fixtures/interfaces.yaml

@@ -0,0 +1,22 @@
+# Interfaces Model interfaces
+#  - modelData interfaces
+#  - template  interfaces/interface_mapper.mustache
+---
+- :interface_name: _customer_post_
+  :interface_operation: "/customer(post)"
+  :implementation: customer_post
+  :source:
+    :sourceModule: test.sol
+    :sourceLine: 89
+    :sourceColumn: 
+  :completion: 
+  _comma: ''
+  :parameter_definitions:
+  - :parameter_name: customer
+    :isArray: false
+    :type: Customer
+    :metatype: definitions
+    _comma: ''
+  :response_definitions: false
+
+

data/spec/fixtures/model.tla

@@ -0,0 +1,1195 @@
+Model version: Model version file /home/jj/work/sbuilder-eth/tmp/aruba/solidity/new-account/VERSION not found
+Generator version: 0.3.5-SNAPSHOT
+Generation timestemp: 2017-10-02 07:52:38
+
+
+------------------------------ MODULE model ------------------------------
+
+EXTENDS TLC, FiniteSets, Sequences, Integers
+
+(* Execution environment *)
+
+CONSTANTS Steps           \* Sequence process/parameter records
+(* Magic values *)
+
+CONSTANTS WildCard        \* bind to any value
+CONSTANTS Nil             \* no value
+CONSTANTS Abort           \* response.status error
+
+      \* Extension point template extend/extend_const.mustache:
+
+      
+
+
+(******************************************************************
+Domain definitions
+ - modelData domains
+ - template  domains.mustache
+ ******************************************************************)
+ 
+CONSTANTS d_intti
+CONSTANTS d_Intti
+CONSTANTS d_domari
+CONSTANTS d_eth_address
+CONSTANTS d_eth_value
+CONSTANTS d_eth_gas
+CONSTANTS d_eth_code_hash
+CONSTANTS d_BOOLEAN
+
+
+
+(* schedule operators  *)
+
+\* Notice:  cardinality of +steps+ sequence elements is 1, change in future?
+ProcessStep( stepdefs ) ==  (CHOOSE s \in Head( stepdefs ): TRUE )
+ProcessRunning( stepdefs ) ==  ProcessStep( stepdefs ).process
+ProcessEnabled( stepdefs, s ) == Len( stepdefs ) # 0 /\ s =  ProcessRunning( stepdefs )
+ProcessesToRun( stepdefs ) == Tail( stepdefs )
+ProcessParameter( stepdefs ) == ProcessStep( stepdefs )
+
+TickNext( t )   == t + 1                \* advance time (when process start)
+InTransaction   == FALSE                \* TRUE when application service running, FALSE when not
+(******************************************************************
+Initial value for infrastructure service responses
+ - modelData infrastructureServices
+ - template  infrastructure-service-init.mustache
+
+******************************************************************)
+
+\* create record to put into 'responses'variable field
+InfrastructureServiceResponse( status, response ) == [ status |-> status, response |-> response ]
+
+\* Initial value to variable 'responses' 
+InfrastructureServiceInit ==  [   i_geth_newAccount_ |-> InfrastructureServiceResponse( Nil, Nil ), i_geth_mine_ |-> InfrastructureServiceResponse( Nil, Nil )  ] 
+
+
+(******************************************************************
+Defined types Data type definitions
+ - modelData definitions
+ - template  definition_types.mustache
+*******************************************************************)
+
+
+
+(******************************************************************
+Interface input types: Interface types
+ - modelData interfaces
+ - template  interface_types.mustache
+*******************************************************************)
+
+
+(* REQUEST: geth(newAccount) --> TLA process: p_geth_newAccount_ *)
+t_req_geth_newAccount_ == [
+          sender: d_eth_address,
+          originator: d_eth_address,
+          recipient: d_eth_address,
+          value: d_eth_value
+]
+(* END-OF-REQUEST *)
+
+(* REQUEST: geth(mine) --> TLA process: p_geth_mine_ *)
+t_req_geth_mine_ == [
+          sender: d_eth_address,
+          originator: d_eth_address,
+          recipient: d_eth_address,
+          value: d_eth_value
+]
+(* END-OF-REQUEST *)
+
+\* end of Interface input types
+
+(******************************************************************
+Interface response types: Interface types
+ - modelData interfaces
+ - template  interface_types.mustache
+*******************************************************************)
+
+(* RESPONSE: geth(newAccount) --> TLA process: p_geth_newAccount_ *)
+t_resp_geth_newAccount_ == { Nil }
+(* END-OF-RESPONSE *)
+
+(* RESPONSE: geth(mine) --> TLA process: p_geth_mine_ *)
+t_resp_geth_mine_ == { Nil }
+(* END-OF-RESPONSE *)
+
+(* 
+--algorithm model {
+(******************************************************************
+State environment model
+ - modelData none
+ - template  tla/plc_run_state.mustache
+ ******************************************************************)
+
+variables
+  \* sequence of [ { process |-> {}, parameter |-> {} }]
+  steps             = Steps;
+  \* process currently running = self with _ replcing non-numeric
+  step              = Nil;
+  \* head from +steps+ sequence used to schedule +step+
+  step_parameter    = {};
+  \* current time tick, each process run in own tick
+  now               = 0;
+  \* TRUE when process is running   
+  tx_running        = FALSE;
+  \* rec [ ret_ctx |->  stack entry push in resume ], when resuming, Nil when not
+  resume_context    = Nil;   
+(******************************************************************
+Variables used by infrastructure-services
+ - modelData none
+ - template  infrastructure-service-variables.mustache
+
+******************************************************************)
+
+\* Variable for returning responses from infrastructure services
+responses = InfrastructureServiceInit;
+
+
+      \* Extension point template extend/extend_state.mustache:
+
+      (* SNIPPET: eth/accounts --> eth_accounts *)
+      eth_accounts = {  };
+      (* --END OF SNIPPET-- *)
+      
+(* SNIPPET: eth/storageRoot --> eth_storageRoot *)
+eth_storageRoot = {  };
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/addressPool --> eth_addressPool *)
+eth_addressPool = d_eth_address \ { Nil };
+(* --END OF SNIPPET-- *)
+
+    define {
+       
+     (* 
+	 Current time in state variable now gets ticked
+	 when process starts.
+     *)
+     currentTime == now
+
+     (*
+	 Return set of possible bindings to an enabled process
+
+	 @param [Set] inputSet set of all possible inputs to a process
+	 @return first that matches
+	   - inputSet                if step_parameter.bindSet  == Nil
+	   - step_parameter.bindSet  if step_parameter.bindSet  != Nil
+     *)
+     ProcessParameterInput( inputSet ) ==
+	 IF step_parameter'.bindSet = Nil
+	      THEN inputSet
+	      ELSE step_parameter'.bindSet
+		    
+     (* All record fields in 'bindDef' must bind with corresponding fields in 'inputParam' *)
+     \* ProcessParameterEnablesTst( inputParam, bindDefs ) == \A key \in  { k \in DOMAIN bindDefs : k # "_key" }:  bindDefs[key] = inputParam[key] 
+
+     (*
+       ProcessParameterEnables: 'inputParam' satisfies 'bindDefs'
+
+       - all 'normal' field in 'bindDefs' are found in 'inputParam'
+       - and all subrecords  can be validated recursively using 'ProcessParameterEnables' using a the set in field '_key'
+       - and for each record in the set in field '_rows'
+             -- validates at least one row in 'inputParam'
+                --- cardinality of inputParam[key] = cardinality _row.set
+	     -- OR  equals 'values' set
+
+       Recurse one level down  in 'inputParam' using keys 'bindDefs._key.key'.
+       Recursion is done only if 'bindDefs' defines field '_key'.
+
+
+     *)
+     RECURSIVE ProcessParameterEnables( _, _ )
+     ProcessParameterEnables( inputParam, bindDefs ) ==
+                      ( \A key \in  { k \in DOMAIN bindDefs : Len(k)<4 \/ (SubSeq(k,1,4) # "_key" /\ k # "_rows" )}:  bindDefs[key] = inputParam[key]  )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : Len(k)>3 /\SubSeq(k,1,4)  = "_key"  }: \A r \in bindDefs[reckey] : ProcessParameterEnables( inputParam[r.key], r.rec ) )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : k = "_rows" }: \A r \in bindDefs[reckey] :
+                              (r.row_types = "singletons" /\ r.set = inputParam[r.key]  )
+                           \/ (r.row_types = "hashes" /\ Cardinality( r.set ) = Cardinality( inputParam[r.key] ) /\  \A bDef \in r.set: \E ip \in inputParam[r.key]: ProcessParameterEnables( ip, bDef ) )
+	              )
+
+
+    (*
+    
+     Predicate to filter elements in ProcessParameterInput set to pass
+     to +steps+ element in +step_parameter' variable.
+     
+     Pass +inputParameter+ to a process if one the following matches
+	 - resume_contex # Nil (i.e. process execution is resuming)
+	 - step_parameter = WildCard  (i.e. Head elemend of +steps+ sequence is WildCard, allow everything )
+	 - step_parameter.bindSet = WildCard (i.e. Head element defines bindSet element)
+	 - predicate 'ProcessParameterEnables' resolves TRUE for  step_parameter'.bindRule
+     *)
+
+     ProcessParameterBind( inputParam ) ==
+		       \/  resume_context' # Nil
+		       \/  step_parameter' = WildCard  
+		       \/  step_parameter'.bindRule = WildCard
+		       \/  ProcessParameterEnables( inputParam, step_parameter'.bindRule )
+
+(******************************************************************
+Operators for infrastrcuture service (generated)
+ - modelData infrastructureServices
+ - template  operator-infrastructure-service.mustache
+
+******************************************************************)
+InterfaceOperation2ProcessName( op ) == CASE op = "xxXXxx" -> Nil 
+       [] op = "geth(newAccount)" -> "i_geth_newAccount_" 
+       [] op = "geth(mine)" -> "i_geth_mine_" 
+       [] OTHER -> Assert( FALSE, "Unknown infrastructure service" ) 
+       
+
+
+(******************************************************************
+Operators supporting infrastructure services
+ - modelData none
+ - template  tla/operators-infrastructure-service.mustache
+******************************************************************)
+
+\* return response for 'operation' from 'responses' state variable
+InfrastructureServiceGetResponse( operation ) == responses[InterfaceOperation2ProcessName(operation)].response
+
+\* return status for 'operation' from 'responses' state variable
+InfrastructureServiceGetStatus( operation ) == responses[InterfaceOperation2ProcessName(operation)].status
+
+
+      \* Extension point template extend/extend_operations.mustache:
+
+      (* SNIPPET: framework-svc/NewStep --> NewStep *)
+      (* Create a step entry to schedule in +steps+ sequence
+      *  @param procci process identifier to schedule
+      *  @param procInput an elment in process input set to pass to the process
+      *  @param ctx context where to resume, Nil if no resume
+      *)
+      NewStep( procci, procInput, ctx  ) == [ process  |-> procci, bindRule |-> WildCard ,bindSet  |-> procInput, ctx  |-> ctx ]
+      
+           
+      (* --END OF SNIPPET-- *)
+      
+(* SNIPPET: eth/elementExists --> eth_elementExists *)
+(*
+ * Unique element exists
+*)
+eth_elementExists( set, key, id ) ==  Cardinality( { e \in set : e[key] = id } ) = 1
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/gasPrice --> eth_gasPrice *)
+(* Use integer math, and gasPrice is just 0 *)
+eth_gasPrice == 0
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/gasValue --> eth_gasValue *)
+(*  @return [Integer] value of 'gas' *)
+eth_gasValue( gas ) == gas * eth_gasPrice
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/intrinsicGas --> eth_intrinsicGas *)
+(*
+ *Always consume at least ''intrinsicGas' units of gas, i.e.
+ * account must have balance >= intrinsicGas*gasPrice before execution
+*)
+eth_intrinsicGas == 1
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/NextId --> eth_NextId *)
+(*
+ * 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.
+ *)
+ eth_NextId( ids, address ) == CHOOSE x \in ids: (address = x /\ address # Nil) \/ address = Nil
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/upFrontCost --> eth_upFrontCost *)
+(* 
+ ** Value account must hold before transaction possible to start
+ * 
+ * @return [Integer] request.value  + gasPrice * intrinsicGas
+ *) 
+eth_upFrontCost( request ) == request.value + eth_gasPrice *  eth_intrinsicGas
+
+(* --END OF SNIPPET-- *)
+
+    } \* define
+    (***********************************************************************
+     Macros to control process execution && time
+     ***********************************************************************)
+    macro tick() {
+          now := TickNext( now ); \* now := now + 1;
+    }
+    
+    macro enable( s ) {
+      (* head in sequence 'steps' enable processes *)
+      \* await Len( steps ) # 0 /\ ProcessEnabled( steps, s );
+      await ProcessEnabled( steps, s );
+      
+      (* process entered, remove head from sequence 'steps' *)
+      step  := ProcessRunning( steps ); \* Head( steps ).process;
+      step_parameter  := ProcessParameter( steps );
+      \* steps := ProcessesToRun( steps ); \* Tail( steps );
+
+      \* Context to resume to from Head(steps ), Nil = not resuming
+      resume_context  := ProcessStep( steps ).ctx;      
+
+      (* Reset infrastructure service responses on process entry *)
+      responses := InfrastructureServiceInit;
+
+      (* Flag Transaction started *)
+      tx_running := TRUE;
+
+      (* time advances by one tick for each process step *)
+      tick();
+      \* debug( s );
+    }
+
+    (*  Remove currently running prosess from head of 'step'.
+    
+	Calling this macro enables next process to take turn.
+        If a process comprises several steps, this results
+	processes runing parallel, unless 'process_done' is
+	called in the end of the process.
+    
+    *)
+    
+    macro process_done( s ) {
+    
+        steps := ProcessesToRun( steps ); \* Tail( steps );
+
+        \* process must clear resume context
+	assert( resume_context = Nil );
+	
+	(* Flag Transaction started *)
+        tx_running := FALSE;
+	
+    }
+
+    
+    
+(******************************************************************
+Macros for infrastructure services
+ - modelData none
+ - template  tla/macro-infrastructure-service.mustache
+******************************************************************)
+
+\* set 'status' with 'response' for 'operation'  into state variable 'responses'
+macro InfrastructureServiceReturn( operation, status, response ) {
+
+      \* update field for 'operation' in 'responses' variable  with record [ status |-> s , response |-> r ] 
+      responses[InterfaceOperation2ProcessName(operation)] := InfrastructureServiceResponse( status, response );
+}
+
+
+
+      \* Extension point template extend/extend_macros.mustache:
+
+      (* SNIPPET: framework-svc/schedule_throw --> schedule_throw *)
+      (*
+         Throw exception and exit current process via +exitLocation+.
+      
+         Modify +stack+ top to return from current procedure to
+         +exitLocation+, and retain stack bottom to return from current
+         process.  *)
+      
+      macro schedule_throw( exitLocation ) {
+      
+      
+        stack := <<
+             [ stack[self][1] EXCEPT !.pc = exitLocation ],
+               stack[self][ Len(stack[self]) ]
+                 >>;
+      
+      }
+      (* --END OF SNIPPET-- *)
+      
+(* SNIPPET: framework-svc/schedule_process_mac --> schedule_process_mac *)
+(*
+
+ Schedule a call for an external process +called+ with +input+, and
+ +resume+ back to the calling process in context +resumeCtx+.
+
+ Implementation adds two step entries in +steps+ sequence.
+ Entries cannot be made to position 1 because it represents
+ currently running process, which get shifted away the sequnce
+ once the process finishes.
+
+*)
+
+macro schedule_process_mac( called, input, resume, resumeCtx ) {
+
+    \* NOTICE!!: call and resume steps always successive elements
+    \* The only option is to apped to +steps+
+    if ( Cardinality( { p \in 1..Len(steps) :  \A s \in steps[p]: s.ctx = Nil }  ) <= 1  ) {
+	  steps := steps \o
+		  << { NewStep( called, input, Nil ) },
+		     { NewStep( resume, Nil, resumeCtx ) } >>;
+    } else {
+         \* Non-deteministic choice where to put
+	 with ( pos \in { p \in 2..Len(steps) : \A s \in steps[p]: s.ctx = Nil  } ) {
+	   steps := IF pos = Len(steps) THEN
+		     steps \o
+			<< { NewStep( called, input, Nil ) },
+			   { NewStep( resume, Nil, resumeCtx ) } >>
+		      ELSE
+			 SubSeq( steps, 1, pos-1 )  \o
+			     << { NewStep( called, input, Nil ) },
+				{ NewStep( resume, Nil, resumeCtx ) } >> \o         
+			 SubSeq( steps, pos, Len(steps))
+		    ;
+	 }; \* with
+   }; \* else
+  skip;
+}
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: service_implementation/geth(newAccount) --> i__geth_newAccount_ *)
+macro i__geth_newAccount_( input ) {
+print << "TODO: Greetings from service-implementation",input >>;
+call eth_geth_newAccount_( input);
+}
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: service_implementation/geth(mine) --> i__geth_mine_ *)
+macro i__geth_mine_( input ) {
+print << "TODO: Greetings from service-implementation",input >>;
+call eth_geth_mine_( input);
+}
+(* --END OF SNIPPET-- *)
+
+(******************************************************************
+Interfaces generated  Create a dummy procedure to have &#39;defaultInitValue&#39; in the model
+ - modelData none
+ - template  interface_stubs_dummy.mustache
+******************************************************************)
+
+(* Allow  'interface-extension.implementation' without specification code snippet *)
+macro dummy( dummy_input ) {
+      print << "Dummy macro called should replace with actual macro" >>;
+}
+
+
+(* Create a dummy procedure with input variable so that pcal creates
+   constant defaultInitValue (which is assigned a value in setup.tla)
+*)
+
+procedure dummy( dummy_input ) {
+	dummy_start:  skip;
+}
+
+
+      \* Extension point template extend/extend_implementation.mustache:
+
+      (* SNIPPET: framework-svc/schedule_process_proc --> schedule_process_proc *)
+      (*
+      
+         Schedule process +input.called+ with +input.input+, and resume back
+         to currently running process +step+ to pc of +self+ ProcDef.
+      
+         Creates a record with +ret_ctx+ property, which calling process can
+         use to restore its context, adds call step and resume step to
+         +steps+ sequence.
+      
+      *)
+      
+      procedure schedule_process_proc( input ) {
+      
+      schedule_process_start:
+      
+           schedule_process_mac(
+                input.called,  input.input, step,
+      	  [ ret_ctx |-> [ stack[self][2] EXCEPT !.pc = stack[self][1].pc ] ]
+            );
+      
+           return;
+      }
+      (* --END OF SNIPPET-- *)
+      
+(* SNIPPET: eth/geth(newAccount) --> eth_geth_newAccount_ *)
+procedure eth_geth_newAccount_( eth_geth_newAccount__input ) 
+   variable  contractId;
+   {
+  eth_geth_newAccount__start:
+    \*  print "ENTRY:";
+skip
+;
+
+    (* Body of geth(newAccount) *)
+    eth_geth_newAccount__0: print << "new.account",eth_geth_newAccount__input,"free-pool=",eth_addressPool >>;
+eth_accounts := eth_accounts \union { [ address |-> eth_NextId( eth_addressPool,Nil ), balance |-> 0, codeHash |-> Nil ] };
+eth_addressPool := eth_addressPool \ { eth_NextId( eth_addressPool,Nil ) };
+print << "after-free-pool=",eth_addressPool >>;
+print << "after-accounts=",eth_accounts >>;
+
+
+  eth_geth_newAccount__exit:
+    goto eth_geth_newAccount__end;
+  eth_geth_newAccount__fail:
+     \* throw command sends here
+     InfrastructureServiceReturn( "geth(newAccount)", FALSE, Nil);
+     goto eth_geth_newAccount__end;
+
+  eth_geth_newAccount__abort:
+     \* should not happen??
+     print <<"ABORT eth_geth_newAccount_">>;
+     InfrastructureServiceReturn( "geth(newAccount)", Abort, Nil);
+     \* schedule_throw( "eth_geth_newAccount__exit" );
+  eth_geth_newAccount__end:
+      skip;
+      (* ethereum_service_pop( "geth(newAccount)" ); *)
+  \*  print "EXIT:";
+return
+;
+  }
+
+(* --END OF SNIPPET-- *)
+
+(* SNIPPET: eth/geth(mine) --> eth_geth_mine_ *)
+procedure eth_geth_mine_( eth_geth_mine__input ) 
+   variable  contractId;
+   {
+  eth_geth_mine__start:
+    \*  print "ENTRY:";
+skip
+;
+
+    (* Body of geth(mine) *)
+    
+
+  eth_geth_mine__exit:
+    goto eth_geth_mine__end;
+  eth_geth_mine__fail:
+     \* throw command sends here
+     InfrastructureServiceReturn( "geth(mine)", FALSE, Nil);
+     goto eth_geth_mine__end;
+
+  eth_geth_mine__abort:
+     \* should not happen??
+     print <<"ABORT eth_geth_mine_">>;
+     InfrastructureServiceReturn( "geth(mine)", Abort, Nil);
+     \* schedule_throw( "eth_geth_mine__exit" );
+  eth_geth_mine__end:
+      skip;
+      (* ethereum_service_pop( "geth(mine)" ); *)
+  \*  print "EXIT:";
+return
+;
+  }
+
+(* --END OF SNIPPET-- *)
+
+
+(******************************************************************
+Interfaces generated  Process interfaces
+ - modelData interfaces
+ - template  interface_processes.mustache
+******************************************************************)
+
+(* Process geth(newAccount) *)
+fair process (p_geth_newAccount_="geth(newAccount)") {
+     p_geth_newAccount__enter: while (TRUE) {
+         enable( "p_geth_newAccount_" );
+	 (* enable next process to run parallel *)
+	 \* process_done( "geth(newAccount)" );
+	 with ( _input \in { t \in ProcessParameterInput( t_req_geth_newAccount_ ) : ProcessParameterBind( t ) } ) {
+	    \* PREFERENCES.debug-output: true
+	    print <<"Default process p_geth_newAccount_ for operation 'geth(newAccount)',tick=", currentTime>>;
+	    (* Valid input type? - _input must match type of API request *)	    
+	    assert(  _input \in t_req_geth_newAccount_ );	    
+	    i__geth_newAccount_( _input );
+	 }; \* with _input
+	 (* enable next process - after current process *)
+	 p_geth_newAccount__exit:
+	     process_done( "geth(newAccount)" );
+     } \* while(TRUE)
+} \* fair process p_geth_newAccount_
+
+(* Process geth(mine) *)
+fair process (p_geth_mine_="geth(mine)") {
+     p_geth_mine__enter: while (TRUE) {
+         enable( "p_geth_mine_" );
+	 (* enable next process to run parallel *)
+	 \* process_done( "geth(mine)" );
+	 with ( _input \in { t \in ProcessParameterInput( t_req_geth_mine_ ) : ProcessParameterBind( t ) } ) {
+	    \* PREFERENCES.debug-output: true
+	    print <<"Default process p_geth_mine_ for operation 'geth(mine)',tick=", currentTime>>;
+	    (* Valid input type? - _input must match type of API request *)	    
+	    assert(  _input \in t_req_geth_mine_ );	    
+	    i__geth_mine_( _input );
+	 }; \* with _input
+	 (* enable next process - after current process *)
+	 p_geth_mine__exit:
+	     process_done( "geth(mine)" );
+     } \* while(TRUE)
+} \* fair process p_geth_mine_
+
+
+    fair process ( tail="Tail") {
+        tail_wait: await( Len(steps) = 0 );
+        step           := "Tail";
+        step_parameter := {};
+        tail: while( TRUE ) {
+           skip;
+        }
+    }
+} \* end of algorithm
+*)
+\* BEGIN TRANSLATION
+\* Label tail of process tail at line 632 col 15 changed to tail_
+\* Procedure variable contractId of procedure eth_geth_newAccount_ at line 511 col 14 changed to contractId_
+CONSTANT defaultInitValue
+VARIABLES steps, step, step_parameter, now, tx_running, resume_context, 
+          responses, eth_accounts, eth_storageRoot, eth_addressPool, pc, 
+          stack
+
+(* define statement *)
+     currentTime == now
+
+
+
+
+
+
+
+
+
+     ProcessParameterInput( inputSet ) ==
+         IF step_parameter'.bindSet = Nil
+              THEN inputSet
+              ELSE step_parameter'.bindSet
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+     RECURSIVE ProcessParameterEnables( _, _ )
+     ProcessParameterEnables( inputParam, bindDefs ) ==
+                      ( \A key \in  { k \in DOMAIN bindDefs : Len(k)<4 \/ (SubSeq(k,1,4) # "_key" /\ k # "_rows" )}:  bindDefs[key] = inputParam[key]  )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : Len(k)>3 /\SubSeq(k,1,4)  = "_key"  }: \A r \in bindDefs[reckey] : ProcessParameterEnables( inputParam[r.key], r.rec ) )
+                   /\ ( \A reckey \in { k \in DOMAIN bindDefs : k = "_rows" }: \A r \in bindDefs[reckey] :
+                              (r.row_types = "singletons" /\ r.set = inputParam[r.key]  )
+                           \/ (r.row_types = "hashes" /\ Cardinality( r.set ) = Cardinality( inputParam[r.key] ) /\  \A bDef \in r.set: \E ip \in inputParam[r.key]: ProcessParameterEnables( ip, bDef ) )
+                      )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+     ProcessParameterBind( inputParam ) ==
+                       \/  resume_context' # Nil
+                       \/  step_parameter' = WildCard
+                       \/  step_parameter'.bindRule = WildCard
+                       \/  ProcessParameterEnables( inputParam, step_parameter'.bindRule )
+
+
+
+
+
+
+
+InterfaceOperation2ProcessName( op ) == CASE op = "xxXXxx" -> Nil
+       [] op = "geth(newAccount)" -> "i_geth_newAccount_"
+       [] op = "geth(mine)" -> "i_geth_mine_"
+       [] OTHER -> Assert( FALSE, "Unknown infrastructure service" )
+
+
+
+
+
+
+
+
+
+
+InfrastructureServiceGetResponse( operation ) == responses[InterfaceOperation2ProcessName(operation)].response
+
+
+InfrastructureServiceGetStatus( operation ) == responses[InterfaceOperation2ProcessName(operation)].status
+
+
+
+
+
+
+
+
+
+
+      NewStep( procci, procInput, ctx  ) == [ process  |-> procci, bindRule |-> WildCard ,bindSet  |-> procInput, ctx  |-> ctx ]
+
+
+
+
+
+
+
+
+eth_elementExists( set, key, id ) ==  Cardinality( { e \in set : e[key] = id } ) = 1
+
+
+
+
+
+eth_gasPrice == 0
+
+
+
+
+
+eth_gasValue( gas ) == gas * eth_gasPrice
+
+
+
+
+
+
+
+
+eth_intrinsicGas == 1
+
+
+
+
+
+
+
+
+
+ eth_NextId( ids, address ) == CHOOSE x \in ids: (address = x /\ address # Nil) \/ address = Nil
+
+
+
+
+
+
+
+
+
+eth_upFrontCost( request ) == request.value + eth_gasPrice *  eth_intrinsicGas
+
+VARIABLES dummy_input, input, eth_geth_newAccount__input, contractId_, 
+          eth_geth_mine__input, contractId
+
+vars == << steps, step, step_parameter, now, tx_running, resume_context, 
+           responses, eth_accounts, eth_storageRoot, eth_addressPool, pc, 
+           stack, dummy_input, input, eth_geth_newAccount__input, contractId_, 
+           eth_geth_mine__input, contractId >>
+
+ProcSet == {"geth(newAccount)"} \cup {"geth(mine)"} \cup {"Tail"}
+
+Init == (* Global variables *)
+        /\ steps = Steps
+        /\ step = Nil
+        /\ step_parameter = {}
+        /\ now = 0
+        /\ tx_running = FALSE
+        /\ resume_context = Nil
+        /\ responses = InfrastructureServiceInit
+        /\ eth_accounts = {  }
+        /\ eth_storageRoot = {  }
+        /\ eth_addressPool = d_eth_address \ { Nil }
+        (* Procedure dummy *)
+        /\ dummy_input = [ self \in ProcSet |-> defaultInitValue]
+        (* Procedure schedule_process_proc *)
+        /\ input = [ self \in ProcSet |-> defaultInitValue]
+        (* Procedure eth_geth_newAccount_ *)
+        /\ eth_geth_newAccount__input = [ self \in ProcSet |-> defaultInitValue]
+        /\ contractId_ = [ self \in ProcSet |-> defaultInitValue]
+        (* Procedure eth_geth_mine_ *)
+        /\ eth_geth_mine__input = [ self \in ProcSet |-> defaultInitValue]
+        /\ contractId = [ self \in ProcSet |-> defaultInitValue]
+        /\ stack = [self \in ProcSet |-> << >>]
+        /\ pc = [self \in ProcSet |-> CASE self = "geth(newAccount)" -> "p_geth_newAccount__enter"
+                                        [] self = "geth(mine)" -> "p_geth_mine__enter"
+                                        [] self = "Tail" -> "tail_wait"]
+
+dummy_start(self) == /\ pc[self] = "dummy_start"
+                     /\ TRUE
+                     /\ pc' = [pc EXCEPT ![self] = "Error"]
+                     /\ UNCHANGED << steps, step, step_parameter, now, 
+                                     tx_running, resume_context, responses, 
+                                     eth_accounts, eth_storageRoot, 
+                                     eth_addressPool, stack, dummy_input, 
+                                     input, eth_geth_newAccount__input, 
+                                     contractId_, eth_geth_mine__input, 
+                                     contractId >>
+
+dummy(self) == dummy_start(self)
+
+schedule_process_start(self) == /\ pc[self] = "schedule_process_start"
+                                /\ IF Cardinality( { p \in 1..Len(steps) :  \A s \in steps[p]: s.ctx = Nil }  ) <= 1
+                                      THEN /\ steps' =  steps \o
+                                                       << { NewStep( (input[self].called), (input[self].input), Nil ) },
+                                                          { NewStep( step, Nil, ([ ret_ctx |-> [ stack[self][2] EXCEPT !.pc = stack[self][1].pc ] ]) ) } >>
+                                      ELSE /\ \E pos \in { p \in 2..Len(steps) : \A s \in steps[p]: s.ctx = Nil  }:
+                                                steps' = (IF pos = Len(steps) THEN
+                                                           steps \o
+                                                              << { NewStep( (input[self].called), (input[self].input), Nil ) },
+                                                                 { NewStep( step, Nil, ([ ret_ctx |-> [ stack[self][2] EXCEPT !.pc = stack[self][1].pc ] ]) ) } >>
+                                                            ELSE
+                                                               SubSeq( steps, 1, pos-1 )  \o
+                                                                   << { NewStep( (input[self].called), (input[self].input), Nil ) },
+                                                                      { NewStep( step, Nil, ([ ret_ctx |-> [ stack[self][2] EXCEPT !.pc = stack[self][1].pc ] ]) ) } >> \o
+                                                               SubSeq( steps, pos, Len(steps)))
+                                /\ TRUE
+                                /\ pc' = [pc EXCEPT ![self] = Head(stack[self]).pc]
+                                /\ input' = [input EXCEPT ![self] = Head(stack[self]).input]
+                                /\ stack' = [stack EXCEPT ![self] = Tail(stack[self])]
+                                /\ UNCHANGED << step, step_parameter, now, 
+                                                tx_running, resume_context, 
+                                                responses, eth_accounts, 
+                                                eth_storageRoot, 
+                                                eth_addressPool, dummy_input, 
+                                                eth_geth_newAccount__input, 
+                                                contractId_, 
+                                                eth_geth_mine__input, 
+                                                contractId >>
+
+schedule_process_proc(self) == schedule_process_start(self)
+
+eth_geth_newAccount__start(self) == /\ pc[self] = "eth_geth_newAccount__start"
+                                    /\ TRUE
+                                    /\ pc' = [pc EXCEPT ![self] = "eth_geth_newAccount__0"]
+                                    /\ UNCHANGED << steps, step, 
+                                                    step_parameter, now, 
+                                                    tx_running, resume_context, 
+                                                    responses, eth_accounts, 
+                                                    eth_storageRoot, 
+                                                    eth_addressPool, stack, 
+                                                    dummy_input, input, 
+                                                    eth_geth_newAccount__input, 
+                                                    contractId_, 
+                                                    eth_geth_mine__input, 
+                                                    contractId >>
+
+eth_geth_newAccount__0(self) == /\ pc[self] = "eth_geth_newAccount__0"
+                                /\ PrintT(<< "new.account",eth_geth_newAccount__input[self],"free-pool=",eth_addressPool >>)
+                                /\ eth_accounts' = (eth_accounts \union { [ address |-> eth_NextId( eth_addressPool,Nil ), balance |-> 0, codeHash |-> Nil ] })
+                                /\ eth_addressPool' = eth_addressPool \ { eth_NextId( eth_addressPool,Nil ) }
+                                /\ PrintT(<< "after-free-pool=",eth_addressPool' >>)
+                                /\ PrintT(<< "after-accounts=",eth_accounts' >>)
+                                /\ pc' = [pc EXCEPT ![self] = "eth_geth_newAccount__exit"]
+                                /\ UNCHANGED << steps, step, step_parameter, 
+                                                now, tx_running, 
+                                                resume_context, responses, 
+                                                eth_storageRoot, stack, 
+                                                dummy_input, input, 
+                                                eth_geth_newAccount__input, 
+                                                contractId_, 
+                                                eth_geth_mine__input, 
+                                                contractId >>
+
+eth_geth_newAccount__exit(self) == /\ pc[self] = "eth_geth_newAccount__exit"
+                                   /\ pc' = [pc EXCEPT ![self] = "eth_geth_newAccount__end"]
+                                   /\ UNCHANGED << steps, step, step_parameter, 
+                                                   now, tx_running, 
+                                                   resume_context, responses, 
+                                                   eth_accounts, 
+                                                   eth_storageRoot, 
+                                                   eth_addressPool, stack, 
+                                                   dummy_input, input, 
+                                                   eth_geth_newAccount__input, 
+                                                   contractId_, 
+                                                   eth_geth_mine__input, 
+                                                   contractId >>
+
+eth_geth_newAccount__fail(self) == /\ pc[self] = "eth_geth_newAccount__fail"
+                                   /\ responses' = [responses EXCEPT ![InterfaceOperation2ProcessName("geth(newAccount)")] = InfrastructureServiceResponse( FALSE, Nil )]
+                                   /\ pc' = [pc EXCEPT ![self] = "eth_geth_newAccount__end"]
+                                   /\ UNCHANGED << steps, step, step_parameter, 
+                                                   now, tx_running, 
+                                                   resume_context, 
+                                                   eth_accounts, 
+                                                   eth_storageRoot, 
+                                                   eth_addressPool, stack, 
+                                                   dummy_input, input, 
+                                                   eth_geth_newAccount__input, 
+                                                   contractId_, 
+                                                   eth_geth_mine__input, 
+                                                   contractId >>
+
+eth_geth_newAccount__abort(self) == /\ pc[self] = "eth_geth_newAccount__abort"
+                                    /\ PrintT(<<"ABORT eth_geth_newAccount_">>)
+                                    /\ responses' = [responses EXCEPT ![InterfaceOperation2ProcessName("geth(newAccount)")] = InfrastructureServiceResponse( Abort, Nil )]
+                                    /\ pc' = [pc EXCEPT ![self] = "eth_geth_newAccount__end"]
+                                    /\ UNCHANGED << steps, step, 
+                                                    step_parameter, now, 
+                                                    tx_running, resume_context, 
+                                                    eth_accounts, 
+                                                    eth_storageRoot, 
+                                                    eth_addressPool, stack, 
+                                                    dummy_input, input, 
+                                                    eth_geth_newAccount__input, 
+                                                    contractId_, 
+                                                    eth_geth_mine__input, 
+                                                    contractId >>
+
+eth_geth_newAccount__end(self) == /\ pc[self] = "eth_geth_newAccount__end"
+                                  /\ TRUE
+                                  /\ pc' = [pc EXCEPT ![self] = Head(stack[self]).pc]
+                                  /\ contractId_' = [contractId_ EXCEPT ![self] = Head(stack[self]).contractId_]
+                                  /\ eth_geth_newAccount__input' = [eth_geth_newAccount__input EXCEPT ![self] = Head(stack[self]).eth_geth_newAccount__input]
+                                  /\ stack' = [stack EXCEPT ![self] = Tail(stack[self])]
+                                  /\ UNCHANGED << steps, step, step_parameter, 
+                                                  now, tx_running, 
+                                                  resume_context, responses, 
+                                                  eth_accounts, 
+                                                  eth_storageRoot, 
+                                                  eth_addressPool, dummy_input, 
+                                                  input, eth_geth_mine__input, 
+                                                  contractId >>
+
+eth_geth_newAccount_(self) == eth_geth_newAccount__start(self)
+                                 \/ eth_geth_newAccount__0(self)
+                                 \/ eth_geth_newAccount__exit(self)
+                                 \/ eth_geth_newAccount__fail(self)
+                                 \/ eth_geth_newAccount__abort(self)
+                                 \/ eth_geth_newAccount__end(self)
+
+eth_geth_mine__start(self) == /\ pc[self] = "eth_geth_mine__start"
+                              /\ TRUE
+                              /\ pc' = [pc EXCEPT ![self] = "eth_geth_mine__exit"]
+                              /\ UNCHANGED << steps, step, step_parameter, now, 
+                                              tx_running, resume_context, 
+                                              responses, eth_accounts, 
+                                              eth_storageRoot, eth_addressPool, 
+                                              stack, dummy_input, input, 
+                                              eth_geth_newAccount__input, 
+                                              contractId_, 
+                                              eth_geth_mine__input, contractId >>
+
+eth_geth_mine__exit(self) == /\ pc[self] = "eth_geth_mine__exit"
+                             /\ pc' = [pc EXCEPT ![self] = "eth_geth_mine__end"]
+                             /\ UNCHANGED << steps, step, step_parameter, now, 
+                                             tx_running, resume_context, 
+                                             responses, eth_accounts, 
+                                             eth_storageRoot, eth_addressPool, 
+                                             stack, dummy_input, input, 
+                                             eth_geth_newAccount__input, 
+                                             contractId_, eth_geth_mine__input, 
+                                             contractId >>
+
+eth_geth_mine__fail(self) == /\ pc[self] = "eth_geth_mine__fail"
+                             /\ responses' = [responses EXCEPT ![InterfaceOperation2ProcessName("geth(mine)")] = InfrastructureServiceResponse( FALSE, Nil )]
+                             /\ pc' = [pc EXCEPT ![self] = "eth_geth_mine__end"]
+                             /\ UNCHANGED << steps, step, step_parameter, now, 
+                                             tx_running, resume_context, 
+                                             eth_accounts, eth_storageRoot, 
+                                             eth_addressPool, stack, 
+                                             dummy_input, input, 
+                                             eth_geth_newAccount__input, 
+                                             contractId_, eth_geth_mine__input, 
+                                             contractId >>
+
+eth_geth_mine__abort(self) == /\ pc[self] = "eth_geth_mine__abort"
+                              /\ PrintT(<<"ABORT eth_geth_mine_">>)
+                              /\ responses' = [responses EXCEPT ![InterfaceOperation2ProcessName("geth(mine)")] = InfrastructureServiceResponse( Abort, Nil )]
+                              /\ pc' = [pc EXCEPT ![self] = "eth_geth_mine__end"]
+                              /\ UNCHANGED << steps, step, step_parameter, now, 
+                                              tx_running, resume_context, 
+                                              eth_accounts, eth_storageRoot, 
+                                              eth_addressPool, stack, 
+                                              dummy_input, input, 
+                                              eth_geth_newAccount__input, 
+                                              contractId_, 
+                                              eth_geth_mine__input, contractId >>
+
+eth_geth_mine__end(self) == /\ pc[self] = "eth_geth_mine__end"
+                            /\ TRUE
+                            /\ pc' = [pc EXCEPT ![self] = Head(stack[self]).pc]
+                            /\ contractId' = [contractId EXCEPT ![self] = Head(stack[self]).contractId]
+                            /\ eth_geth_mine__input' = [eth_geth_mine__input EXCEPT ![self] = Head(stack[self]).eth_geth_mine__input]
+                            /\ stack' = [stack EXCEPT ![self] = Tail(stack[self])]
+                            /\ UNCHANGED << steps, step, step_parameter, now, 
+                                            tx_running, resume_context, 
+                                            responses, eth_accounts, 
+                                            eth_storageRoot, eth_addressPool, 
+                                            dummy_input, input, 
+                                            eth_geth_newAccount__input, 
+                                            contractId_ >>
+
+eth_geth_mine_(self) == eth_geth_mine__start(self)
+                           \/ eth_geth_mine__exit(self)
+                           \/ eth_geth_mine__fail(self)
+                           \/ eth_geth_mine__abort(self)
+                           \/ eth_geth_mine__end(self)
+
+p_geth_newAccount__enter == /\ pc["geth(newAccount)"] = "p_geth_newAccount__enter"
+                            /\ ProcessEnabled( steps, "p_geth_newAccount_" )
+                            /\ step' = ProcessRunning( steps )
+                            /\ step_parameter' = ProcessParameter( steps )
+                            /\ resume_context' = ProcessStep( steps ).ctx
+                            /\ responses' = InfrastructureServiceInit
+                            /\ tx_running' = TRUE
+                            /\ now' = TickNext( now )
+                            /\ \E _input \in { t \in ProcessParameterInput( t_req_geth_newAccount_ ) : ProcessParameterBind( t ) }:
+                                 /\ PrintT(<<"Default process p_geth_newAccount_ for operation 'geth(newAccount)',tick=", currentTime>>)
+                                 /\ Assert((  _input \in t_req_geth_newAccount_ ), 
+                                           "Failure of assertion at line 599, column 13.")
+                                 /\ PrintT(<< "TODO: Greetings from service-implementation",_input >>)
+                                 /\ /\ eth_geth_newAccount__input' = [eth_geth_newAccount__input EXCEPT !["geth(newAccount)"] = _input]
+                                    /\ stack' = [stack EXCEPT !["geth(newAccount)"] = << [ procedure |->  "eth_geth_newAccount_",
+                                                                                           pc        |->  "p_geth_newAccount__exit",
+                                                                                           contractId_ |->  contractId_["geth(newAccount)"],
+                                                                                           eth_geth_newAccount__input |->  eth_geth_newAccount__input["geth(newAccount)"] ] >>
+                                                                                       \o stack["geth(newAccount)"]]
+                                 /\ contractId_' = [contractId_ EXCEPT !["geth(newAccount)"] = defaultInitValue]
+                                 /\ pc' = [pc EXCEPT !["geth(newAccount)"] = "eth_geth_newAccount__start"]
+                            /\ UNCHANGED << steps, eth_accounts, 
+                                            eth_storageRoot, eth_addressPool, 
+                                            dummy_input, input, 
+                                            eth_geth_mine__input, contractId >>
+
+p_geth_newAccount__exit == /\ pc["geth(newAccount)"] = "p_geth_newAccount__exit"
+                           /\ steps' = ProcessesToRun( steps )
+                           /\ Assert(( resume_context = Nil ), 
+                                     "Failure of assertion at line 362, column 9 of macro called at line 604, column 14.")
+                           /\ tx_running' = FALSE
+                           /\ pc' = [pc EXCEPT !["geth(newAccount)"] = "p_geth_newAccount__enter"]
+                           /\ UNCHANGED << step, step_parameter, now, 
+                                           resume_context, responses, 
+                                           eth_accounts, eth_storageRoot, 
+                                           eth_addressPool, stack, dummy_input, 
+                                           input, eth_geth_newAccount__input, 
+                                           contractId_, eth_geth_mine__input, 
+                                           contractId >>
+
+p_geth_newAccount_ == p_geth_newAccount__enter \/ p_geth_newAccount__exit
+
+p_geth_mine__enter == /\ pc["geth(mine)"] = "p_geth_mine__enter"
+                      /\ ProcessEnabled( steps, "p_geth_mine_" )
+                      /\ step' = ProcessRunning( steps )
+                      /\ step_parameter' = ProcessParameter( steps )
+                      /\ resume_context' = ProcessStep( steps ).ctx
+                      /\ responses' = InfrastructureServiceInit
+                      /\ tx_running' = TRUE
+                      /\ now' = TickNext( now )
+                      /\ \E _input \in { t \in ProcessParameterInput( t_req_geth_mine_ ) : ProcessParameterBind( t ) }:
+                           /\ PrintT(<<"Default process p_geth_mine_ for operation 'geth(mine)',tick=", currentTime>>)
+                           /\ Assert((  _input \in t_req_geth_mine_ ), 
+                                     "Failure of assertion at line 618, column 13.")
+                           /\ PrintT(<< "TODO: Greetings from service-implementation",_input >>)
+                           /\ /\ eth_geth_mine__input' = [eth_geth_mine__input EXCEPT !["geth(mine)"] = _input]
+                              /\ stack' = [stack EXCEPT !["geth(mine)"] = << [ procedure |->  "eth_geth_mine_",
+                                                                               pc        |->  "p_geth_mine__exit",
+                                                                               contractId |->  contractId["geth(mine)"],
+                                                                               eth_geth_mine__input |->  eth_geth_mine__input["geth(mine)"] ] >>
+                                                                           \o stack["geth(mine)"]]
+                           /\ contractId' = [contractId EXCEPT !["geth(mine)"] = defaultInitValue]
+                           /\ pc' = [pc EXCEPT !["geth(mine)"] = "eth_geth_mine__start"]
+                      /\ UNCHANGED << steps, eth_accounts, eth_storageRoot, 
+                                      eth_addressPool, dummy_input, input, 
+                                      eth_geth_newAccount__input, contractId_ >>
+
+p_geth_mine__exit == /\ pc["geth(mine)"] = "p_geth_mine__exit"
+                     /\ steps' = ProcessesToRun( steps )
+                     /\ Assert(( resume_context = Nil ), 
+                               "Failure of assertion at line 362, column 9 of macro called at line 623, column 14.")
+                     /\ tx_running' = FALSE
+                     /\ pc' = [pc EXCEPT !["geth(mine)"] = "p_geth_mine__enter"]
+                     /\ UNCHANGED << step, step_parameter, now, resume_context, 
+                                     responses, eth_accounts, eth_storageRoot, 
+                                     eth_addressPool, stack, dummy_input, 
+                                     input, eth_geth_newAccount__input, 
+                                     contractId_, eth_geth_mine__input, 
+                                     contractId >>
+
+p_geth_mine_ == p_geth_mine__enter \/ p_geth_mine__exit
+
+tail_wait == /\ pc["Tail"] = "tail_wait"
+             /\ ( Len(steps) = 0 )
+             /\ step' = "Tail"
+             /\ step_parameter' = {}
+             /\ pc' = [pc EXCEPT !["Tail"] = "tail_"]
+             /\ UNCHANGED << steps, now, tx_running, resume_context, responses, 
+                             eth_accounts, eth_storageRoot, eth_addressPool, 
+                             stack, dummy_input, input, 
+                             eth_geth_newAccount__input, contractId_, 
+                             eth_geth_mine__input, contractId >>
+
+tail_ == /\ pc["Tail"] = "tail_"
+         /\ TRUE
+         /\ pc' = [pc EXCEPT !["Tail"] = "tail_"]
+         /\ UNCHANGED << steps, step, step_parameter, now, tx_running, 
+                         resume_context, responses, eth_accounts, 
+                         eth_storageRoot, eth_addressPool, stack, dummy_input, 
+                         input, eth_geth_newAccount__input, contractId_, 
+                         eth_geth_mine__input, contractId >>
+
+tail == tail_wait \/ tail_
+
+Next == p_geth_newAccount_ \/ p_geth_mine_ \/ tail
+           \/ (\E self \in ProcSet:  \/ dummy(self) \/ schedule_process_proc(self)
+                                     \/ eth_geth_newAccount_(self)
+                                     \/ eth_geth_mine_(self))
+
+Spec == /\ Init /\ [][Next]_vars
+        /\ WF_vars(p_geth_newAccount_)
+        /\ WF_vars(p_geth_mine_)
+        /\ WF_vars(tail)
+
+\* END TRANSLATION
+(******************************************************************
+Validate types for infrastructure service return values
+ - modelData infrastructureServices
+ - template  state_type_invariant-infrastructure-service.mustache
+
+******************************************************************)
+
+(*
+   Type invariants for infrastructure service return values.
+
+
+   All fields in 'responses' state variable store a record [ status |-> ... , response |-> ... ]
+
+*)
+
+InfrastructureService_TypeInvariant_i_geth_newAccount_ == responses.i_geth_newAccount_.response \in { Nil } 
+
+
+\* Type invariant for infrastructure service return values
+
+InfrastructureService_TypeInvariant_i_geth_mine_ == responses.i_geth_mine_.response \in { Nil } 
+
+
+\* Type invariant for infrastructure service return values
+
+InfrastructureService_TypeInvariant == TRUE 
+                                  /\ InfrastructureService_TypeInvariant_i_geth_newAccount_
+                                  /\ InfrastructureService_TypeInvariant_i_geth_mine_
+
+
+
+      \* Extension point template extend/extend_invariant.mustache:
+
+      
+
+      \* Extension point template extend/extend_assumptions.mustache:
+
+      
+
+=============================================================================