sbuilder-ethereum 0.0.6

data/lib/resources/correctness/accouns_type.tla

@@ -0,0 +1 @@
+accounts_type == \A e \in {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}: e \in {{#SPEC_NAME}}definitions.Accounts{{/SPEC_NAME}}

data/lib/resources/correctness/accounts_unique.tla

@@ -0,0 +1,2 @@
+\* Invariant: unique entries in account state variable
+accounts_unique == uniqueElements( {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}, "address" )

data/lib/resources/correctness/accounts_valid.tla

@@ -0,0 +1,2 @@
+\* valid account must have value >= 0, and address # Nil
+accounts_valid == \A a \in {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}: a.address # Nil /\ a.balance >= 0

data/lib/resources/correctness/storage_root_unique.tla

@@ -0,0 +1,2 @@
+\* Invariant: unique entries in storageRoot state variable
+storageRoot_unique == uniqueElements( {{#SPEC_NAME}}eth.storageRoot{{/SPEC_NAME}}, "address" )

data/lib/resources/correctness/total_value.tla

@@ -0,0 +1 @@
+total_value == Stable =>  ( {{#SPEC_NAME}}eth.mined{{/SPEC_NAME}} + SumRecordField( {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}, "balance" ) =  0 )

data/lib/resources/eth/accounts_state.tla

@@ -0,0 +1,2 @@
+\* account entries
+{{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}} = {};

data/lib/resources/eth/accounts_temp.tla

@@ -0,0 +1,2 @@
+\* account transient state
+{{#SPEC_NAME}}eth.accounts_temp{{/SPEC_NAME}} = <<>>;

data/lib/resources/eth/address_free.tla

@@ -0,0 +1,2 @@
+\* Unassigned addresses
+{{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}} = {{#SPEC_NAME}}domains.eth_address{{/SPEC_NAME}} \ { Nil };

data/lib/resources/eth/mined_state.tla

@@ -0,0 +1 @@
+{{#SPEC_NAME}}eth.mined{{/SPEC_NAME}} = 0;

data/lib/resources/eth/storageRoot.tla

@@ -0,0 +1 @@
+{{#SPEC_NAME}}eth.storageRoot{{/SPEC_NAME}} = {};

data/lib/resources/eth/storageRoot_temp.tla

@@ -0,0 +1 @@
+{{#SPEC_NAME}}eth.storageRoot_temp{{/SPEC_NAME}} = <<>>;

data/lib/resources/mine/mine_entry.tla

@@ -0,0 +1,4 @@
+macro {{#SPEC_NAME}}service_implementation.geth_mine(){{/SPEC_NAME}}( input ) {
+
+      call {{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}( input );
+}

data/lib/resources/mine/mine_service.tla

@@ -0,0 +1,22 @@
+procedure {{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}( input ) {
+
+{{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}_enter: 
+
+  \* Check that account input.etherbase exists 
+  if ( { e \in {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}: e.address = input.beneficiary } = {}) {
+     goto {{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}_exit;
+  };
+
+{{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}_ok:
+  
+  \* Update  on 'account.balance' with 'input.value'
+  {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}}  :=
+  {  IF e.address = input.beneficiary THEN [ e EXCEPT !.balance = e.balance + input.value ] ELSE e : e \in  {{#SPEC_NAME}}eth.accounts{{/SPEC_NAME}} };
+
+  \* Update total value 'mined'
+  {{#SPEC_NAME}}eth.mined{{/SPEC_NAME}} := {{#SPEC_NAME}}eth.mined{{/SPEC_NAME}} - input.value;
+
+{{#SPEC_NAME}}eth.mine{{/SPEC_NAME}}_exit:
+   return;
+
+}

data/lib/resources/operators/elementExists.tla

@@ -0,0 +1,4 @@
+(*
+ * Unique element exists
+ *)
+elementExists( set, key, id ) ==  Cardinality( { e \in set : e[key] = id } ) = 1

data/lib/resources/operators/gasPrice.tla

@@ -0,0 +1,2 @@
+\* Use integer math, and gasPrice is just 1
+gasPrice == 0

data/lib/resources/operators/gasValue.tla

@@ -0,0 +1,2 @@
+\* @return [Integer] gas * gasPrice
+gasValue( gas ) == gas * gasPrice

data/lib/resources/operators/getElement.tla

@@ -0,0 +1,5 @@
+(*
+ * Return element from 'set' such that element['key'] == 'id'
+ * Assume 'id' unique, and element exists
+ *)
+getElement( set, key, id ) == ( CHOOSE x \in { e \in set : e[key] = id } : TRUE )

data/lib/resources/operators/intrinsicGas.tla

@@ -0,0 +1,4 @@
+(* Always consume at least one unit of gas
+ * Account must have balance >= intrinsicGas*gasPrice before execution
+ *)
+intrinsicGas == 1

data/lib/resources/operators/transactionGas.tla

@@ -0,0 +1,4 @@
+(*
+ * Running transaction consumes always 1 unit of gas.
+ *)
+transactionGas == 1

data/lib/resources/operators/upFrontCost.tla

@@ -0,0 +1,6 @@
+(*
+* Value account must hold before transaction possible to start
+* 
+* @return [Integer] request.value  + gasPrice * intrinsicGas
+*)
+upFrontCost( request ) == request.value + gasPrice *  intrinsicGas

data/lib/resources/personal_newAccount/personal_newAccount_done.tla

@@ -0,0 +1,14 @@
+macro personal_newAccount_done( interface ) {
+
+      \* like ethereum_service_done( interface ) + creates eth_storageRoot
+      
+
+      eth_storageRoot :=  Head(eth_storageRoot_temp) \union { [address |-> InfrastructureServiceGetResponse( "personal_newAccount()" ) ] };
+      eth_accounts :=  Head(eth_accounts_temp);
+      \* eth_gasUsed :=  Head(eth_gasUsed_temp);
+
+      eth_storageRoot_temp := <<>>;
+      eth_accounts_temp := <<>>;
+      \* eth_gasUsed_temp := <<>>;
+
+}

data/lib/resources/personal_newAccount/personal_newAccount_entry.tla

@@ -0,0 +1,10 @@
+macro {{#SPEC_NAME}}service_implementation.personal_newAccount(){{/SPEC_NAME}}( input ) {
+
+      \* prepare for transaction
+      \*  print <<"TRACE>","TX-start@personal_newAccount(): push block state to stack">>;
+      
+      ethereum_service_start();
+      
+      call {{#SPEC_NAME}}eth.personal_newAccount{{/SPEC_NAME}}( [ codeHash |-> input.dummy, address |-> Nil ] );
+
+}

data/lib/resources/personal_newAccount/personal_newAccount_service.tla

@@ -0,0 +1,29 @@
+
+(*
+* @param [codeHash] class name, Nil for non-contract accounts
+* @param [address] Nil|address to take from pools
+*)
+procedure {{#SPEC_NAME}}eth.personal_newAccount{{/SPEC_NAME}}( input ) {
+
+{{#SPEC_NAME}}eth.personal_newAccount{{/SPEC_NAME}}_enter:
+
+  \* Must have NextId available in free address pool
+  assert( {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}} # {} );
+
+  \* Create account record in 'accounts' variable, input.dummy is default - because no input defined
+  {{#SPEC_NAME}}eth.accounts_temp{{/SPEC_NAME}}  :=
+      UpdateTop( {{#SPEC_NAME}}eth.accounts_temp{{/SPEC_NAME}},
+        Head( {{#SPEC_NAME}}eth.accounts_temp{{/SPEC_NAME}} ) \union { [ address |-> NextId( {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}}, input.address ), balance |-> 0, codeHash |-> input.codeHash ]});
+
+  \* Set return 
+  InfrastructureServiceReturn(  "personal_newAccount()", status_OK, NextId( {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}}, input.address ) );
+
+  \* Remove 'NextId' from frees address pool
+  {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}} :=
+       {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}} \ { NextId( {{#SPEC_NAME}}eth.address_free{{/SPEC_NAME}}, input.address ) };
+
+{{#SPEC_NAME}}eth.personal_newAccount{{/SPEC_NAME}}_exit:
+
+   return;
+
+}

data/lib/resources/removed/sendTransaction_entry.tla

@@ -0,0 +1,5 @@
+macro {{#SPEC_NAME}}service_implementation.sendTransaction(){{/SPEC_NAME}}( input ) {
+
+      call sendTransaction( input );
+
+}

data/lib/resources/removed/sendTransaction_service.tla

@@ -0,0 +1,36 @@
+procedure sendTransaction( input ) {
+
+sendTransaction_enter:
+
+
+   (* Validate send transaction
+      - must be transferring accross different addresses 'to' <> 'from'
+      - sender 'from' must have enough 'value'
+   *)
+   
+   if (
+              { e \in accounts : e.aid = input.from } = {}
+         \/   input.from = input.to 
+         \/   (CHOOSE x \in { e \in accounts: e.aid = input.from } : TRUE ).value < input.value
+    ) {
+   
+       goto sendTransaction_exit;
+
+   };
+
+sendTransaction_transaction_ok:
+
+
+  \* Send: 'to.value' += input.value; 'from.value' -= input.value
+  
+  accounts  :=  { e \in accounts : e.aid # input.from /\ e.aid # input.to }
+                \union
+		{ [ e_to_new EXCEPT !.value = e_to_new.value + input.value ] :  e_to_new \in { e_to \in accounts: e_to.aid = input.to } }
+		\union
+		{ [ e_from_new  EXCEPT !.value = e_from_new.value - input.value ] :  e_from_new \in { e_from \in accounts: e_from.aid = input.from } }
+		;
+
+sendTransaction_exit:
+   return;
+
+}

data/lib/resources/removed/tst.tla

@@ -0,0 +1 @@
+tst == TRUE

data/lib/resources/transaction/ethereum_service_done.tla

@@ -0,0 +1,24 @@
+(*
+ * Interface process (called scheduled) has finished.
+ * Check service response status, and 
+ * commit changes in 'eth_storageRoot' and 'eth_accounts', if success.
+ * In any case clear variables modeling block status because
+ * they are not needed anymore (after all scheduler starts a new
+ * round).
+ * 
+ *)
+macro ethereum_service_done( interface ) {
+
+   if ( InfrastructureServiceGetStatus(interface ) = TRUE ) {
+     \* Success commit changes to 'temp' & cleanup
+     {|^preferences.tla-trace|}\* {|/preferences.tla-trace|}  print <<"TRACE>", "TX-end@", interface, "success: restore eth_storageRoot ">>;
+     {|^preferences.tla-trace|}\* {|/preferences.tla-trace|}  print <<"TRACE>", "TX-end@", interface, "success: restore eth_accounts ">>;
+     (* {|^preferences.tla-trace|}\* {|/preferences.tla-trace|}  print <<"TRACE>", "TX-end@", interface, "success: restore eth_gasUsed ">>; *)
+     eth_storageRoot :=  Head(eth_storageRoot_temp);
+     eth_accounts :=  Head(eth_accounts_temp);
+    \*  eth_gasUsed :=  Head(eth_gasUsed_temp);
+   };
+   eth_storageRoot_temp := <<>>;
+   eth_accounts_temp := <<>>;
+   \* eth_gasUsed_temp := <<>>;
+}

data/lib/resources/transaction/ethereum_service_pop.tla

@@ -0,0 +1,24 @@
+(*
+ * Service procedure for 'interface' has finished.
+ * Check status of service response.
+ * For success make changes in procedure permanent by propagating
+ * stack top to top-1..bottom.
+ *
+ * In any case pop one element from stack.
+ * 
+ *)
+ 
+macro ethereum_service_pop( interface ) {
+
+   if ( InfrastructureServiceGetStatus(interface ) = TRUE ) {
+     \* Success - propage changes, and make the permanent
+      eth_storageRoot_temp :=  PropageTopAndPop( eth_storageRoot_temp );
+      eth_accounts_temp :=  PropageTopAndPop( eth_accounts_temp );
+      \* eth_gasUsed_temp :=  PropageTopAndPop( eth_gasUsed_temp );
+   }
+   else {
+      eth_storageRoot_temp := Tail(eth_storageRoot_temp);
+      eth_accounts_temp := Tail(eth_accounts_temp);
+      \* eth_gasUsed_temp := Tail( eth_gasUsed_temp );
+   };
+}

data/lib/resources/transaction/ethereum_service_push.tla

@@ -0,0 +1,14 @@
+(*
+ * Macro called when service starts. Duplicates current
+ * top of stack.
+ *
+ * @see ethereum_service_start
+ * @see ethereum_service_done 
+ *)
+macro {{#SPEC_NAME}}framework-svc.ethereum_service_push{{/SPEC_NAME}}() {
+
+      eth_storageRoot_temp :=  Push( eth_storageRoot_temp, Head( eth_storageRoot_temp )) ;
+      eth_accounts_temp :=  Push( eth_accounts_temp, Head( eth_accounts_temp ));
+      \* eth_gasUsed_temp :=  Push( eth_gasUsed_temp, Head(eth_gasUsed_temp));
+      
+}

data/lib/resources/transaction/ethereum_service_start.tla

@@ -0,0 +1,13 @@
+(*
+ * Macro called when transaction starts.
+ * Inializes ethreum block context to stack.
+ *
+ * @see ethereum_service_done
+ * @see ethereum_service_push 
+ *)
+macro {{#SPEC_NAME}}framework-svc.ethereum_service_start{{/SPEC_NAME}}() {
+
+      eth_storageRoot_temp :=  <<eth_storageRoot>>;
+      eth_accounts_temp :=  <<eth_accounts>>;
+      \* eth_gasUsed_temp :=  <<eth_gasUsed>>;
+}

data/lib/resources/transaction/status_fail.tla

@@ -0,0 +1 @@
+status_FAIL == FALSE

data/lib/resources/transaction/status_ok.tla

@@ -0,0 +1 @@
+status_OK == TRUE

data/lib/sbuilder-ethereum.rb

@@ -0,0 +1,52 @@
+
+require 'sbuilder'
+
+require_relative "utils/string_inject"
+require_relative "utils/logger"
+
+
+require_relative "sbuilder/exception"
+
+# mixers
+require_relative "mixer/type_symbol"
+require_relative "mixer/symbol_ref"
+require_relative "mixer/scope"
+require_relative "mixer/scoped"    
+require_relative "mixer/decl_ref"
+require_relative "mixer/domain_ref"
+
+# constants
+require_relative "sbuilder/constants"            
+
+# solidity stuff
+require_relative "sbuilder/compile"            
+require_relative "sbuilder/load"
+
+
+require_relative "sbuilder/sexp_ast"
+require_relative "sbuilder/sexp_utils"
+
+# sex processors
+require_relative "sbuilder/sexp_processor_ethereum"
+require_relative "sbuilder/sexp_processor_need_to_canonize"
+require_relative "sbuilder/sexp_processor_canonize"
+require_relative "sbuilder/sexp_processor_symboltable1"
+require_relative "sbuilder/sexp_processor_symboltable2"
+require_relative "sbuilder/sexp_processor_dataflow"
+require_relative "sbuilder/sexp_processor_api"
+require_relative "sbuilder/sexp_processor_snippet"
+require_relative "sbuilder/s"
+
+# Code generation 
+require_relative "sbuilder/generate/tla_element_text"
+require_relative "sbuilder/generate/tla_element_generator"
+require_relative "sbuilder/generate/sexp_processor_tla"
+
+
+# mustache
+require_relative "sbuilder/mustache/renderer"
+require_relative "sbuilder/render"        
+
+# plugin && main
+require_relative "plugin/plugin"
+

data/lib/sbuilder/compile.rb

@@ -0,0 +1,163 @@
+require 'open3'
+module Sbuilder
+  module Ethereum
+
+
+    ##
+    # Compile solidity source.
+    #
+    class Compile
+
+      PROGNAME = nil       # progname for logger default class name
+      include MyLogger     # mix logger
+
+      # @attr [String] solc_command
+      attr_writer :solc_command
+
+      # @attr [String] solc_flags
+      attr_reader :solc_flags
+
+      # @attr [String] output_directory, can be configured outside
+      attr_accessor :output_directory
+
+      # @attr [String] compiled_ast
+      attr_accessor :compiledAst
+      
+      # ------------------------------------------------------------------
+      # @!group construct & configure
+      
+      def initialize( options = {} )
+
+        @options = options
+        @logger = getLogger( nil, options )
+        @logger.info "#{__method__}: initalized"
+
+        initDefaults
+        
+      end
+
+      # set configuration values
+      def initDefaults
+        @output_directory ||= "tmp/solidity"
+        @solc_flags   ||= "--combined-json ast -o #{output_directory}"
+      end
+
+      # @return [String] path to solc executable
+      def solc_command
+        @solc_command ||= "#{Dir.pwd}/solc/solidity/build/solc/solc"
+      end
+      
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group public services
+
+      ##
+      # Call +solc_command+ to compile solidity source in +sourcePath+
+      # to create abstract syntax tree file in +compiledAst+
+      #
+      # @param [String|String:Array] soliditySource to solidity file to compile
+      #
+      def compile( soliditySource )
+
+        self.compiledAst = nil
+
+        sourcePaths = soliditySource.is_a?( Array ) ? soliditySource : [soliditySource]
+
+        # Check sourcePath & compiler command
+        sourcePaths.each do |sourcePath|
+          @logger.info "#{__method__}: solc_command=#{solc_command}, solc_flags=#{solc_flags}, sourcePath=#{sourcePath}, pwd=#{Dir.pwd}"
+          raise SbuilderEtherumCompileException, "Solidity source file '#{sourcePath}': no such file" unless File.exists?( sourcePath )
+        end
+        raise SbuilderEtherumCompileException, "Solidity output directory '#{output_directory}': no such directory" unless Dir.exists?( output_directory )        
+        raise SbuilderEtherumCompileException, "Solidity compiler '#{solc_command}': executabable not found" unless which( solc_command )
+        
+
+        # ast named after first source file, must not exist
+        astPath = ast_path( sourcePaths.first )
+        File.delete( astPath ) if File.exists?( astPath )
+        raise SbuilderEtherumCompileException, "Solidity ast file '#{astPath}': could not remove" if File.exists?( astPath )
+
+
+        cmd = "#{solc_command} #{solc_flags} #{sourcePaths.join(' ')} > #{astPath}"
+        @logger.info "#{__method__}: cmd:#{cmd}"
+        out,err,exit_status = Open3.capture3( cmd )
+        
+        @logger.info "#{__method__}: out=#{out}, err=#{err}, st=#{exit_status}"
+        raise SbuilderEtherumCompileException, <<-EOS if exit_status != 0
+        Error compiling #{sourcePaths.join(',')}
+
+        Compiler : #{solc_command}
+        Flags : #{solc_flags}
+
+        Exit status: #{exit_status}
+
+        Stderr:  #{err}
+
+        Output:  #{out}
+
+        EOS
+
+        
+        # check that ast file was created
+        raise SbuilderEtherumCompileException, <<-EOS unless File.exists?( astPath )
+        Error compiling #{sourcePaths.join(',')}
+
+        Compiler command
+
+        #{cmd}
+
+        in cwd #{Dir.getwd}
+  
+        failed to create solidity ast file '#{astPath}'
+
+        EOS
+
+
+        # return path to compiled ast file                                                                         
+        self.compiledAst = astPath
+        @logger.info "#{__method__}, compiledAst=#{compiledAst}"
+        compiledAst                                                                         
+      end
+      
+      # @!endgroup
+
+
+      # ------------------------------------------------------------------
+      # @!group configuration
+
+      # @return [String] path to a file in output directory
+      def ast_path( sourcePath )
+        "#{output_directory}/#{ast_file(sourcePath)}"
+      end
+
+
+      # @return [String] filename for abstract syntax tree for
+      # solidity source in +sourcePath+
+      def ast_file( sourcePath )
+        "#{File.basename( sourcePath, File.extname(sourcePath) )}.sol_json.ast"
+      end
+      
+      # @!endgroup
+
+      # ------------------------------------------------------------------
+      # @!group utilities
+
+      # @return [Boolean] true if +cmd+ points to executable or it is
+      # found in PATH
+      def which( cmd )
+        File.exists?( cmd ) && File.executable?( cmd ) ||
+          ENV['PATH'].split(':').select do |folder|
+          f = "#{folder}/#{cmd}"
+          File.exists?(f) && File.executable?(f)
+        end.any?
+      end
+
+      # @!endgroup      
+      
+
+    end
+    
+  end
+end