sbuilder-ial 0.0.1

data/lib/ethereum/api.rb

@@ -0,0 +1,669 @@
+
+require 'sbuilder-ial'
+
+module Sbuilder
+  module Ial
+    class Ethereum
+
+      # ------------------------------------------------------------------
+      # Infra macros
+      INFRA_PUSH='Push'
+      INFRA_HEAD='Head'
+      INFRA_TAIL='Tail'            
+      INFRA_POP='Pop'
+      INFRA_NEXT_ID='NextId'
+      INFRA_UPDATE_TOP='UpdateTop'      
+      INFRA_READ_RETURN='InfrastructureServiceGetStatus'
+      INFRA_SVC_STACK_ACCEPT='PropageTopAndPop'
+      INFRA_SVC_STACK_REJECT='Tail'      
+      
+
+      # ------------------------------------------------------------------
+      # Constants: domains
+      
+      DOMAIN_ADDRESS = "eth_address"
+      DOMAIN_VALUE = "eth_value"
+      DOMAIN_GAS = "eth_gas"
+      DOMAIN_CODE_HASH = "eth_code_hash"
+      DOMAINS = [ DOMAIN_ADDRESS, DOMAIN_VALUE, DOMAIN_GAS, DOMAIN_CODE_HASH]
+      # DOMAIN_BOOLEAN = "BOOLEAN"
+      # DOMAIN_DEFAULT = "default" # when no better candidate not found
+
+      # Ethereum field names
+      FIELD_NAME_ADDRESS = "address"
+      FIELD_NAME_CODE_HASH = "codeHash"      
+      FIELD_NAME_BALANCE = "balance"
+
+      
+      FIELD_NAME_CID = "cid"
+      FIELD_NAME_ORIGINATOR = "originator"
+      FIELD_NAME_SENDER = "sender"
+      FIELD_NAME_RECIPIENT = "recipient"
+      FIELD_NAME_BENEFICIARY = "beneficiary"
+      # FIELD_NAME_VALUE = "value"
+      FIELD_NAME_RESULT = "result"      
+      FIELD_NAME_GAS = "gas"
+      FIELD_NAME_STATUS = "status"      
+      
+
+      # Variables
+      
+      VARIABLE_ACCOUNTS = "accounts"
+      VARIABLE_ADDRESS = "address"
+      VARIABLE_MINED = "mined"
+      VARIABLE_STORAGE_ROOT = "storageRoot"
+      
+      VARIABLE_ACCOUNTS_TEMP = "accounts_temp"
+      VARIABLE_STORAGE_ROOT_TEMP = "storageRoot_temp"
+
+      VARIABLE_LOCAL_ID = 'thisId'
+
+      VARIABLE_ADDRESS_FREE = "address_free"      
+
+      VARIABLES = [
+        VARIABLE_ACCOUNTS,
+        VARIABLE_ADDRESS,
+        VARIABLE_MINED,
+        VARIABLE_STORAGE_ROOT,
+        VARIABLE_ACCOUNTS_TEMP,
+        VARIABLE_STORAGE_ROOT_TEMP,
+        VARIABLE_ADDRESS_FREE,
+      ]
+
+      # Macros
+      MACRO_SERVICE_PUSH = "ethereum_service_push"
+      MACRO_SERVICE_POP = "ethereum_service_pop"
+      MACRO_SERVICE_DONE = "ethereum_service_done"
+      MACRO_SERVICE_START = "ethereum_service_start"            
+
+      # Operators
+      OPERATOR_GASPRICE = 'gasPrice'
+      OPERATOR_INTRINSICGAS = 'intrinsicGas'
+      OPERATOR_TRANSACTIONGAS = 'transactionGas'
+      OPERATOR_UPFRONT_COST = 'upFrontCost'
+      OPERATOR_GAS_VALUE = 'gasValue'
+
+      
+      
+      # ------------------------------------------------------------------
+      # API
+      class << self
+
+        def domainDefinition( d )
+          Sbuilder::Ial.domain{ name  d }          
+          # ->(d) { Sbuilder::Ial.domain{ name  d } }          
+        end
+
+        def variableDefinition( v, init=nil)
+          # ->(v,init=nil) { Sbuilder::Ial.variable{ name  v; init init } }
+          Sbuilder::Ial.variable do
+            name  v
+            init init
+          end
+        end
+        
+        # @return [ReferenceExpression] reference to domain 'd'
+        def domainRef( d )
+          return d unless d.is_a?( String )          
+          # ->(d) { Sbuilder::Ial.referenceExpression { domain  d } }          
+          Sbuilder::Ial.referenceExpression do
+            domain  d
+          end
+        end
+
+        # @return [ReferenceExpression] reference to variable 'v'
+        def variableRef( v )
+          return v unless v.is_a?( String )
+          Sbuilder::Ial.referenceExpression { variable v }
+        end
+
+        # @return [TlaExpression] reference formal parameter 'v'
+        def parameterRef( v )
+          return v unless v.is_a?( String )          
+          Sbuilder::Ial.referenceExpression { parameter v }
+        end
+
+        # @return [ReferenceExpression] reference to local varibale 'v'
+        def localRef( v )
+          return v unless v.is_a?( String )
+          Sbuilder::Ial.referenceExpression { local v }
+        end
+        
+        
+        def fieldName( v )
+          return v unless v.is_a?( String )
+          Sbuilder::Ial.referenceExpression { parameter v }
+        end
+
+        def constant( v )
+          return v if v.is_a?( Sbuilder::Ial::Model::Expression )                    
+          Sbuilder::Ial.constantExpression { const v }
+        end
+        
+
+        # return [Tlaexpression] expression producing value 'v'
+        #
+        def plainName( v )
+          return v if v.is_a?( Sbuilder::Ial::Model::Expression )          
+          Sbuilder::Ial.referenceExpression { plain v }
+        end
+
+        def tlaIfExpression( condExpr, thenExpr, elseExpr )
+          Sbuilder::Ial.tlaExpression do
+            template :IF_expression
+            args condExpr
+            args thenExpr
+            args elseExpr
+          end          
+        end
+
+        def tlaExceptExpression( variable, excepts )
+          Sbuilder::Ial.tlaExpression do
+            template :EXCEPT_expression
+            args variable
+            args excepts
+          end         
+        end
+
+        def tlaSetGenerate( mapExpression, iterationVariable, baseSetToIterate )
+          Sbuilder::Ial.tlaExpression do
+            template :set_generate
+            args mapExpression
+            args iterationVariable
+            args baseSetToIterate
+          end
+        end
+
+        # @return [TlaExpression] expression 'rec.fieldName' to access
+        # field 'fldName' in record 'rec'
+        def fieldRef( rec, fldName )
+          Sbuilder::Ial.tlaExpression do
+            template :record_field
+            args plainName(rec)
+            args plainName(fldName)
+          end
+        end
+
+        # @return [TlaExpression] expression for binary exression  'left-op-right'
+        def binaryOperator( left, op, rigth )
+          Sbuilder::Ial.binaryExpression(){ expression left, op, rigth }
+        end
+
+        # @return [TlaExpression] expression for 'operator( *args )',
+        # where operator define 
+        def operatorCall( ialOperator, *args )
+          Sbuilder::Ial.operatorExpression{ called ialOperator; args args }
+        end
+
+        # @return [TlaExpression] operator calle expression infraOperator( *args )
+        def infraOperatorCall( infraOperator, *args )
+          Sbuilder::Ial.operatorExpression{ called infraOperator; infrastructureService true; args args }
+        end
+
+        # @return [TlaExpression] set constructor for an element 'e' :: "{ e }"
+        def toSet( e )
+          Sbuilder::Ial.tlaExpression do
+            template :set
+            args e
+          end
+        end
+
+
+        # @return [sTla] template to create one TLA record key val
+        # mapping
+        #
+        # plainName(k) |-> eval(v).
+        #
+        # Example: address |-> NextId(address_free)
+        def toRecordKeyVal( k,v )
+          Sbuilder::Ial.tlaExpression do
+            template :record_field_definition
+            args plainName(k)
+            args v
+          end
+        end
+
+        # Create TLA record entry for 'hash'. Hash keys represent
+        # record fields, and hash values are record field value
+        # expression to evaluate.
+        #
+        # Example: [ k1 |-> TRUE, k2 -> Nil ]
+        #
+        def toRecord( hash )
+          Sbuilder::Ial.tlaExpression do
+            template :record
+            args  hash.keys.map { |k| toRecordKeyVal( k, hash[k] ) }
+          end
+        end
+        
+        # @return [TlaExpression] sequence constructor for an element(s) 'e' :: "<< eval(e) >>"
+        def toSequence( e )
+          Sbuilder::Ial.tlaExpression do
+            template :sequence
+            args e unless e.nil?
+          end
+        end
+
+        def emptySequence
+          toSequence( nil )
+        end
+        
+
+        # @return [TlaExpression] expression for non Nil elements in domain 'domainName', 
+        # more formally return  'domainRef(domainName) \ { Nil}'
+        def domainSetMinusNil( domainName )
+          Sbuilder::Ial.binaryExpression do
+            expression domainRef(domainName), :set_minus, toSet(:nil)
+          end
+        end
+
+        # ------------------------------------------------------------------
+        # common (Ethreum ) expressions
+
+        # @return [OperatorExpression] expression binding to next free
+        # id in variable 'address_free' :: NextId( address_free, Nil )
+        #
+        # Example: NextId( address_free,Nil );
+        def nextId
+          infraOperatorCall( INFRA_NEXT_ID, variableRef(VARIABLE_ADDRESS_FREE), :nil )
+        end
+
+        # @return [ReferenceExpression] this address of current id (in local variable
+        def currentId
+          localRef(VARIABLE_LOCAL_ID)
+        end
+
+        # @return [Expression] expression referencing storage holding
+        # account during transaction execution
+        def accountVariableExec
+          variableRef(VARIABLE_ACCOUNTS_TEMP)
+        end
+
+        def contractVariableExec
+          variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+        end
+        
+
+        # @return [Hash] hash for contract of type 'codeHash'
+        # address/identity 'nextId' with initial balance 'value'
+        def newContractHash( codeHash:, id:, value: )
+          {
+            FIELD_NAME_ADDRESS =>id,
+            FIELD_NAME_CODE_HASH => codeHash,
+            FIELD_NAME_BALANCE => value,
+          }
+        end
+
+        def newStrorageRoot( codeHash:, id:, members: )
+          entry = {
+            FIELD_NAME_ADDRESS =>id,
+            FIELD_NAME_CODE_HASH =>codeHash,
+          }.merge( members.inject({}){|h,(k,v)| h[k] = constant(v); h })
+          entry
+        end
+        
+        
+        
+        
+
+        # ------------------------------------------------------------------
+        # common statement (single)
+
+        def stmtOutuput( txt )
+          Sbuilder::Ial.printStatement() { msg txt } 
+        end
+
+        # @return [Statement] statement assigning expression 'e' to
+        # local variable 'v'
+        def stmtAssignLocal( v, e )
+          Sbuilder::Ial.assignStatement(){
+            local localRef(v)
+            expression e
+          }          
+        end
+
+
+        # @return [Statement] statement assigning expression 'e' to
+        # variable 'v'
+        #
+        #  variableRef('v') := eval('e').
+        # 
+        def stmtAssign( v, e )
+          Sbuilder::Ial.assignStatement(){
+            variable variableRef(v)
+            expression e
+          }          
+        end
+        
+
+        # @return [Statement] statement to update variable 'v' with
+        # expression
+        #
+        # eval('v') := eval('v') \op eval('e').
+        #
+        # Example: eth_address_free := eth_address_free \ { NextId(
+        # eth_address_free, input.address ) };
+        def stmtUpdateVariable( v, op, e )
+          stmtAssign( v, binaryOperator(variableRef(v), op, e ) )
+        end
+
+
+        # @return [Statement] statement to assign variable 'v' a value
+        # where set containing expression 'e', { 'e' }, is added to
+        # the set in the first element of the sequence in 'v'.
+        #
+        #  variableRef(v) := UpdateTop( Head(variableRef(v)) \union { eval(e) }
+        # 
+        #
+        # Example: ial_accounts_temp := UpdateTop( Head( ial_accounts_temp ) \union { Nil }  )
+        def stmtUpdateSequenceHead( v, e )        
+          Sbuilder::Ial.assignStatement(){
+            variable variableRef(v)
+            expression infraOperatorCall( INFRA_UPDATE_TOP, variableRef(v), binaryOperator(infraOperatorCall(INFRA_HEAD, variableRef(v)), :union, toSet(e) ))
+          }          
+        end
+
+        # ethrereum statements
+
+        #
+        # @param [memberVariables] memberVariables, key member variable name,
+        # value constant expression to initialize with
+        #
+        # @param [value] balance to set on contract
+        #
+        # @return [Statement:Array] statements array to create
+        # contract type 'codeHash' with initial balance 'value', and
+        # member variables initilized with 'memberVariables'
+        def stmtsCreateContract( codeHash:, value:, memberVariables: )
+          [
+            # debug message
+            # stmtOutuput( "#{__method__}" ),
+            # entry to account 
+            stmtUpdateSequenceHead( VARIABLE_ACCOUNTS_TEMP, toRecord( newContractHash(codeHash: codeHash, value: value, id: nextId ))  ),
+            # entry to storage root
+            stmtUpdateSequenceHead( VARIABLE_STORAGE_ROOT_TEMP, toRecord( newStrorageRoot(codeHash: codeHash, id: nextId, members: memberVariables ))),
+            #
+            stmtAssignLocal( VARIABLE_LOCAL_ID, nextId ),
+            # consume next nextId
+            stmtUpdateVariable( VARIABLE_ADDRESS_FREE, :set_minus, toSet(nextId) ),
+          ]
+        end
+
+
+        # @return [Statement:Array] statements array to update
+        # contract member variables in hash 'memberVariable' on
+        # contract pointed by 'addressRef' in ethreum transaction
+        # context 'VARIABLE_STORAGE_ROOT_TEMP'.
+
+        def stmtsUpdateContract( addressRef:, memberVariable: nil)
+          [
+            # stmtOutuput( "#{__method__} starting" ),
+            stmtAssign( VARIABLE_STORAGE_ROOT_TEMP, exprUpdateContract( addressRef, memberVariable) )
+          ]
+        end
+
+        # @param [Hash] memberVariable keys are record fieds to set,
+        # values are expression to set
+        #
+        private def exprUpdateContractExpression( memberVariable )
+          raise "Must give at least one update" unless memberVariable && memberVariable.keys.any?
+           memberVariable.keys.map { |k|  binaryOperator( fieldRef( "!", k ), Sbuilder::Ial::Model::Constants::OPERATOR_EQUAL , memberVariable[k] ) }
+        end
+        
+        private def exprUpdateContract( addressRef, memberVariable )
+
+          contractRef = variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+          iterationVariableRef = plainName( 'a' )
+
+          updateExpression = exprUpdateContractExpression( memberVariable )
+
+          condExpr = binaryOperator( fieldRef(iterationVariableRef, FIELD_NAME_ADDRESS), :equal,  addressRef )
+          thenExpr = tlaExceptExpression( iterationVariableRef, updateExpression )
+          elseExpr = iterationVariableRef
+          
+          mapExpression = tlaIfExpression( condExpr, thenExpr, elseExpr )
+          
+          baseSetToIterate = infraOperatorCall(INFRA_HEAD, contractRef )
+          updateExpression = tlaSetGenerate( mapExpression, iterationVariableRef, baseSetToIterate )
+
+          # update contract data in top of stack
+          infraOperatorCall( INFRA_UPDATE_TOP, contractRef, updateExpression )
+          
+        end
+
+        # transactions i.e. contract constructor & contract function
+        # call
+        
+        def constructor( contract:, req: [], rply: [] )
+          operation = ""
+          Sbuilder::Ial.transaction() do 
+            name contract
+            # well known local variable holding identity of contract
+            # being created. 
+            locals VARIABLE_LOCAL_ID
+            request  req.is_a?(Array) ? req : [req]
+            response rply.is_a?(Array) ? rply : [rply]
+            entryBlock do
+              # output "entry block called"
+              callMacro MACRO_SERVICE_START
+              callService contract, operation, plainName('input')
+            end
+            block do
+              stmtOutuput "preamble"
+              # 
+              # transaction implementation here
+              # 
+              yield self
+              stmtOutuput "epiloque"
+            end
+          end
+        end
+        
+
+        # ------------------------------------------------------------------
+        # Snippets for ethereum implementation
+        
+      end
+
+      class << self
+
+        # e.g. eth_storageRoot_temp :=  Push( eth_storageRoot_temp, Head( eth_storageRoot_temp )) ;
+        private def pushServiceStateVariable( variableName )
+          infraOperatorCall( INFRA_PUSH, variableRef(variableName), infraOperatorCall(INFRA_HEAD, variableRef(variableName)) )                          
+        end
+
+        # Create macro to inialize transaction 
+        def operator_gasPrice
+          Sbuilder::Ial.operator(){
+            name OPERATOR_GASPRICE
+            expression 0
+          }
+
+        end
+
+        # Create macro to inialize transaction
+
+        # gasValue( gas ) == gas * gasPrice
+        def operator_gasValue
+          Sbuilder::Ial.operator(){
+            name OPERATOR_GAS_VALUE
+            gas = 'gas'
+            parameters gas
+            expression binaryOperator(parameterRef(gas), :mult, operatorCall(OPERATOR_GASPRICE))
+          }
+        end
+
+        # Create macro to inialize transaction 
+        def operator_intrinsicGas
+          Sbuilder::Ial.operator(){
+            name OPERATOR_INTRINSICGAS
+            expression 1
+          }
+        end
+        
+
+        # Create macro to inialize transaction 
+        def operator_transactionGas
+          Sbuilder::Ial.operator(){
+            name OPERATOR_TRANSACTIONGAS
+            expression 1
+          }
+        end
+
+        # upFrontCost( request ) == request.value + gasPrice *  intrinsicGas
+        def operator_upFrontCost
+          Sbuilder::Ial.operator(){
+            request = 'request'
+            name OPERATOR_UPFRONT_COST
+            parameters request
+            expression binaryOperator( fieldRef(parameterRef(request), 'value' ), :plus,  binaryOperator( operatorCall(OPERATOR_INTRINSICGAS), :mult, operatorCall(OPERATOR_GASPRICE)))
+          }
+        end
+        
+        
+        # Create macro to inialize transaction 
+        def service_start
+          Sbuilder::Ial.macro do
+            name MACRO_SERVICE_START
+            block {
+              assignTo {
+                variable variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+                expression toSequence( variableRef(VARIABLE_STORAGE_ROOT ))
+              }
+              assignTo {
+                variable variableRef(VARIABLE_ACCOUNTS_TEMP)
+                expression toSequence( variableRef(VARIABLE_ACCOUNTS ))
+              }
+            }
+            
+          end
+        end
+
+
+        # Create a macro to push 'service' state to transaction state
+        def service_push
+
+          Sbuilder::Ial.macro do
+            name MACRO_SERVICE_PUSH
+            block {
+              assignTo {
+                variable variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+                expression pushServiceStateVariable(VARIABLE_STORAGE_ROOT_TEMP)
+              }
+              assignTo {
+                variable variableRef(VARIABLE_ACCOUNTS_TEMP)
+                expression pushServiceStateVariable(VARIABLE_ACCOUNTS_TEMP)
+              }
+            }
+          end
+        end
+
+        def service_pop
+          
+          Sbuilder::Ial.macro do
+            p1 = 'interface'
+            
+            name MACRO_SERVICE_POP
+            parameters p1
+            block {
+
+              ifThen( binaryOperator( infraOperatorCall(INFRA_READ_RETURN, parameterRef(p1)), :equal,  true ) ) {
+                
+                assignTo {
+                  variable variableRef(VARIABLE_STORAGE_ROOT_TEMP, )
+                  expression infraOperatorCall( INFRA_SVC_STACK_ACCEPT, variableRef(VARIABLE_STORAGE_ROOT_TEMP))
+                }
+                
+                assignTo {
+                  variable variableRef(VARIABLE_ACCOUNTS_TEMP)
+                  expression infraOperatorCall( INFRA_SVC_STACK_ACCEPT, variableRef(VARIABLE_ACCOUNTS_TEMP))
+                }
+                
+              }.elseThen {
+                
+                assignTo {
+                  variable variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+                  expression infraOperatorCall(INFRA_SVC_STACK_REJECT, variableRef(VARIABLE_STORAGE_ROOT_TEMP))
+                }
+                
+                assignTo {
+                  variable variableRef(VARIABLE_ACCOUNTS_TEMP)
+                  expression infraOperatorCall(INFRA_SVC_STACK_REJECT, variableRef(VARIABLE_ACCOUNTS_TEMP))
+                }
+                
+              }
+            }
+          end
+
+        end
+
+        def service_done
+          
+          Sbuilder::Ial.macro do
+            p1 = 'interface'
+            
+            name MACRO_SERVICE_DONE
+            parameters p1
+            block {
+
+
+              ifThen( binaryOperator( infraOperatorCall(INFRA_READ_RETURN, parameterRef(p1)), :equal,  true ) ) {
+                assignTo {
+                  variable variableRef(VARIABLE_STORAGE_ROOT, )
+                  expression infraOperatorCall( INFRA_SVC_STACK_ACCEPT, variableRef(VARIABLE_STORAGE_ROOT_TEMP))
+                }
+                assignTo {
+                  variable variableRef(VARIABLE_ACCOUNTS)
+                  expression infraOperatorCall( INFRA_SVC_STACK_ACCEPT, variableRef(VARIABLE_ACCOUNTS_TEMP))
+                }
+              }
+
+              assignTo {
+                variable variableRef(VARIABLE_STORAGE_ROOT_TEMP)
+                expression true
+              }
+              
+              assignTo {
+                variable variableRef(VARIABLE_ACCOUNTS_TEMP)
+                expression true
+              }
+
+            } # block
+          end
+        end
+
+        # ------------------------------------------------------------------
+        # Library
+
+
+        # @return [(Snippet|Domain):Array] model element to load to 
+        def library
+          [
+            domainDefinition(DOMAIN_ADDRESS),
+            domainDefinition(DOMAIN_VALUE),
+            domainDefinition(DOMAIN_GAS),
+            domainDefinition(DOMAIN_CODE_HASH),
+            variableDefinition(VARIABLE_ACCOUNTS),
+            variableDefinition(VARIABLE_ADDRESS),
+            variableDefinition(VARIABLE_MINED),
+            variableDefinition(VARIABLE_ADDRESS_FREE, domainSetMinusNil(DOMAIN_ADDRESS) ),
+            variableDefinition(VARIABLE_STORAGE_ROOT),
+            variableDefinition(VARIABLE_ACCOUNTS_TEMP, emptySequence ),
+            variableDefinition(VARIABLE_STORAGE_ROOT_TEMP, emptySequence ),
+            # Macros
+            operator_gasPrice,
+            operator_transactionGas,
+            operator_intrinsicGas,
+            operator_upFrontCost,
+            operator_gasValue,            
+            # Macros
+            service_start,            
+            service_push,
+            service_pop,
+            service_done,            
+          ]
+        end
+      end # self 
+    end #  class Ethereum
+  end
+end

data/lib/ethereum.rb

@@ -0,0 +1 @@
+require_relative 'ethereum/ethereum.rb'